Hibernate - HQL对象检索详解

Hibernate 提供了以下几种检索对象的方式：

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

【1】HQL检索

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

① 它有如下功能:

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

② HQL 检索方式包括以下步骤:

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

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

---

③ HQL vs SQL:

HQL 查询语句是面向对象的, Hibernate 负责解析 HQL 查询语句, 然后根据对象-关系映射文件中的映射信息, 把 HQL 查询语句翻译成相应的 SQL 语句。 HQL 查询语句中的主体是域模型中的类及类的属性。

SQL 查询语句是与关系数据库绑定在一起的。SQL 查询语句中的主体是数据库表及表的字段。

---

④ 绑定参数

Hibernate 的参数绑定机制依赖于 JDBC API 中的 PreparedStatement 的预定义 SQL 语句功能。

HQL 的参数绑定由两种形式:

• 按参数名字绑定: 在 HQL 查询语句中定义命名参数, 命名参数以“:”开头
• 按参数位置绑定: 在 HQL 查询语句中用 “?”来定义参数位置

相关方法:

• setEntity(): 把参数与一个持久化类绑定
• setParameter(): 绑定任意类型的参数。 该方法的第三个参数显式指定 Hibernate 映射类型

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

这里以Department：Employee=1：N双向一对多为例。

Department类如下：

public class Department {

	private Integer id;
	private String name;
	
	private Set emps = new HashSet<>();

	public Integer getId() {
		return id;
	}

	public void setId(Integer id) {
		this.id = id;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public Set getEmps() {
		return emps;
	}

	public void setEmps(Set emps) {
		this.emps = emps;
	}

	@Override
	public String toString() {
		return "Department [id=" + id + "]";
	}
	
}

Department.hbm.xml如下：

Employee类如下：

public class Employee {

	private Integer id;
	private String name;
	private float salary;
	private String email;
	
	private Department dept;

	public Integer getId() {
		return id;
	}

	public void setId(Integer id) {
		this.id = id;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public float getSalary() {
		return salary;
	}

	public void setSalary(float salary) {
		this.salary = salary;
	}

	public String getEmail() {
		return email;
	}

	public void setEmail(String email) {
		this.email = email;
	}

	public Department getDept() {
		return dept;
	}

	public void setDept(Department dept) {
		this.dept = dept;
	}

	@Override
	public String toString() {
		return "Employee [id=" + id + "]";
	}

	public Employee(String email, float salary, Department dept) {
		super();
		this.salary = salary;
		this.email = email;
		this.dept = dept;
	}
	
	public Employee() {
		// TODO Auto-generated constructor stub
	}
	
}

Employee.hbm.xml如下：

测试HQL查询代码如下：

	@Test
	public void testHQL(){
		
		//1. 创建 Query 对象
		//基于位置的参数. 
		String hql = "FROM Employee e WHERE e.salary > ? AND e.email LIKE ? AND e.dept = ? "
				+ "ORDER BY e.salary";
		Query query = session.createQuery(hql);
		
		//2. 绑定参数--位置索引绑定方式
		//Query 对象调用 setXxx 方法支持方法链的编程风格.
		Department dept = new Department();
		dept.setId(1); 
		query.setFloat(0, 3000)
		     .setParameter(1, "%A%",StringType.INSTANCE)
		     .setEntity(2, dept);
		
		//3. 执行查询
		List emps = query.list();
		System.out.println(emps.size());  
	}

测试结果如下：

Hibernate: 
    select
        employee0_.ID as ID1_1_,
        employee0_.NAME as NAME2_1_,
        employee0_.SALARY as SALARY3_1_,
        employee0_.EMAIL as EMAIL4_1_,
        employee0_.DEPT_ID as DEPT_ID5_1_ 
    from
        GG_EMPLOYEE employee0_ 
    where
        employee0_.SALARY>? 
        and (
            employee0_.EMAIL like ?
        ) 
        and employee0_.DEPT_ID=? 
    order by
        employee0_.SALARY
1

使用命名参数进行参数绑定：

	@Test
	public void testHQLNamedParameter(){
		
		//1. 创建 Query 对象
		//基于命名参数. 
		String hql = "FROM Employee e WHERE e.salary > :sal AND e.email LIKE :email";
		Query query = session.createQuery(hql);
		
		//2. 绑定参数
		query.setFloat("sal", 7000)
		     .setString("email", "%A%");
		
		//3. 执行查询
		List emps = query.list();
		System.out.println(emps.size());  
	}

---

⑤ 分页查询

setFirstResult(int firstResult): 设定从哪一个对象开始检索, 参数 firstResult 表示这个对象在查询结果中的索引位置, 索引位置的起始值为 0。默认情况下, Query 从查询结果中的第一个对象开始检索。

setMaxResults(int maxResults): 设定一次最多检索出的对象的数目。在默认情况下, Query 和 Criteria 接口检索出查询结果中所有的对象。

测试代码如下：

