Hibernate之HQL介绍

浏览数：40 / 时间：2015年06月09日

Hibernate中提供了多种检索对象的方式，主要包括以下种类：

导航对象图检索方式：根据已经加载的对象导航到其他对象
OID检索方式：根据对象的OID来检索对象
HQL检索方式：使用面向对象的HQL查询语言
QBC检索方式：使用QBC(Query By Criteria)API来检索对象。这种API封装了基于字符串形式的查询语句，提供了更加面向对象的查询接口
本地SQL检索方式：使用本地数据库的SQL查询语句

本文主要介绍第三种方式，也就是HQL检索对象。

HQL(Hibernate Query Language)是面向对象的查询语言，它和SQL查询语言有些相似。在Hibernate提供的各种检索方式中，HQL是使用最广的一种检索方式。它有如下功能：

在查询语句中设定各种查询条件
支持投影查询，即仅检索出对象的部分属性
支持分页查询
支持连接查询
支持分组查询，允许使用HAVING和GROUP BY关键字
提供内置聚集函数，如sum(), min()和max()
支持子查询
支持动态绑定参数
能够调用用户定义的SQL函数或标准的SQL函数

HQL检索方式包括以下步骤：

通过Session的createQuery()方法创建一个Query对象，它包括一个HQL查询语句，HQL查询语句可以包含命名参数
动态绑定参数
调用Query相关方法执行查询语句

Query接口支持方法链编程风格，它的setXxx()方法返回自身实例，而不是void类型。

HQL vs SQL：

HQL查询语句是面向对象的，Hibernate负责解析HQL查询语句，然后根据对象-关系映射文件中的映射信息，把HQL查询语句翻译成相应的SQL语句，HQL查询语句中的主体是域模型中的类及类的属性
SQL查询语句是与关系数据库绑定在一起的。SQL查询语句中的主体是数据库表及表的字段

绑定参数：

Hibernate的参数绑定机制依赖于JDBC API中的PreparedStatement的预定义SQL语句功能
Hibernate的参数绑定有两种形式：

　　　　1.按参数名字绑定：在HQL查询语句中定义命名参数，命名参数以":"开头

　　　　2.按参数位置绑定：在HQL查询语句中用"?"来定义参数位置

相关方法：

　　　　1.setEntity():把参数与一个持久化类绑定

　　　　2.setParameter(): 绑定任意类型的参数，该方法的第三个参数显式指定Hibernate映射类型

HQL采用ORDER BY关键字对查询结果排序

下面详细介绍下Hibernate的HQL的几个功能：

分页查询：

setFirstResult(int firstResult): 设定从哪一个对象开始检索，参数firstResult表示这个对象在查询结果中的索引位置，索引位置的起始值为0.默认情况下，Query从查询结果中的第一个对象开始检索
setMaxResult(int maxResults): 设定一次最多检索出的对象的数目。在默认情况下，Query和Criteria接口检索出查询结果中所有的对象

在映射文件中定义命名查询语句

Hibernate允许在映射文件中定义字符串形式的查询语句
<query>元素用于定义一个HQL查询语句，它和<class>元素并列

　　　　<query name="salaryEmps"><![CDATA[FROM Employee w WHERE e.salary > :minSal AND e.salary < :maxSal]]></query>

在程序中通过Session的getNamedQuery()方法获取查询语句对应的Query对象

投影查询

投影查询：查询结果仅包含实体的部分属性。通过SELECT关键字实现
Query的list()方法返回的集合中包含的是数组类型的元素，每个对象数组代表查询结果的一条记录
可以在持久化类中定义一个对象的构造器来包装投影查询返回的记录，使程序代码能完全运用面向对象的语义来访问查询结果集
可以通过DISTINCT关键字来保证查询结果不会返回重复元素

报表查询

报表查询用于对数据分组和统计，与SQL一样，HQL利用GROUP BY关键字对数据分组，用HAVING关键字对分组数据设定约束条件
在HQL查询语句中可以调用以下聚集函数
- count()
- min()
- max()
- sum()
- avg()

HQL(迫切)左外连接

迫切左外连接：
- LEFT JOIN FETCH关键字表示迫切左外连接检索策略
- list()方法返回的集合中存放实体对象的引用，每个Department对象关联的Employee集合都被初始化，存放所有关联的Employee的实体对象
- 查询结果中可能会包含重复元素，可以通过一个HashSet来过滤重复元素
左外连接：
- LEFT JOIN关键字表示左外连接
- list()方法返回的集合中存放的是对象数组类型
- 根据配置文件来决定Employee集合的检索策略
- 如果希望list()方法返回的集合中仅包含Department对象，可以在HQL查询语句中使用SELECT关键字

