hibernate查询语言--hql

最新推荐文章于 2021-10-19 17:05:02 发布
最新推荐文章于 2021-10-19 17:05:02 发布
阅读量452 收藏 1
点赞数
分类专栏： hibernate 文章标签： hibernate 面向对象 hql 框架 orm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jie_liang/article/details/77249124
版权

hql(hibernate query language)是一种查询语言。hql是完全面向对象的查询语言，可以理解如继承，多态，关联等概念。hql区分大小写，但是对应sql关键字（select、from、where）不区分。

新建一个java项目，结构如下：


实体类Book代码

@Entity
@Table(name="t_book")
@FilterDef(name="bf",parameters={@ParamDef(name="id",type="integer")})
@Filter(name="bf",condition="id <:id")
public class Book {
	@Id
	@GeneratedValue(strategy=GenerationType.AUTO)
	private int id;
	private String name;
	private double price;
	private String author;
	private Date pubDate;
	@ManyToOne(cascade=CascadeType.ALL)
	@JoinColumn(name="category_id")
	private Category category;
	public Book() {
	}
	public Book(String name, double price) {
		super();
		this.name = name;
		this.price = price;
	}
	@Override
	public String toString() {
		return "Book [id=" + id + ", name=" + name + ", price=" + price
				+ ", author=" + author + ", pubDate=" + pubDate + "]";
	}
	//省略get/set
}
Book.hbm.xml配置文件 

<hibernate-mapping package="com.test.pojo">  
    <class name="Book" table="t_book">  
        <id name="id">  
            <generator class="identity" />  
        </id>  
        <many-to-one name="category" class="Category" column="category_id" />  
        <property name="author" />  
        <property name="name" column="book_name" />  
        <property name="price" />  
        <property name="pubDate" />  
        <!-- 使用过滤器 -->  
        <filter name="bookFilter" condition="id=:id"></filter>  
  
    </class>  
    <!-- 过滤器定义 : 定义参数 -->  
    <filter-def name="bookFilter">  
        <filter-param name="id" type="integer" />  
    </filter-def>  
  
</hibernate-mapping>
Category实体类 

@Entity
@Table
public class Category {
	@Id
	@GeneratedValue(strategy=GenerationType.AUTO)
	private int id;
	private String name;
	//在多对一中的一端，设置了OneToMany后，必须指定mappedBy=多端的属性，这里的多端是Book
	@OneToMany(mappedBy="category")
	private Set<Book> books=new HashSet<Book>();
	//省略get/set
}

Category.hbm.xml配置文件 

<hibernate-mapping package="com.test.pojo">  
    <class name="Category" >  
        <id name="id" >  
            <generator class="identity" />  
        </id>  
        <property name="name" />  
        <set name="books" inverse="true">  
            <key>  
                <column name="category_id" />  
            </key>  
            <one-to-many class="Book" />  
        </set>  
    </class>  
  
</hibernate-mapping>
hibernate.cfg.xml配置文件 

<hibernate-configuration>
<session-factory>
	<property name="connection.driver_class">
		com.mysql.jdbc.Driver
	</property>
	<property name="connection.url">
		jdbc:mysql:///hibernatetest
	</property>
	<property name="connection.username">root</property>
	<property name="connection.password">root</property>
	<property name="dialect">
		org.hibernate.dialect.MySQLDialect
	</property>
	<property name="show_sql">true</property>
	<property name="format_sql">true</property>
	<property name="hbm2ddl.auto">update</property>
 	
 	<mapping resource="com/test/pojo/Book.hbm.xml" /> 
 	<mapping resource="com/test/pojo/Category.hbm.xml" /> 
 	
<!-- 	<mapping class="com.test.pojo.Book" /> -->
<!-- 	<mapping class="com.test.pojo.Category" /> -->
</session-factory>
</hibernate-configuration>
HibernateUtil类 

public class HibernateUtil {
	private static Configuration cfg=null;
	private static SessionFactory factory=null;
	private static Session session=null;
	static{
		cfg=new Configuration().configure();
		factory=cfg.buildSessionFactory(new StandardServiceRegistryBuilder()
		        .applySettings(cfg.getProperties()).build());
	}
	public static Session getSession(){
		if(factory!=null)
			return session=factory.openSession();
		factory=cfg.buildSessionFactory(new StandardServiceRegistryBuilder()
		        .applySettings(cfg.getProperties()).build());
		return session=factory.openSession();
	}
	public static void closeSession(){
		if(session!=null && session.isOpen())
			session.close();
	}
}

