碼上歡樂
相關內容    簡體    繁體

Hibernate中的HQL的基本常用小例子，單表查詢與多表查詢

本文轉載自   查看原文   2017-12-19 19:34   2071    Hibernate

 

[cpp]  view plain  copy
 
  1. <span style="font-size:24px;color:#3366ff;">本文章實現HQL的以下功能：</span>  
  2. /** 
  3.  * hql語法： 
  4.  *   1）單表查詢 
  5.  *       1.1 全表查詢 
  6.  *       1.2 指定字段查詢 
  7.  *       1.3 排除重復記錄 
  8.  *       1.4 條件查詢（重點） 
  9.  *       1.5 分頁查詢 
  10.  *       1.6 聚合查詢 
  11.  *       1.7 查詢排序 
  12.  *       1.8 分組查詢 
  13.  *       1.9 分組后篩選 
  14.  *        
  15.  *   2）多表查詢 
  16.  *       1.1 內連接 
  17.  *       1.2 左外連接/右外連接    
  18. */  
  19. </span>  


 

首先要配置Hibernate的xml文件，讓兩個數據庫建立聯系，是一對多的映射連接

Employee.hbm.xml

 

[html]  view plain  copy
 
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd" >  
  3. <hibernate-mapping>  
  4.     <class name="star.july.d_hql.Employee" table="employee">  
  5.         <id name="id">  
  6.             <generator class="native"></generator>  
  7.         </id>  
  8.         <property name="name"></property>  
  9.         <property name="gender"></property>  
  10.         <property name="title"></property>  
  11.         <property name="email"></property>  
  12.         <property name="salary"></property>  
  13.         <many-to-one name="dept"   
  14.             class="star.july.d_hql.Dept"  
  15.             column="deptId"  
  16.         ></many-to-one>  
  17.     </class>  
  18. </hibernate-mapping>  

 

 

Dept.hbm.xml

 

[html]  view plain  copy
 
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd" >  
  3. <hibernate-mapping>  
  4.     <class name="star.july.d_hql.Dept" table="dept">  
  5.         <id name="id">  
  6.             <generator class="native"></generator>  
  7.         </id>  
  8.         <property name="deptName" column="name">  
  9.         </property>  
  10.         <set name="employee"  
  11.             cascade="all"  
  12.         >  
  13.         <key column="id"></key>  
  14.             <one-to-many class="star.july.d_hql.Employee"  
  15.             />  
  16.         </set>  
  17.     </class>  
  18. </hibernate-mapping>  


 

再建立兩個實體類

Employee.java

 

[cpp]  view plain  copy
 
  1. package star.july.d_hql;  
  2.   
  3. public class Employee {  
  4.     private int id;  
  5.     private String name;  
  6.     private String gender;  
  7.     private String title;  
  8.     private String email;  
  9.     private double salary;  
  10.     private Dept dept = new Dept();  
  11.       
  12.     public Dept getDept() {  
  13.         return dept;  
  14.     }  
  15.     public void setDept(Dept dept) {  
  16.         this.dept = dept;  
  17.     }  
  18.     public int getId() {  
  19.         return id;  
  20.     }  
  21.     public void setId(int id) {  
  22.         this.id = id;  
  23.     }  
  24.     public String getName() {  
  25.         return name;  
  26.     }  
  27.     public void setName(String name) {  
  28.         this.name = name;  
  29.     }  
  30.     public String getGender() {  
  31.         return gender;  
  32.     }  
  33.     public void setGender(String gender) {  
  34.         this.gender = gender;  
  35.     }  
  36.     public String getTitle() {  
  37.         return title;  
  38.     }  
  39.     public void setTitle(String title) {  
  40.         this.title = title;  
  41.     }  
  42.     public String getEmail() {  
  43.         return email;  
  44.     }  
  45.     public void setEmail(String email) {  
  46.         this.email = email;  
  47.     }  
  48.     public double getSalary() {  
  49.         return salary;  
  50.     }  
  51.     public void setSalary(double salary) {  
  52.         this.salary = salary;  
  53.     }  
  54.     @Override  
  55.     public String toString() {  
  56.         return "Employee [id=" + id + ", name=" + name + ", gender=" + gender  
  57.                 + ", title=" + title + ", email=" + email + ", salary="  
  58.                 + salary + "]";  
  59.     }  
  60.       
  61.       
  62. }  


 

 

 