HQL(迫切)内连接

迫切内连接：
- INNER JOIN FETCH关键字表示迫切内连接，也可以省略INNER关键字
- list()方法返回的集合中存放Department对象的引用，每个Department对象的Employee集合都被初始化，存放所有关联的Employee对象
内连接
- INNER JOIN关键字表示内连接，也可以省略INNER关键字
- list()方法的集合中存放的每个元素对应查询结果的一条记录，每个元素都是对象数组类型
- 如果希望list()方法的返回的集合仅包含Department对象，可以在HQL查询语句中使用SELECT关键字

关联级别运行时的检索策略：

如果在HQL中没有显式指定检索策略，将使用映射文件配置的检索策略
HQL会忽略映射文件中设置的迫切左外连接检索策略，如果希望HQL采用迫切左外连接策略，就必须在HQL查询语句中显式指定它
若在HQL代码中显式指定了检索策略，就会覆盖映射文件中配置的检索策略

==============================代码区========================================

Department.java

 1 package com.yl.hibernate.entities;
 2 
 3 import java.util.HashSet;
 4 import java.util.Set;
 5 
 6 public class Department {
 7     
 8     private Integer id;
 9     private String name;
10     
11     private Set<Employee> emps = new HashSet<Employee>();
12 
13     public Integer getId() {
14         return id;
15     }
16 
17     public void setId(Integer id) {
18         this.id = id;
19     }
20 
21     public String getName() {
22         return name;
23     }
24 
25     public void setName(String name) {
26         this.name = name;
27     }
28 
29     public Set<Employee> getEmps() {
30         return emps;
31     }
32 
33     public void setEmps(Set<Employee> emps) {
34         this.emps = emps;
35     }
36 
37     @Override
38     public String toString() {
39         //return "Department [id=" + id + ", name=" + name + "]";
40         return "Department [id=" + id + "]";
41     }
42             
43 }

Employee.java

 1 package com.yl.hibernate.entities;
 2 
 3 public class Employee {
 4     
 5     private Integer id;
 6     private String name;
 7     private float salary;
 8     private String email;
 9     
10     private Department dept;
11 
12     public Integer getId() {
13         return id;
14     }
15 
16     public void setId(Integer id) {
17         this.id = id;
18     }
19 
20     public String getName() {
21         return name;
22     }
23 
24     public void setName(String name) {
25         this.name = name;
26     }
27 
28     public float getSalary() {
29         return salary;
30     }
31 
32     public void setSalary(float salary) {
33         this.salary = salary;
34     }
35 
36     public String getEmail() {
37         return email;
38     }
39 
40     public void setEmail(String email) {
41         this.email = email;
42     }
43 
44     public Department getDept() {
45         return dept;
46     }
47 
48     public void setDept(Department dept) {
49         this.dept = dept;
50     }
51 
52     @Override
53     public String toString() {
54         return "Employee [id=" + id + "]";
55     }
56 
57     public Employee(){}
58     
59     public Employee(String email, float salary, Department dept) {
60         super();
61         this.salary = salary;
62         this.email = email;
63         this.dept = dept;
64     }
65     
66 }

Department.hbm.xml

 1 <?xml version="1.0"?>
 2 <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
 3 "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
 4 <!-- Generated 2014-12-1 19:29:32 by Hibernate Tools 3.4.0.CR1 -->
 5 <hibernate-mapping>
 6     <class name="com.yl.hibernate.entities.Department" table="YL_DEPARTMENT">
 7         <id name="id" type="java.lang.Integer">
 8             <column name="ID" />
 9             <generator class="native" />
10         </id>
11         <property name="name" type="java.lang.String">
12             <column name="NAME" />
13         </property>
14         <set name="emps" table="YL_EMPLOYEE" inverse="true" lazy="true">
15             <key>
16                 <column name="DEPT_ID" />
17             </key>
18             <one-to-many class="com.yl.hibernate.entities.Employee" />
19         </set>
20     </class>
21 </hibernate-mapping>

Employee.hbm.xml

 1 <?xml version="1.0"?>
 2 <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
 3 "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
 4 <!-- Generated 2014-12-1 19:29:32 by Hibernate Tools 3.4.0.CR1 -->
 5 <hibernate-mapping>
 6     <class name="com.yl.hibernate.entities.Employee" table="YL_EMPLOYEE">
 7         <id name="id" type="java.lang.Integer">
 8             <column name="ID" />
 9             <generator class="native" />
