Hibernate中提供了多種檢索對象的方式，主要包括以下種類：

1. 導航對象圖檢索方式：根據已經加載的對象導航到其他對象
2. OID檢索方式：根據對象的OID來檢索對象
3. HQL檢索方式：使用面向對象的HQL查詢語言
4. QBC檢索方式：使用QBC(Query By Criteria)API來檢索對象。這種API封裝了基于字符串形式的查詢語句，提供了更加面向對象的查詢接口
5. 本地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中的
  • 相關方法：

  　　　　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     @Override38     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     @Override53     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     @Test106     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     @Test119     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     @Test137     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     @Test155     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     @Test172     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     @Test193     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     @Test216     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     @Test237     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 }