Dept.java

 

[java]  view plain  copy
 
  1. package star.july.d_hql;  
  2.   
  3. import java.util.HashSet;  
  4. import java.util.Set;  
  5.   
  6. public class Dept {  
  7.     private int id;  
  8.     private String deptName;  
  9.     private Set<Employee> employee = new HashSet<Employee>();  
  10.     public int getId() {  
  11.         return id;  
  12.     }  
  13.     public void setId(int id) {  
  14.         this.id = id;  
  15.     }  
  16.     public String getDeptName() {  
  17.         return deptName;  
  18.     }  
  19.     public void setDeptName(String deptName) {  
  20.         this.deptName = deptName;  
  21.     }  
  22.     public Set<Employee> getEmployee() {  
  23.         return employee;  
  24.     }  
  25.     public void setEmployee(Set<Employee> employee) {  
  26.         this.employee = employee;  
  27.     }  
  28.       
  29.       
  30. }     


 

 

最后測試HQL：

Demo.java

 

[java]  view plain  copy
 
  1. package star.july.d_hql;  
  2.   
  3. import java.util.List;  
  4. import java.util.Set;  
  5.   
  6. import org.hibernate.Query;  
  7. import org.hibernate.Session;  
  8. import org.hibernate.Transaction;  
  9. import org.junit.Test;  
  10.   
  11. import star.july.util.HibernateUtil;  
  12. /** 
  13.  * hql語法： 
  14.  *   1）單表查詢 
  15.  *       1.1 全表查詢 
  16.  *       1.2 指定字段查詢 
  17.  *       1.3 排除重復記錄 
  18.  *       1.4 條件查詢（重點） 
  19.  *       1.5 分頁查詢 
  20.  *       1.6 聚合查詢 
  21.  *       1.7 查詢排序 
  22.  *       1.8 分組查詢 
  23.  *       1.9 分組后篩選 
  24.  *        
  25.  *   2）多表查詢 
  26.  *       1.1 內連接 
  27.  *       1.2 左外連接/右外連接    
  28.  *       * 
  29.  */        
  30. public class Demo {  
  31.     @Test  
  32.     public void test(){  
  33.         Session session = HibernateUtil.getSession();  
  34.         Transaction ts = session.getTransaction();  
  35.         try{  
  36.             ts.begin();  
  37.             //hql基本語法  
  38.             //1、創建一個Query對象  
  39.             //參數：需要執行的hql語句  
  40.             String hql = "select e from Employee e where id = 1";  
  41.             Query query = session.createQuery(hql);  
  42.             //2、執行查詢  
  43.             //2、1封裝所有  
  44.             List<Employee> emp = query.list();  
  45.             for(Employee e : emp){  
  46.                 System.out.println(e);  
  47.             }  
  48.               
  49.             //2、2 封裝一個（第一個）  
  50.             Employee empl = (Employee)query.uniqueResult();  
  51.             System.out.println(empl);  
  52.               
  53.             ts.commit();  
  54.               
  55.         }catch(Exception e){  
  56.             e.printStackTrace();  
  57.             ts.rollback();  
  58.         }  
  59.     }  
  60.       
  61.       
  62.     //單表查詢  
  63.     @Test  
  64.     public void test3(){  
  65.         Session session = HibernateUtil.getSession();  
  66.         Transaction ts = session.getTransaction();  
  67.         try{  
  68.             ts.begin();  
  69. //           *  1）單表查詢  
  70. //           *       1.1 全表查詢  
  71.         //  String hql = "from star.july.d_hql.Employee";  
  72.             //auto-import:自動到爆，自動在每個包下面搜索對應這個類的包，多個同名類的報會沖突  
  73. //          String hql = "select e from Employee e";  
  74.               
  75. //           *       1.2 指定字段查詢  
  76.             //返回對象數組  
  77. //          String hql = "select e.name,e.title from Employee e";  
  78.               
  79. //           *       1.3 排除重復記錄  
  80. //          String hql = "select distinct(e.gender) from Employee e";  
  81.               
  82. //           *       1.4 條件查詢（重點）(where)  
  83.             //邏輯條件：and  or  
  84.             // 模糊查詢：like: % _  
  85.             //比較查詢： < > <= >= between and <>  
  86.             //判空查詢： is null ,is not null, ='',<>'';  
  87. //          String hql = "select e from Employee e where name like '張%'";  
  88. //          String hql = "select e from Employee e where e.gender is null or e.gender=''";  
  89.               
  90. //           *       1.5 分頁查詢  
  91.         /*  String hql = "from Employee "; 
  92.             Query query = session.createQuery(hql); 
  93.             //設置開始讀取行 
  94.             query.setFirstResult(0); 
  95.             //每頁讀取多少條信息 
  96.             query.setMaxResults(3);*/  
  97.               
  98. //           *       1.6 聚合查詢  
  99.             //avg,count,max,min,uniqueResult  
  100. //          String hql = "select max(e.salary) from Employee e";  
  101.               
  102. //           *       1.7 查詢排序  
  103.             //order by  
  104.             //desc：降序  asc：升序  
  105. //          String hql = "select e from Employee e order by id desc ";  
  106.               
  107.               
  108. //           *       1.8 分組查詢  
  109. //          String hql = "select e from Employee e group by e.gender";  
  110.           
  111. //           *       1.9 分組后篩選  
  112.             String hql = "select e from Employee e  where e.gender is not null and e.gender<>'' group by e.gender having count(e.gender)>1";  
  113.               
  114.             Query query = session.createQuery(hql);  
  115.               
  116.               
  117.             //集合對象  
  118.             List<Object> e = query.list();  
  119.             for(Object emp : e){  
  120.                 System.out.println(emp);  
  121.             }  
  122.               
  123.               
  124.             //對象數組  
  125.         /*  List<Object[]> objects = query.list(); 
  126.             for(Object[] object : objects){ 
  127.                 for(Object obj:object ){ 
  128.                 System.out.print(obj); 
  129.                 } 
  130.                 System.out.println(); 
  131.             }   */        
  132.               
  133.               
  134.             //封裝一個對象  
  135.             /*Object unique = query.uniqueResult(); 
  136.             System.out.println(unique);*/  
  137.               
  138.               
  139.               
  140.             ts.commit();  
  141.         }catch(Exception e){  
  142.             e.printStackTrace();  
  143.             ts.rollback();  
  144.         }  
  145.     }  
  146.       
  147.       
  148.     //多表查詢  
  149.         @Test  
  150.         public void test2(){  
  151.             Session session = HibernateUtil.getSession();  
  152.             Transaction ts = session.getTransaction();  
  153.             try{  
  154.                 ts.begin();  
  155.                   
  156.                 /** 
  157.                  *步驟 
  158.                  *1、確定查詢哪些對象 
  159.                  *2、確定擦汗尋哪些屬性 
  160.                  *3、確定連接條件 
  161.                  *4、業務條件  
  162.                  */  
  163.                 //1、內連接查詢  
  164.                 //效果：只有滿足條件的數據才會被顯示出來  
  165.                 //查詢員工及其部門：顯示員工名稱，部門名稱  
  166. //              String hql = "select e.name,d.deptName from Employee e , Dept d where e.dept.id=d.id";  
  167.                 //另一種寫法  
  168. //              String hql = "select e.name,d.deptName from Employee e inner join e.dept d";  
  169.                   
  170.                   
  171.                 //左外連接  
  172.                 //效果：優先顯示左表，右表的數據匹配顯示，不匹配則顯示null  
  173.                 //查詢所有部門的員工(沒有員工的部門也要顯示出來)  
  174.                 String hql = "select d.deptName, e.name from Dept d left outer join d.employee e";  
  175.                   
  176.                 //右外連接  
  177. //              String hql = "select d.deptName,e.name from Employee e right outer join e.dept d";  
  178.                 Query query = session.createQuery(hql);  
  179.                   
  180.                 /*List<Object>  object = query.list(); 
  181.                 for(Object obj:object){ 
  182.                     System.out.println(obj); 
  183.                 }*/  
  184.                   
  185.                 List<Object[]> objects = query.list();  
  186.                 for(Object[] object:objects){  
  187.                     for(Object obj : object){  
  188.                         System.out.print(obj);  
  189.                     }  
  190.                     System.out.println();  
  191.                 }  
  192.                   
  193.                   
  194.                   
  195.                   
  196.                 ts.commit();  
  197.                   
  198.             }catch(Exception e){  
  199.                 e.printStackTrace();  
  200.                 ts.rollback();  
  201.             }  
  202.         }  
  203. }  

    Hibernate主要支持兩種查詢方式：HQL查詢和Criteria查詢。前者應用較為廣發，后者也只是調用封裝好的接口。