HibernateTest测试类（该测试类所需的实体类使用注解方式或*.hbm.xml配置文件方式都可以测试，只需将hibernate.cfg.xml配置实体类映射修改即可） 

public class HibernateTest {
	@Test
	public void testCreateDB(){
		Configuration cfg=new Configuration().configure();
		SchemaExport se=new SchemaExport(cfg);
		se.create(true, true);
	}
	@Test
	public void testSave(){
		Session session=HibernateUtil.getSession();
		Transaction tx=session.beginTransaction();
		Category category=new Category();
		category.setName("文学");
		Category category1=new Category();
		category1.setName("科幻");
		Category category2=new Category();
		category2.setName("历史");
		Category category3=new Category();
		category3.setName("言情");
		Category category4=new Category();
		category4.setName("漫画");
		Category category5=new Category();
		category5.setName("悬疑");
		Book book=new Book();
		book.setName("读者");
		book.setPrice(21.5);
		book.setAuthor("读者出版传媒有限公司");
		book.setPubDate(new Date());
		book.setCategory(category);
		Book book1=new Book();
		book1.setName("蓝血人");
		book1.setPrice(50);
		book1.setAuthor("卫斯理");
		book1.setPubDate(new Date());
		book1.setCategory(category1);
		Book book2=new Book();
		book2.setName("傲慢与偏见");
		book2.setPrice(80);
		book2.setAuthor("简.奥斯丁");
		book2.setPubDate(new Date());
		book2.setCategory(category3);
		Book book3=new Book();
		book3.setName("中国历史");
		book3.setPrice(21.5);
		book3.setAuthor("人民");
		book3.setPubDate(new Date());
		book3.setCategory(category2);
		Book book4=new Book();
		book4.setName("七龙珠");
		book4.setPrice(21.5);
		book4.setAuthor("不知道");
		book4.setPubDate(new Date());
		book4.setCategory(category4);
		Book book5=new Book();
		book5.setName("名侦探柯南");
		book5.setPrice(50);
		book5.setAuthor("宫崎骏");
		book5.setPubDate(new Date());
		book5.setCategory(category5);
		
		
		session.save(book);
		session.save(book1);
		session.save(book2);
		session.save(book3);
		session.save(book4);
		session.save(book5);
		tx.commit();
		HibernateUtil.closeSession();
	}
	@Test
	public void testGet(){
		Session session=HibernateUtil.getSession();
		Transaction tx=session.beginTransaction();
		Book book=(Book) session.get(Book.class, 1);
		System.out.println(book.getName()+"----"+book.getCategory().getName());
		tx.commit();
		HibernateUtil.closeSession();
	}
	//hql---hibernate query language
	//查询单个属性
	@Test
	public void testQuery1(){
		//查询所有书名
		//创建Query对象
		Session session=HibernateUtil.getSession();
		Transaction tx=session.beginTransaction();
		//Book 大写表示是com.test.pojo.Book类
		String hql="select name from Book";
		Query query=session.createQuery(hql);
		//list()返回查询结果
		//返回结果的类型是根据查询的列决定的
		List<String> list=query.list();
		for(String bookname:list){
			System.out.println(bookname);
		}
		tx.commit();
		HibernateUtil.closeSession();
	}
	//查询多个属性
	@Test
	public void testQuery2(){
		//查询所有书的名称和价格
		//创建Query对象
		Session session=HibernateUtil.getSession();
		Transaction tx=session.beginTransaction();
		//Book 大写表示是com.test.pojo.Book类
		//list()返回查询结果
		//查询多个列时 返回结果是数组集合  数组中元素的类型是由查询列来决定
		List<Object[]> list=session.createQuery("select name,price from Book").list();
		for(Object[] objs:list){
			System.out.println(objs[0]+"---"+objs[1]);
		}
		tx.commit();
		HibernateUtil.closeSession();
	}
	//查询多个列时将查询结果封装为对象集合
	@Test
	public void testQuery3(){
		//查询所有书的名称和价格
		//创建Query对象
		Session session=HibernateUtil.getSession();
		Transaction tx=session.beginTransaction();
		//Book 大写表示是com.test.pojo.Book类
		//list()返回查询结果
		//查询多个列时 返回结果是数组集合  数组中元素的类型是由查询列来决定
		List<Book> list=session.createQuery("select new Book(name,price) from Book").list();
		for(Book b:list){
			System.out.println(b);
		}
		tx.commit();
		HibernateUtil.closeSession();
	}
	/**
	 * 别名的使用
	 */
	@Test
	public void testQuery4(){
		//查询所有书的名称和价格
		//创建Query对象
		Session session=HibernateUtil.getSession();
		Transaction tx=session.beginTransaction();
		//Book 大写表示是com.test.pojo.Book类
		//list()返回查询结果
		//查询多个列时 返回结果是数组集合  数组中元素的类型是由查询列来决定
		List<Book> list=session.createQuery("select new Book(b.name,b.price) from Book as b").list();
		for(Book b:list){
			System.out.println(b);
		}
		tx.commit();
		HibernateUtil.closeSession();
	}
	/**
	 * 查询所有列    不能使用*号
	 */
	@Test
	public void testQuery5(){
		//查询所有书的名称和价格
		//创建Query对象
		Session session=HibernateUtil.getSession();
		Transaction tx=session.beginTransaction();
		//Book 大写表示是com.test.pojo.Book类
		//list()返回查询结果
		//查询多个列时 返回结果是数组集合  数组中元素的类型是由查询列来决定
		List<Book> list=session.createQuery("from Book").list();
		//查询所有列不能使用select * 可以使用别名 select b from Book b
		for(Book b:list){
			System.out.println(b);
		}
		tx.commit();
		HibernateUtil.closeSession();
	}
	//条件查询 占位符从0开始
	//使用setInteger（0,4）或者是使用setParameter（0,4），setParameter不用理会参数类型
	@Test
	public void testQuery6(){
		//查询所有书的名称和价格
		//创建Query对象
		Session session=HibernateUtil.getSession();
		Transaction tx=session.beginTransaction();
		List<Book> list=session.createQuery("from Book b where id<?")
				.setInteger(0, 4)
				.list();
		//查询所有列不能使用select * 可以使用别名 select b from Book b
		for(Book b:list){
			System.out.println(b);
		}
		tx.commit();
		HibernateUtil.closeSession();
	}
	//条件查询 命名查询--设置条件参数的名称 以冒号开头后更改名称  设置参数时，只需指定名
	@Test
	public void testQuery7(){
		//查询所有书的名称和价格
		//创建Query对象
		Session session=HibernateUtil.getSession();
		Transaction tx=session.beginTransaction();
		List<Book> list=session.createQuery("from Book b where id<:id")
				.setParameter("id", 4)
				.list();
		for(Book b:list){
			System.out.println(b);
		}
		tx.commit();
		HibernateUtil.closeSession();
	}
	/**
	 * 分页查询
	 */
	@Test
	public void testQuery8(){
		//查询所有书的名称和价格
		//创建Query对象
		Session session=HibernateUtil.getSession();
		Transaction tx=session.beginTransaction();
		List<Book> list=session.createQuery("from Book b")
				.setFirstResult(0)  //开始显示的记录下标(currentPage-1)*pageSize
				.setMaxResults(3)  //设置每页记录数pageSize
				.list();
		for(Book b:list){
			System.out.println(b);
		}
		tx.commit();
		HibernateUtil.closeSession();
	}
	/**
	 * 聚合函数--统计查询
	 */
	@Test
	public void testQuery9(){
		//查询图书总数
		Session session=HibernateUtil.getSession();
		Transaction tx=session.beginTransaction();
		//值类型可能是int，long 根据数据大小变化
		Number count= (Number) session.createQuery("select count(b.name) from Book b")
				.uniqueResult();
	//  Object count=  session.createQuery("select max(b.price) from Book b")
	//              .uniqueResult();
		System.out.println("总数："+count.intValue());
		tx.commit();
		HibernateUtil.closeSession();
	}
	/**
	 * 分组查询
	 */
	@Test
	public void testQuery10(){
		//查询图书总数
		Session session=HibernateUtil.getSession();
		Transaction tx=session.beginTransaction();
		List<Object[]> list= session.createQuery("select b.category.name,count(b.id) from Book b group by b.category.name")
				.list();
		for(Object[] objs:list){
			System.out.println(objs[0]+"---"+objs[1]);
		}
		tx.commit();
		HibernateUtil.closeSession();
	}
	/**
	 * 排序
	 */
	@Test
	public void testQuery11(){
		//查询图书总数
		Session session=HibernateUtil.getSession();
		Transaction tx=session.beginTransaction();
		List<Book> list= session.createQuery("from Book order by price desc")
				.list();
		for(Book b:list){
			System.out.println(b);
		}
		tx.commit();
		HibernateUtil.closeSession();
	}
	/**
	 * 对象导航--连接查询
	 */
	@Test
	public void testQuery12(){
		//查询科幻有关书籍
		Session session=HibernateUtil.getSession();
		Transaction tx=session.beginTransaction();
		String hql="from Book b where b.category.name=:name";
		hql="select b from Book b join b.category c where c.name=:name";
		hql="select b from Book b inner join b.category c where c.name=:name";
		List<Book> list= session.createQuery(hql)
				.setString("name", "科幻")
				.list();
		for(Book b:list){
			System.out.println(b);
		}
		tx.commit();
		HibernateUtil.closeSession();
	}
	/**
	 * 左外连接
	 */
	@Test
	public void testQuery13(){
		Session session=HibernateUtil.getSession();
		Transaction tx=session.beginTransaction();
		String hql="select c.name, b.name from Category c left outer join c.books b";
		List<Object[]> list= session.createQuery(hql)
				.list();
		for(Object[] objs:list){
			System.out.println(objs[0]+"----"+objs[1]);
		}
		tx.commit();
		HibernateUtil.closeSession();
	}
	/**
	 * 过滤器的使用--过滤查询--为查询加上某些条件
	 * 1、定义过滤器
	 * 2、使用，加条件
	 * 3、在查询时使得过滤器生效
	 */
	@Test
	public void testQuery14(){
		Session session=HibernateUtil.getSession();
		Transaction tx=session.beginTransaction();
		//配置文件方式，启用过滤器
		session.enableFilter("bookFilter").setParameter("id", 4);
		//注解方式，启用过滤器
//		session.enableFilter("bf").setParameter("id", 4);
		List<Book> list= session.createQuery("from Book")
				.list();
		for(Book b:list){
			System.out.println(b);
		}
		tx.commit();
		HibernateUtil.closeSession();
	}
	
}
具体运行结果在此不做展示，感兴趣的可以自己运行测试。






