一、实体对象查询
实体对象查询是hql查询的基础，作为一种对象查询语言，在查询操作时和sql不同，查询字符串中的内容要使用类名和类的属性名来代替。这种查询方法相对简单，只要有SQL功底，使用hql是很简单的，但是有一些问题需要注意，就是查询获取数据不是目的，需要考虑的是如何编写出高效的查询语句，这才是讨论的重点。
1.N+1问题
（1）什么是N+1问题
在刚听到这个名词时疑惑可能是有的，以前根本就没有听过N+1问题，那么它是指什么呢？N+1指的是一张表中有N条数据，那么在获取这N条数据时会产生N+1条sql命令，这种操作被称为N+1。这里的1指的是发出一条查询id列表的语句，N则指根据id发出N条sql语句，加载相关的对象。这种查询操作效率很低，往往产生在迭代器中，也就是说如果我们将查询结果直接转化为迭代器，这时候就会出现这种问题，如下代码：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
|
public void testQuery(){ Session session=null; try{ session=HibernateUtils.getSession(); session.beginTransaction(); /** * 会出现N+1问题，所谓的N+1值得是发出了N+1条sql语句 * * 1：发出一条查询id列表的语句 * * N：根据id发出N条sql语句，加载相关的对象 */ Iterator iter=session.createQuery("from Student").iterate(); while(iter.hasNext()){ Student student=(Student)iter.next(); System.out.println(student.getName()); } session.getTransaction().commit(); }catch(Exception e){ e.printStackTrace(); session.getTransaction().rollback(); }finally{ HibernateUtils.closeSession(session); } } |
上面的这段查询代码就会产生N+1问题，因为查询时返回的是一个迭代器，这样没产生一次就会发出一条sql语句，这主要取决于Iterator的这种查询机制，它是从缓存中查询数据，如果缓存中不存在该数据那么首先会将数据转换到内存中，所以这时候就会发出一条sql查询语句，所以在每次迭代时就会产生一条sql语句。这种写法其实是一种错误，可以使用其它方法优化解决。
（2）避免N+1问题
出现了N+1的问题是因为Iterate使用不当的原因，当然可以使用其它的方法来避免这种N+1的问题，这里介绍一种List的方法。List和Iterate最大的区别是List将数据放到缓存中，但是不利用缓存，默认情况下list每次都会发出sql语句。可以在使用Iterate之前，使用list将数据保存到数据库中，这样Iterate访问数据时就可以从缓存中读取，避免了N+1问题的出现，代码如下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
|
public void testQuery(){ Session session=null; try{ session=HibernateUtils.getSession(); session.beginTransaction(); List students=session.createQuery("from Student").list(); System.out.println("---------------------------------"); /** * 避免了N+1问题 * * 因为执行list操作后会将数据放到session的缓存中（一级缓存），所以采用iterate的时候 * 首先会发出一条查询id列表的语句，再根据id到缓存中加载相应的数据，如果缓存中存在与之匹配的数据 * 则不再发出根据id查询的sql语句，直接使用缓存中的数据 * * Iterate方法如果缓存中存在数据，它可以提高性能，否则出现N+1问题 */ //可以使用as别名 Iterator iter=session.createQuery("from Student").iterate(); while(iter.hasNext()){ Student student=(Student)iter.next(); System.out.println(student.getName()); } session.getTransaction().commit(); }catch(Exception e){ e.printStackTrace(); session.getTransaction().rollback(); }finally{ HibernateUtils.closeSession(session); } } |
上例 避免了N+1问题，因为执行list操作后会将数据放到session的缓存中（一级缓存），所以采用iterate的时候首先会发出一条查询id列表的语句，再根据id到缓存中加载相应的数据，如果缓存中存在与之匹配的数据， 则不再发出根据id查询的sql语句，直接使用缓存中的数据。 Iterate方法如果缓存中存在数据，它可以提高性能，否则出现N+1问题。
2.对象导航查询
对象导航是指在一个对象中按照对象的属性导航获取到另一个对象的数据，这样做可以简化查询语句，优化查询方法。如果按照我们平常的想法可能会再重写编写另一个类的对象，来获取另一个对象的操作，和对象导航对比语句比较累赘。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
|
@SuppressWarnings({ "unchecked", "rawtypes" }) public void testQuery1(){ Session session=null; try{ session=HibernateUtils.getSession(); session.beginTransaction(); //返回结果集属性列表，元素类型和实体类中的属性类型一致 List students=session.createQuery("from Student s where s.classes.name like '%2%'").list(); for(Iterator ite=students.iterator();ite.hasNext();){ Student obj=(Student)ite.next(); System.out.println(obj.getName()); } session.getTransaction().commit(); }catch(Exception e){ e.printStackTrace(); session.getTransaction().rollback(); }finally{ HibernateUtils.closeSession(session); } } |
上例中的查询语句就使用了对象导航的方法，查询语句是从Student对象中查询的信息，但是要比对的对象属性却是来自于Classes对象的name属性，这时候使用对象导航的查询方法就会明显提高查询效率，优化查询语句，如果换做普通的查询方法就可能会产生大量的连接语句，很复杂。
二、sql原生查询
原生查询值的是使用SQL语句来查询获取数据，而不是采用hql语句，它的使用方法其实很简单，同hql类似，只需要使用createSQLQuery方法查询即可，它其实类似于hql的createQuery方法，代码如下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
public void testQeury(){ Session session=null; try{ session=HibernateUtils.getSession(); session.beginTransaction(); List list=session.createSQLQuery("select * from t_student").list(); for(Iterator ite=list.iterator();ite.hasNext();){ Object[] obj=(Object[])ite.next(); System.out.println(obj[0]+","+obj[1]); } session.getTransaction().commit(); }catch(Exception e){ e.printStackTrace(); session.getTransaction().rollback(); }finally{ HibernateUtils.closeSession(session); } } |
上面的代码使用了createSQLQuery方法，方法内的查询字符串就是SQL语句，它实现了底层的字符串查询方法，不同的是HQL又做了一层包装，在Hibernate.cfg.xml中配置相应的方言选项即可完成映射。
三、连接查询
在sql中经常使用连接查询来获取多个对象的合集，其中经常用到的有inner join、left join、right join等，分别指代内连接查询、左外连接查询、右外连接查询，它们在查询时返回的内容分别是实体之间的笛卡尔积，查询的内容及左表的一些内容，查询内容及右表的一些内容，查询的功能强大。hql的连接查询方法和sql的连接查询在查询结果上是相同的，但是在查询语句上稍有区别。
1.内连接
hql的内连接查询可使用inner join语句或者join语句查询，获取的结果集是笛卡尔积。同sql的内连接查询类似，hql的join查询又分为显式与隐式两种，显示的查询是指查询字符串中有join关键字，隐式的查询在字符串中不需要添加join。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
|
//内连接 @SuppressWarnings({ "unchecked", "rawtypes" }) public void testQuery(){ Session session=null; try{ session=HibernateUtils.getSession(); session.beginTransaction(); //返回结果集属性列表，元素类型和实体类中的属性类型一致 List students=session.createQuery("select s.name,c.name from Student s join s.classes c").list(); for(Iterator ite=students.iterator();ite.hasNext();){ Object[] obj=(Object[])ite.next(); System.out.println(obj[0]); } session.getTransaction().commit(); }catch(Exception e){ e.printStackTrace(); session.getTransaction().rollback(); }finally{ HibernateUtils.closeSession(session); } } |
2.外连接
外连接又分为左外连接和右外连接查询，查询方法类似，但是查询出的结果集不同，它们在查询结果上和SQL的外连接相同，不同的是写法，具体使用代码如下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
|
@SuppressWarnings({ "unchecked", "rawtypes" }) public void testQuery(){ Session session=null; try{ session=HibernateUtils.getSession(); session.beginTransaction(); //返回结果集属性列表，元素类型和实体类中的属性类型一致 List students=session.createQuery("select s.name,c.name from Student s left join s.classes c").list(); for(Iterator ite=students.iterator();ite.hasNext();){ Object[] obj=(Object[])ite.next(); System.out.println(obj[0]); } session.getTransaction().commit(); }catch(Exception e){ e.printStackTrace(); session.getTransaction().rollback(); }finally{ HibernateUtils.closeSession(session); } } |
上面的代码使用的是左外连接查询语句，相应的右外连接查询的方法和左外连接类似，将left转换为right即可。查询到的数据被保存到list对象中，可通过list来获取查询内容。
四、外置命名查询
外置命名查询是指将查询语句写到映射文件中，在映射文件中使用<query>标签来定义hql语句，这样定义的hql语句就能够实现功能配置功能，如果出现问题只需要修改配置即可。如果想用使用该sql语句，可在程序中使用session.getNamedQuery()方法得到hql查询串，如下示例。
1.外置查询语句
下面示例中演示了外置查询语句的应用，在映射文件中添加<query>标签，并为该标签添加name属性，将字符串添加到<![CDATA[]]>中，这样既可在程序中按照query的name属性获取对应的查询字符串了。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
<?xml version="1.0"?> <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd"> <hibernate-mapping> <class name="com.src.hibernate.Student" table="t_student"> <id name="id"> <generator class="native"/> </id> <property name="name"/> <property name="createTime"></property> <!-- 在多的一端Student中添加一行新的Classes列 ,并且列的名称要和Classes.hbm.xml的列明相同--> <many-to-one name="classes" column="classesid"></many-to-one> </class> <query name="queryStudent"> <![CDATA[ select s from Student s where s.id<? ]]> </query> </hibernate-mapping> |
外置的命名查询将查询语句放到了映射文件中，所以它可以被认为是公共的查询字符串，在程序文件中都可以查询使用该字符串，这是它的优点，这样其它的程序文件就都可以获取使用了，另外作为公共的字符串增加了修改的便利性。
2.程序应用
定义了外置的查询语句后要在程序中使用，hql提供了getNameQuery方法来获取外置的查询语句串，该方法中需要添加一个外置的游标名称，hql会根据游标名称查询获取相对应的sql语句块，如下的程序代码：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
|
//外置命名查询 @SuppressWarnings({ "unchecked", "rawtypes" }) public void testQuery(){ Session session=null; try{ session=HibernateUtils.getSession(); session.beginTransaction(); List students=session.getNamedQuery("queryStudent").setParameter(0, 10).list(); for(Iterator ite=students.iterator();ite.hasNext();){ Student obj=(Student)ite.next(); System.out.println(obj.getName()); } session.getTransaction().commit(); }catch(Exception e){ e.printStackTrace(); session.getTransaction().rollback(); }finally{ HibernateUtils.closeSession(session); } } |