現在有一個問題，就是實現多表連接查詢，且查詢結果集不與任何一個實體類對應，怎么解決呢？

舉個例子：

現在有兩個表，一個users用戶表, 一個goods商品表，每個用戶可以有多個商品，而一個商品只能對應一個用戶。

users表中的字段：userId,userName,telephone,address

goods表中的字段：goodsId,goodsName,userId

現在要實現兩表連接查詢，查出每個用戶所擁有的商品，並把該用戶的信息和其商品信息顯示出來。

使用Hibernate反向生成的實體類分別是Users和Goods。

有兩種方式：

（1）使用傳統方式：

String hql="select u.userName, u.telephone, u.address, g.goodsName from Users u, Goods g where u.userId=g.userId";

根據這個查詢語句，調用query.list()方法得到一個List值，這個List中的每一個值都是Object[]類型的，里面包含了查詢出來的所有值，剩下的自個兒去處理就行了

    例如：需要將查詢的結果集 進行一下轉換：

    List stuList = scoreService.findAllScore(queryScore, null); // 返回的結果集
       if(stuList != null && stuList.size()>0){
        list = new LinkedList();
        StudentScore st;
        for(int i = 0; i < stuList.size();i++){
         st = new StudentScore();
         Object[] object = (Object[])stuList.get(i);// 每行記錄不在是一個對象 而是一個數組
         String userId =  (String)object[0];
         String username =  (String)object[1];
         String truename =  (String)object[2];
         String sex =  (String)object[3];
         String idnum =  (String)object[4];
         String level =  (String)object[5];
         Double sumScore =  Double.parseDouble(String.valueOf(object[6]));
         String paperId =  (String)object[7];
         // 重新封裝在一個javabean里面
         st.setUserId(userId);
         st.setUsername(username);
         st.setTruename(truename);
         st.setIdnum(idnum);
         st.setLevel(DictSwitch.getValue("DICT_LEVEL",level));
         st.setSex(DictSwitch.getValue("DICT_SEX",sex));
         st.setPaperId(paperId);
         st.setSumScore(sumScore);
         st.setExamplace(DictSwitch.getValue("DICT_EXAMSTATION",examplace));
         list.add(st); // 最終封裝在list中 傳到前台。
        }

    （2）增加一個映射類

增加一個映射類UsersVoGoods.java，添加需要查詢的信息相關的所有屬性，本例中添加userName, telephone, address, goodsName。並為這幾個屬性添加setter和getter方法，增加構造函數，參數與這四個屬性對應，那么可以用hql查詢方式：

String hql = "select new com.test.UsersVoGoods(u.userName, u.teltphone, u.address, g.goodsName) from Users u, Goods g where u.userId=g.userId";

query.list()的返回值List中的值都是UsersVoGoods型的，直接使用get()就能獲取。

其實不增加映射類也是可以的，只需要在Users.java實體類里增加一個構造函數，函數參數還是需要的所有字段，並為這些參數中Users實體原來沒有的字段添加屬性和getter() setter()即可。
    復制代碼


免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。



猜您在找 Hibernate HQL多表查詢 hibernate多表查詢HQL Hibernate 中Hql 查詢中間表的用法 HQL多表查詢 ---- Hibernate之查詢語句 HQL單表查詢 ---- Hibernate之查詢語句 Hibernate之HQL查詢的一些例子 Hibernate HQL中的子查詢 hql多表聯合查詢 (轉)Hibernate中關於多表連接查詢hql 和 sql 返回值集合中對象問題 【Hibernate的HQL多表聯合查詢使用left join方式】
 
粵ICP備18138465號   © 2018-2025 CODEPRJ.COM