10         </id>
11         <property name="name" type="java.lang.String">
12             <column name="NAME" />
13         </property>
14         <property name="salary" type="float">
15             <column name="SALARY" />
16         </property>
17         <property name="email" type="java.lang.String">
18             <column name="EMAIL" />
19         </property>
20         <many-to-one name="dept" class="com.yl.hibernate.entities.Department" fetch="join">
21             <column name="DEPT_ID" />
22         </many-to-one>
23     </class>
24     
25     <query name="salaryEmps"><![CDATA[FROM Employee e WHERE e.salary > :minSal AND e.salary < :maxSal]]></query>
26     
27 </hibernate-mapping>

测试类：

  1 package com.yl.hibernate.test;
  2 
  3 
  4 import java.util.ArrayList;
  5 import java.util.Arrays;
  6 import java.util.LinkedHashSet;
  7 import java.util.List;
  8 import java.util.Set;
  9 
 10 import oracle.net.aso.e;
 11 
 12 import org.hibernate.Query;
 13 import org.hibernate.Session;
 14 import org.hibernate.SessionFactory;
 15 import org.hibernate.Transaction;
 16 import org.hibernate.cfg.Configuration;
 17 import org.hibernate.service.ServiceRegistry;
 18 import org.hibernate.service.ServiceRegistryBuilder;
 19 import org.junit.After;
 20 import org.junit.Before;
 21 import org.junit.Test;
 22 
 23 import com.yl.hibernate.entities.Department;
 24 import com.yl.hibernate.entities.Employee;
 25 
 26 public class HibernateTest {
 27 
 28     private SessionFactory sessionFactory;
 29     private Session session;
 30     private Transaction transaction;
 31     
 32     @Before
 33     public void init() {
 34         Configuration configuration = new Configuration().configure();
 35         ServiceRegistry serviceRegistry = 
 36                 new ServiceRegistryBuilder().applySettings(configuration.getProperties())
 37                                             .buildServiceRegistry();
 38 
 39         sessionFactory = configuration.buildSessionFactory(serviceRegistry);
 40         
 41         session = sessionFactory.openSession();
 42 
 43         transaction = session.beginTransaction();
 44     }
 45     @After
 46     public void destory() {
 47         transaction.commit();
 48         
 49         session.close();
 50         
 51         sessionFactory.close();
 52     }
 53     
 54     @Test
 55     public void testHQL() {
 56         //1.创建 Query 对象
 57         //基于位置参数
 58         String hql = "FROM Employee e WHERE e.salary > ? AND e.email LIKE ? AND e.dept = ? ORDER BY e.salary";
 59         Query query = session.createQuery(hql);
 60         //2.绑定参数
 61         //Query 对象调用setXxx()方法支持方法链的编程风格
 62         Department dept = new Department();
 63         dept.setId(30);
 64         query.setFloat(0, 2000)
 65              .setString(1, "%A%")
 66              .setEntity(2, dept);
 67         //3.执行查询
 68         List<Employee> emps = query.list();
 69         System.out.println(emps);
 70     }
 71     
 72     @Test
 73     public void testHQLNamedParameter() {
 74         //1.创建 Query 对象
 75         //基于命名参数
 76         String hql = "FROM Employee e WHERE e.salary > :sal AND e.email LIKE :email";
 77         Query query = session.createQuery(hql);
 78         //2.绑定参数
 79         query.setFloat("sal", 2000)
 80              .setString("email", "%A%");
 81         //3.执行查询
 82         List<Employee> emps = query.list();
 83         System.out.println(emps.size());
 84     }
 85     /**
 86      * 分页查询
 87      */
 88     @Test
 89     public void testPageQuery() {
 90         String hql = "FROM Employee";
 91         Query query = session.createQuery(hql);
 92         
 93         int pageNo = 3;
 94         int pageSize = 5;
 95         
 96         List<Employee> employees = query.setFirstResult((pageNo-1) * pageSize)
 97                                          .setMaxResults(pageSize)
 98                                          .list();
 99         System.out.println(employees);
100         
101     }
102     /**
103      * 在映射文件中定义命名查询语句
104      */
105     @Test
106     public void testNamedQuery() {
107         Query query = session.getNamedQuery("salaryEmps");
108         
109         List<Employee> emps = query.setFloat("minSal", 2000)
110                                     .setFloat("maxSal", 3000)
111                                     .list();
112         System.out.println(emps);
113         
114     }
115     /**
116      * 投影查询
117      */
118     @Test
119     public void testFieldQuery() {
120         String hql = "SELECT e.email, e.salary, e.dept FROM Employee e WHERE e.dept = :dept";
121         Query query = session.createQuery(hql);
122         
123         Department dept = new Department();
124         dept.setId(20);
125         List<Object[]> result = query.setEntity("dept", dept).list();
126         
127         for (Object[] objects : result) {
128             System.out.println(Arrays.asList(objects));
129         }
130         
131     }
132     
133     /**
134      * 投影查询
135      */
136     @Test
137     public void testFieldQuery2() {
138         String hql = "SELECT new Employee(e.email, e.salary, e.dept) "
139                     + "FROM Employee e "
140                     + "WHERE e.dept = :dept";
141         
142         Query query = session.createQuery(hql);
143         
144         Department dept = new Department();
145         dept.setId(20);
146         List<Employee> result = query.setEntity("dept", dept).list();
147         
148         for (Employee emp : result) {
149             System.out.println(emp.getId() + ", " + emp.getEmail() + ", " + emp.getSalary() + ", " + emp.getDept());
150         }
151         
152     }
153     
154     @Test
155     public void testGroupBy() {
156         String hql = "SELECT min(e.salary), max(e.salary) " 
157                 + "FROM Employee e "
158                 + "GROUP BY e.dept "
159                 + "HAVING min(salary) > :minSal";
160         Query query = session.createQuery(hql)
161                              .setFloat("minSal", 700);
162         
163         List<Object[]> result = query.list();
164         for (Object[] objects : result) {
165             System.out.println(Arrays.asList(objects));
166         }
167     }
168     /**
169      * 迫切左外连接
170      */
171     @Test
172     public void testLeftJoinFetch() {
173         /*String hql = "SELECT DISTINCT d FROM Department d LEFT JOIN FETCH d.emps";
174         Query query = session.createQuery(hql);
175         
176         List<Department> depts = query.list();
177         System.out.println(depts.size());*/
178         
179         String hql = "FROM Department d LEFT JOIN FETCH d.emps";
180         Query query = session.createQuery(hql);
181         
182         List<Department> depts = query.list();
183         depts = new ArrayList<Department>(new LinkedHashSet<Department>(depts));
184         
185         System.out.println(depts.size());
186         
187         for (Department department : depts) {
188             System.out.println(department.getName() + "-" + department.getEmps().size());
189         }
190     }
191     
192     @Test
193     public void testLeftJoin() {
194         /*String hql = "FROM Department d LEFT JOIN d.emps";
195         Query query = session.createQuery(hql);
196         
197         List<Object[]> result = query.list();
198         System.out.println(result);
199         
200         for (Object[] objects : result) {
201             System.out.println(Arrays.asList(objects));
202         }*/
203         
204         String hql = "SELECT DISTINCT d FROM Department d LEFT JOIN d.emps";
205         Query query = session.createQuery(hql);
206         
207         List<Department> depts = query.list();
208         System.out.println(depts.size());
209         
210         for (Department department : depts) {
211             System.out.println(department.getName() + ", " + department.getEmps().size());
212         }
213     }
214     
215     @Test
216     public void testInnerJoinFetch() {
217         /*String hql = "SELECT DISTINCT d FROM Department d INNER JOIN FETCH d.emps";
218         Query query = session.createQuery(hql);
219         
220         List<Department> depts = query.list();
221         System.out.println(depts.size());*/
222         
223         String hql = "FROM Department d INNER JOIN FETCH d.emps";
224         Query query = session.createQuery(hql);
225         
226         List<Department> depts = query.list();
227         depts = new ArrayList<Department>(new LinkedHashSet<Department>(depts));
228         
229         System.out.println(depts.size());
230         
231         for (Department department : depts) {
232             System.out.println(department.getName() + "-" + department.getEmps().size());
233         }
234     }
235     
236     @Test
237     public void testInnerJoin() {
238         /*String hql = "FROM Department d INNER JOIN d.emps";
239         Query query = session.createQuery(hql);
240         
241         List<Object[]> result = query.list();
242         System.out.println(result);
243         
244         for (Object[] objects : result) {
245             System.out.println(Arrays.asList(objects));
246         }*/
247         
248         String hql = "SELECT DISTINCT d FROM Department d INNER JOIN d.emps";
249         Query query = session.createQuery(hql);
250         
251         List<Department> depts = query.list();
252         System.out.println(depts.size());
253         
254         for (Department department : depts) {
255             System.out.println(department.getName() + ", " + department.getEmps().size());
256         }
257     }
258     
259 }