	@Test
	public void testPageQuery(){
		String hql = "FROM Employee";
		Query query = session.createQuery(hql);
		
		int pageNo = 1;
		int pageSize = 5;
		
		List emps = query.setFirstResult((pageNo - 1) * pageSize)
								     .setMaxResults(pageSize)
								     .list();
		System.out.println(emps);

测试结果如下：

Hibernate: 
    select
        employee0_.ID as ID1_1_,
        employee0_.NAME as NAME2_1_,
        employee0_.SALARY as SALARY3_1_,
        employee0_.EMAIL as EMAIL4_1_,
        employee0_.DEPT_ID as DEPT_ID5_1_ 
    from
        GG_EMPLOYEE employee0_ limit ?
[Employee [id=1], Employee [id=2], Employee [id=3], Employee [id=4], Employee [id=5]]

---

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

Hibernate 允许在映射文件中定义字符串形式的查询语句。

元素用于定义一个 HQL 查询语句, 它和 元素并列。

在Employee.hbm.xml中添加query节点如下：

 
	 :minSal AND e.salary < :maxSal]]>
 

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

	@Test
	public void testNamedQuery(){
		Query query = session.getNamedQuery("salaryEmps");
		
		List emps = query.setFloat("minSal", 5000)
				                   .setFloat("maxSal", 10000)
				                   .list();
		
		System.out.println(emps.size()); 
	}

测试结果如下：

Hibernate: 
    select
        employee0_.ID as ID1_1_,
        employee0_.NAME as NAME2_1_,
        employee0_.SALARY as SALARY3_1_,
        employee0_.EMAIL as EMAIL4_1_,
        employee0_.DEPT_ID as DEPT_ID5_1_ 
    from
        GG_EMPLOYEE employee0_ 
    where
        employee0_.SALARY>? 
        and employee0_.SALARY

---

⑦ 投影查询

投影查询，查询结果仅包含实体的部分属性， 通过 SELECT 关键字实现。

Query 的 list() 方法返回的集合中包含的是数组类型的元素, 每个对象数组代表查询结果的一条记录。

测试代码一如下：

	@Test
	public void testFieldQuery(){
		String hql = "SELECT e.email, e.salary, e.dept FROM Employee e WHERE e.dept = :dept";
		Query query = session.createQuery(hql);
		
		Department dept = new Department();
		dept.setId(1);
		List result = query.setEntity("dept", dept).list();
		
		for(Object [] objs: result){
			System.out.println(Arrays.asList(objs));
		}
	}

测试一结果如下：

Hibernate: 
    select
        employee0_.EMAIL as col_0_0_,
        employee0_.SALARY as col_1_0_,
        employee0_.DEPT_ID as col_2_0_,
        department1_.ID as ID1_0_,
        department1_.NAME as NAME2_0_ 
    from
        GG_EMPLOYEE employee0_ 
    inner join
        GG_DEPARTMENT department1_ 
            on employee0_.DEPT_ID=department1_.ID 
    where
        employee0_.DEPT_ID=?
[[email protected], 5000.0, Department [id=1]]
[[email protected], 6000.0, Department [id=1]]

---

可以在持久化类中定义一个对象的构造器来包装投影查询返回的记录, 使程序代码能完全运用面向对象的语义来访问查询结果集。

测试代码二如下：

	@Test
	public void testFieldQuery2(){
		//实体类Employee需要有该构造器
		String hql = "SELECT new Employee(e.email, e.salary, e.dept) "
				+ "FROM Employee e "
				+ "WHERE e.dept = :dept";
		Query query = session.createQuery(hql);
		
		Department dept = new Department();
		dept.setId(1);
		List result = query.setEntity("dept", dept).list();
		
		for(Employee emp: result){
			System.out.println(emp.getId() + ", " + emp.getEmail() 
					+ ", " + emp.getSalary() + ", " + emp.getDept());
		}
	}

测试二结果如下：

Hibernate: 
    select
        employee0_.EMAIL as col_0_0_,
        employee0_.SALARY as col_1_0_,
        employee0_.DEPT_ID as col_2_0_ 
    from
        GG_EMPLOYEE employee0_ 
    inner join //内连接
        GG_DEPARTMENT department1_ 
            on employee0_.DEPT_ID=department1_.ID 
    where
        employee0_.DEPT_ID=?
Hibernate: 
    select
        department0_.ID as ID1_0_0_,
        department0_.NAME as NAME2_0_0_ 
    from
        GG_DEPARTMENT department0_ 
    where
        department0_.ID=?
null, [email protected], 5000.0, Department [id=1]
null, [email protected], 6000.0, Department [id=1]

另外，可以通过 DISTINCT 关键字来保证查询结果不会返回重复元素。

---

⑧ 报表查询

报表查询用于对数据分组和统计, 与 SQL 一样, HQL 利用 GROUP BY 关键字对数据分组, 用 HAVING 关键字对分组数据设定约束条件，过滤分组数据。

在 HQL 查询语句中可以调用以下聚集函数：

count()
min()
max()
sum()
avg()

测试代码如下：

@Test
	public void testGroupBy(){
		String hql = "SELECT min(e.salary), max(e.salary) "
				+ "FROM Employee e "
				+ "GROUP BY e.dept "
				+ "HAVING min(salary) > :minSal";
		
		Query query = session.createQuery(hql)
				             .setFloat("minSal", 5000);
		
		List