青春微凉不离殇
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
hibernate查询语言--HQL
03-02
hibernate 查询语言 HQL的使用详解及实例， 个人笔记，适合初学者
4.Hibernate（Hibernate Query Language，Hibernate查询语言）
最新发布
相互学习 共同进步
04-28 131
Hibernate（Hibernate Query Language，Hibernate查询语言）是一种面向对象的查询语言，其中没有表和字段的概念，只有对象和属性的概念。HQL是完全面向对象的，它可以理解继承，多态和关联之类的概念
在Java的Hibernate框架中对数据库数据进行查询操作
F2Zf的博客
07-14 1万+
Hibernate查询语言（HQL）是一种面向对象的查询语言，类似于SQL，但不是对表和列操作，HQL适用于持久对象和它们的属性。 HQL查询由Hibernate转换成传统的SQL查询，这在圈上的数据库执行操作。 虽然可以直接使用SQL语句和Hibernate使用原生SQL，但建议使用HQL尽可能避免数据库可移植性的麻烦，并采取Hibernate的SQL生成和缓存策略的优势。 都像SELECT
Hibernate之HQL
qq_59025975的博客
10-19 2103
1.、什么是HQL？ HQL是Hibernate Query Language的缩写，专属于hibernate的查询语言 2. hql和sql区别/异同 HQL SQL 类名/属性 ...
Hibernate中的HQL语言
weixin_33672400的博客
03-13 330
一、HQL语言简介 HQL全称是Hibernate Query Language，它提供了是十分强大的功能，它是针对持久化对象，直接取得对象，而不进行update,delete和insert等操作。而且HQL是面向对象的，具备继承，多态和关联等特性。 HQL的语法类似于SQL，其常用的方法如下： [select|update|delete 子句] [from 类名列表] [where...
4、hibernate查询语言（HQL）
LemonSnm的博客
07-22 207
1、HQL（Hibernate Query language） hibernate查询语言：主要用面向对象的思维来编写SQl语句，形成hibernate查询语句 1.1、查询所有： From order //order是对象名不是表名 //查询所有 public void findAll(){ //得到seesion ...
Hibernate查询语言HQL.PPT
09-17
Hibernate查询语言HQL.PPT
HQL Hibernate查询语言
12-02
Hibernate配备了一种非常强大的查询语言，这种语言看上去很像SQL。但是不要被语法结构 上的相似所迷惑，HQL是非常有意识的被设计为完全面向对象的查询，它可以理解如继承、多态 和关联之类的概念。
HQL查询语言的使用介绍
09-10
HQL是Hibernate Query Language的缩写，语法很想SQL，但是HQL是一种面向对象的查询语言。SQL的操作对象是数据列、表等数据库对象，而HQL操作的是类、实例、属性
Hibernate 的查询语言 HQL 与高级查询
zhupengqq的博客
05-22 8060
Hibernate  的查询语言 HQL  与高级查询 数据库操作实现类的开发 import java.util.List; import org.hibernate.Query; import org.hibernate.SQLQuery; import org.hibernate.Session; import org.hibernate.Transaction; import org.s
Hibernate HQL语言详解
秋水の歌的专栏
07-23 563
在HQL语言中，可以使用from字句
HQL增删改查
aliushui的专栏
05-26 507
一  增加 getSession().save(entity) 二  删除 1 String hql = " DELETE FROM Student dm WHERE  dm.id = ? "; this.delete(hql,stu.getId()); 2 Transaction trans=session.beginTransaction(); 　　 String
hibernate HQL语句
ahong_1920的博客
12-03 776
HQL语句的几种处理情况 建立持久化类 public class Book { private Integer book_id; private String book_name; private Set&lt;Category&gt; categories = new HashSet&lt;&gt;(); public Book() { } public Intege...
Hibernate——HQL语句
热门推荐
Gavin
03-08 1万+
HQL(Hibernate Query Language) – 官方推荐 前面的入门示例中，我们通过session.load(Employee.class, 1)，也就是通过load()方法或者get()方法，可以通过主键属性来查询一条记录。当然这种方法很有局限性，为了更多的查询需求，我们需要使用HQL语句。 HQL即Hibernate查询语言，它是面向对象的查询语言，与SQL不同，HQL中的...
hibernate hql 大全
06-03 1177
Hibernate配备了一种非常强大的查询语言，这种语言看上去很像SQL。但是不要被语法结构 上的相似所迷惑，HQL是非常有意识的被设计为完全面向对象的查询，它可以理解如继承、多态 和关联之类的概念。  第 15 章 HQL: Hibernate查询语言Hibernate配备了一种非常强大的查询语言，这种语言看上去很像SQL。但是不要被语法结构 上的相似所迷惑，HQL是非常有意识的被设计为
hibernate HQL语言
izhuhf的专栏
12-11 96
1、FROM语句 --- 查询的返回结果是“对象”，与数据库中的表对应。 连接语法：FROM XXXX x join ZZZZ z [WHERE ....] 此处XXXX 和ZZZZ是数据库中对应的类。 1、内连接（innner join）用JOIN关键字时，如果指明其它，默认就是它。连接的两端不合格的结果都除去。 2、左外连接（l...
Hibernate查询语言
weixin_34072637的博客
05-02 70
HQL(Hibernate Query Language)查询语言是完全面向对象的查询语言，它提供了更加面向对象的封装，它可以理解如多态、继承和关联的概念。HQL看上去和SQL语句相似，但它却提供了更加强大的查询功能。 1. 了解HQL语言 HQL语句与SQL语句是相似的，其基本的使用习惯也与SQL相同。由于HQL是面向对象的查询语言，说以它需要从目标对象中查询信息并返回匹配单个实体对象或多个...
hibernate查询语句
香蕉熊的专栏
04-02 717
1 .from  1.1单表查询  from eg.cat as cat.其中，cat只是一个别名，为了用其他子语句的时候书写简单  1.2多表查询  from eg.Cat,eg.Dog from eg.Cat as cat,eg.Dog as dog 2 join相关 (inner) join left (outer) join right
Hibernate查询语言（HQL）
tao_629的博客
09-21 181
教程链接：Java技术 Hibernate查询语言(HQL)与SQL(结构化查询语言)相同，但不依赖于数据库表。 我们在HQL中使用类名，而不是表名。 所以是数据库独立的查询语言。 HQL的优点 数据库独立 支持多态查询 易于Java程序员学习 查询接口 它是一个面向对象的Hibernate Query表示。 Query的对象可以通过Session接口调用createQuery()方...
java hibernate HQL查询
04-27
Hibernate Query Language (HQL) 是 Hibernate 中的一种对象查询语言，类似于 SQL。通过 HQL，开发人员可以方便地查询 Hibernate 映射文件中定义的实体对象。 下面是一个简单的 HQL 查询示例： ```java Query ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值