框架之 hibernate之各種查詢

1. Hibernate的查詢方式
2. Hibernate的查詢策略

---

案例：使用Hibernate完成查詢所有聯系人功能

---

需求分析

1. 完成所有的聯系人的查詢

---

技術分析之Hibernate框架的查詢方式

1. 唯一標識OID的檢索方式
    * session.get(對象.class,OID)
2. 對象的導航的方式

3. HQL的檢索方式
    * Hibernate Query Language  -- Hibernate的查詢語言

4. QBC的檢索方式
    * Query By Criteria -- 條件查詢

5. SQL檢索方式（了解）
    * 本地的SQL檢索

---

技術分析之HQL的查詢方式概述

1. HQL的介紹
    * HQL(Hibernate Query Language) 是面向對象的查詢語言, 它和 SQL 查詢語言有些相似
    * 在 Hibernate 提供的各種檢索方式中, HQL 是使用最廣的一種檢索方式

2. HQL與SQL的關系
    * HQL 查詢語句是面向對象的,Hibernate負責解析HQL查詢語句, 然后根據對象-關系映射文件中的映射信息, 把 HQL 查詢語句翻譯成相應的 SQL 語句. 
    * HQL 查詢語句中的主體是域模型中的類及類的屬性
    * SQL 查詢語句是與關系數據庫綁定在一起的. SQL查詢語句中的主體是數據庫表及表的字段

---

技術分析之HQL的查詢演示

1. HQL基本的查詢格式
    * 支持方法鏈的編程，即直接調用list()方法
    * 簡單的代碼如下
        * session.createQuery("from Customer").list();

2. 使用別名的方式
    * 可以使用別名的方式
        * session.createQuery("from Customer c").list();
        * session.createQuery("select c from Customer c").list();

3. 排序查詢
    * 排序查詢和SQL語句中的排序的語法是一樣的
        * 升序
            * session.createQuery("from Customer order by cust_id").list();

        * 降序
            * session.createQuery("from Customer order by cust_id desc").list();

4. 分頁查詢
    * Hibernate框架提供了分頁的方法，咱們可以調用方法來完成分頁
    * 兩個方法如下
        * setFirstResult(a)     -- 從哪條記錄開始，如果查詢是從第一條開啟，值是0
        * setMaxResults(b)      -- 每頁查詢的記錄條數

    * 演示代碼如下
        * List<LinkMan> list = session.createQuery("from LinkMan").setFirstResult(0).setMaxResults().list();

5. 帶條件的查詢
    * setParameter("?號的位置，默認從0開始","參數的值"); 不用考慮參數的具體類型
    * 按位置綁定參數的條件查詢（指定下標值，默認從0開始）
    * 按名稱綁定參數的條件查詢（HQL語句中的 ? 號換成 :名稱 的方式）
    * 例如代碼如下
        Query query = session.createQuery("from Linkman where lkm_name like ? order by lkm_id desc");
        query.setFirstResult(0).setMaxResults(3);
        query.setParameter(0, "%熊%");
        List<Linkman> list = query.list();
        for (Linkman linkman : list) {
            System.out.println(linkman);
        }

---

HQL的投影查詢

1. 投影查詢就是想查詢某一字段的值或者某幾個字段的值
2. 投影查詢的案例
    * 如果查詢多個字段，例如下面這種方式
        List<Object[]> list = session.createQuery("select c.cust_name,c.cust_level from Customer c").list();
        for (Object[] objects : list) {
            System.out.println(Arrays.toString(objects));
        }

    * 如果查詢兩個字段，也可以把這兩個字段封裝到對象中
        * 先在持久化類中提供對應字段的構造方法
        * 使用下面這種HQL語句的方式
            List<Customer> list = session.createQuery("select new Customer(c.cust_name,c.cust_level) from Customer c").list();
            for (Customer customer : list) {
                System.out.println(customer);
            }

---

技術分析之聚合函數查詢

1. 獲取總的記錄數
    Session session = HibernateUtils.getCurrentSession();
    Transaction tr = session.beginTransaction();
    List<Number> list = session.createQuery("select count(c) from Customer c").list();
    Long count = list.get(0).longValue();
    System.out.println(count);
    tr.commit();

2. 獲取某一列數據的和
    Session session = HibernateUtils.getCurrentSession();
    Transaction tr = session.beginTransaction();
    List<Number> list = session.createQuery("select sum(c.cust_id) from Customer c").list();
    Long count = list.get(0).longValue();
    System.out.println(count);
    tr.commit();

---

技術分析之QBC檢索方式

0. QBC：Query By Criteria  按條件進行查詢

1. 簡單查詢，使用的是Criteria接口
    List<Customer> list = session.createCriteria(Customer.class).list();
    for (Customer customer : list) {
        System.out.println(customer);
    }

2. 排序查詢
    * 需要使用addOrder()的方法來設置參數，參數使用org.hibernate.criterion.Order對象
    * 具體代碼如下：
        Session session = HibernateUtils.getCurrentSession();
        Transaction tr = session.beginTransaction();
        Criteria criteria = session.createCriteria(Linkman.class);
        // 設置排序
        criteria.addOrder(Order.desc("lkm_id"));
        List<Linkman> list = criteria.list();
        for (Linkman linkman : list) {
            System.out.println(linkman);
        }
        tr.commit();

3. 分頁查詢
    * QBC的分頁查詢也是使用兩個方法
        * setFirstResult();
        * setMaxResults();

    * 代碼如下;
        Session session = HibernateUtils.getCurrentSession();
        Transaction tr = session.beginTransaction();
        Criteria criteria = session.createCriteria(Linkman.class);
        // 設置排序
        criteria.addOrder(Order.desc("lkm_id"));
        criteria.setFirstResult(0);
        criteria.setMaxResults(3);
        List<Linkman> list = criteria.list();
        for (Linkman linkman : list) {
            System.out.println(linkman);
        }
        tr.commit();

4. 條件查詢（Criterion是查詢條件的接口，Restrictions類是Hibernate框架提供的工具類，使用該工具類來設置查詢條件）
    * 條件查詢使用Criteria接口的add方法，用來傳入條件。
    * 使用Restrictions的添加條件的方法，來添加條件，例如：
        * Restrictions.eq           -- 相等
        * Restrictions.gt           -- 大於號
        * Restrictions.ge           -- 大於等於
        * Restrictions.lt           -- 小於
        * Restrictions.le           -- 小於等於
        * Restrictions.between      -- 在之間
        * Restrictions.like         -- 模糊查詢
        * Restrictions.in           -- 范圍
        * Restrictions.and          -- 並且
        * Restrictions.or           -- 或者

    * 測試代碼如下
        Session session = HibernateUtils.getCurrentSession();
        Transaction tr = session.beginTransaction();
        Criteria criteria = session.createCriteria(Linkman.class);
        // 設置排序
        criteria.addOrder(Order.desc("lkm_id"));
        // 設置查詢條件
        criteria.add(Restrictions.or(Restrictions.eq("lkm_gender", "男"), Restrictions.gt("lkm_id", 3L)));
        List<Linkman> list = criteria.list();
        for (Linkman linkman : list) {
            System.out.println(linkman);
        }
        tr.commit();

5. 聚合函數查詢（Projection的聚合函數的接口，而Projections是Hibernate提供的工具類，使用該工具類設置聚合函數查詢）
    * 使用QBC的聚合函數查詢，需要使用criteria.setProjection()方法
    * 具體的代碼如下
        Session session = HibernateUtils.getCurrentSession();
        Transaction tr = session.beginTransaction();
        Criteria criteria = session.createCriteria(Linkman.class);
        criteria.setProjection(Projections.rowCount());
        List<Number> list = criteria.list();
        Long count = list.get(0).longValue();
        System.out.println(count);
        tr.commit();

---

技術分析之離線條件查詢

1. 離線條件查詢使用的是DetachedCriteria接口進行查詢，離線條件查詢對象在創建的時候，不需要使用Session對象，只是在查詢的時候使用Session對象即可。
2. 創建離線條件查詢對象
    * DetachedCriteria criteria = DetachedCriteria.forClass(Linkman.class);

3. 具體的代碼如下
    Session session = HibernateUtils.getCurrentSession();
    Transaction tr = session.beginTransaction();

    DetachedCriteria criteria = DetachedCriteria.forClass(Linkman.class);
    // 設置查詢條件
    criteria.add(Restrictions.eq("lkm_gender", "男"));
    // 查詢數據
    List<Linkman> list = criteria.getExecutableCriteria(session).list();
    for (Linkman linkman : list) {
        System.out.println(linkman);
    }
    tr.commit();

---

技術分析之SQL查詢方式（了解）

1. 基本語法
    Session session = HibernateUtils.getCurrentSession();
    Transaction tr = session.beginTransaction();

    SQLQuery sqlQuery = session.createSQLQuery("select * from cst_linkman where lkm_gender = ?");
    sqlQuery.setParameter(0,"男");
    sqlQuery.addEntity(Linkman.class);
    List<Linkman> list = sqlQuery.list();
    System.out.println(list);
    tr.commit();

---

技術分析之HQL多表查詢

1. 多表的查詢進來使用HQL語句進行查詢，HQL語句和SQL語句的查詢語法比較類似。
    * 內連接查詢
        * 顯示內連接
            * select * from customers c inner join orders o on c.cid = o.cno;
        * 隱式內連接
            * select * from customers c,orders o where c.cid = o.cno;

    * 外連接查詢
        * 左外連接
            * select * from customers c left join orders o on c.cid = o.cno;
        * 右外連接
            * select * from customers c right join orders o on c.cid = o.cno;

2. HQL的多表查詢
    * 迫切和非迫切：
        * 非迫切返回結果是Object[]
        * 迫切連接返回的結果是對象，把客戶的信息封裝到客戶的對象中，把訂單的信息封裝到客戶的Set集合中。

3. 內連接查詢
    * 內連接使用 inner join ，默認返回的是Object數組
        Session session = HibernateUtils.getCurrentSession();
        Transaction tr = session.beginTransaction();
        List<Object[]> list = session.createQuery("from Customer c inner join c.linkmans").list();
        for (Object[] objects : list) {
            System.out.println(Arrays.toString(objects));
        }
        tr.commit();

    * 迫切內連接:inner join fetch ，返回的是實體對象
        Session session = HibernateUtils.getCurrentSession();
        Transaction tr = session.beginTransaction();
        List<Customer> list = session.createQuery("from Customer c inner join fetch c.linkmans").list();
        Set<Customer> set = new HashSet<Customer>(list);
        for (Customer customer : set) {
            System.out.println(customer);
        }
        tr.commit();

4. 左外連接查詢
    * 左外連接: 封裝成List<Object[]>

    * 迫切左外連接
        Session session = HibernateUtils.getCurrentSession();
        Transaction tr = session.beginTransaction();
        List<Customer> list = session.createQuery("from Customer c left join fetch c.linkmans").list();
        Set<Customer> set = new HashSet<Customer>(list);
        for (Customer customer : set) {
            System.out.println(customer);
        }
        tr.commit();

---

案例一代碼實現

---

案例二：對查詢功能優化

---

需求分析

1. 對Hibernate框架的查詢進行優化

---

技術分析之延遲加載

1. 延遲加載先獲取到代理對象，當真正使用到該對象中的屬性的時候，才會發送SQL語句，是Hibernate框架提升性能的方式
2. 類級別的延遲加載
    * Session對象的load方法默認就是延遲加載
    * Customer c = session.load(Customer.class, 1L);沒有發送SQL語句，當使用該對象的屬性時，才發送SQL語句

    * 使類級別的延遲加載失效
        * 在<class>標簽上配置lazy=”false”
        * Hibernate.initialize(Object proxy);

3. 關聯級別的延遲加載（查詢某個客戶，當查看該客戶下的所有聯系人是是否是延遲加載）
    * 默認是延遲加載
        Session session = HibernateUtils.getCurrentSession();
        Transaction tr = session.beginTransaction();
        Customer c = session.get(Customer.class, 1L);
        System.out.println("=============");
        System.out.println(c.getLinkmans().size());
        tr.commit();

---

技術分析之Hibernate框架的查詢策略

1. 查詢策略：使用Hibernate查詢一個對象的時候，查詢其關聯對象.應該如何查詢.是Hibernate的一種優化手段!!!    
2. Hibernate框架的檢索策略解決的問題
    * 查詢的時機
        Customer c1 = (Customer) session.get(Customer.class, 1);
        System.out.println(c1.getLinkmans().size());

        * lazy屬性解決查詢的時機的問題，需要配置是否采用延遲加載！！

    * 查詢的語句形式
        List<Customer> list = session.createQuery("from Customer").list();
        for(Customer c : list){
            System.out.println(c.getLinkmans());
        }

        * fetch屬性就可以解決查詢語句的形式的問題！！

---

技術分析之在set標簽上配置策略

1. 在<set>標簽上使用fetch和lazy屬性
    * fetch的取值              -- 控制SQL語句生成的格式
        * select                -- 默認值.發送查詢語句
        * join                  -- 連接查詢.發送的是一條迫切左外連接!!!配置了join.lazy就失效了
        * subselect             -- 子查詢.發送一條子查詢查詢其關聯對象.(需要使用list()方法進行測試)

    * lazy的取值               -- 查找關聯對象的時候是否采用延遲!
        * true                  -- 默認.延遲
        * false                 -- 不延遲
        * extra                 -- 及其懶惰

2. set標簽上的默認值是fetch="select"和lazy="true"

3. 總結：Hibernate框架都采用了默認值，開發中基本上使用的都是默認值。特殊的情況。

---

技術分析之在man-to-one標簽上配置策略

1. 在<many-to-one>標簽上使用fetch和lazy屬性
    * fetch的取值      -- 控制SQL的格式.
        * select        -- 默認。發送基本select語句查詢
        * join          -- 發送迫切左外連接查詢

    * lazy的取值       -- 控制加載關聯對象是否采用延遲.
        * false         -- 不采用延遲加載.
        * proxy         -- 默認值.代理.現在是否采用延遲.
            * 由另一端的<class>上的lazy確定.如果這端的class上的lazy=”true”.proxy的值就是true(延遲加載).
            * 如果class上lazy=”false”.proxy的值就是false(不采用延遲.)

2. 在<many-to-one>標簽上的默認值是fetch="select"和proxy

---

代碼實現

　　TestHQLDemo

package com.xujingyang.test ;

import java.util.List ;
import org.hibernate.Query ;
import org.hibernate.Session ;
import org.hibernate.Transaction ;
import org.junit.Test ;
import com.xujingyang.utils.HibernateUtil ;

/**
 * @author oldmonk
 * @date   2017年4月19日
 */
public class TestHQLDemo {
    
    /**
     * 排序查詢
     */
    @Test
    public void demo1() {
        Session session = HibernateUtil.getSession() ;
        Transaction transaction = session.beginTransaction() ;
        Query query = session.createQuery("from Customer order by cust_id desc") ;
        List<Customer> list = query.list() ;
        for (Customer customer : list) {
            System.out.println(customer) ;
        }
        
        transaction.commit() ;
    }
    
    /**
     * 檢索查詢
     */
    @Test
    public void demo2() {
        Session session = HibernateUtil.getSession() ;
        Transaction transaction = session.beginTransaction() ;
        // Query query = session.createQuery("from Customer where cust_id=?") ;
        // query.setLong(0, 2L);
        Query query = session.createQuery("from Customer where cust_id=2") ;
        List<Customer> list = query.list() ;
        for (Customer customer : list) {
            System.out.println(customer) ;
        }
        
        transaction.commit() ;
    }
    
    /**
     * 分頁查詢
     */
    @Test
    public void demo3() {
        Session session = HibernateUtil.getSession() ;
        Transaction transaction = session.beginTransaction() ;
        Query query = session.createQuery("from Customer") ;
        query.setFirstResult(0) ;// 從第幾條記錄開始
        query.setMaxResults(2) ;// 每頁顯示幾條數據
        List<Customer> list = query.list() ;
        for (Customer customer : list) {
            System.out.println(customer) ;
        }
        
        transaction.commit() ;
    }
    
    /**
     * 統計查詢
     */
    @Test
    public void demo4() {
        Session session = HibernateUtil.getSession() ;
        Transaction transaction = session.beginTransaction() ;
        Query query = session.createQuery("select count(1) from Customer") ;
        List list = query.list() ;
        System.out.println(list.get(0)) ;
        
        transaction.commit() ;
    }
    
    /**
     * 投影查詢
     */
    @Test
    public void demo5() {
        Session session = HibernateUtil.getSession() ;
        Transaction transaction = session.beginTransaction() ;
        Query query = session.createQuery("select cust_id from Customer") ;
        List list = query.list() ;
        
        for (Object object : list) {
            System.err.println(object) ;
        }
        transaction.commit() ;
    }
    
    /**
     * 連接查詢
     */
    @Test
    public void demo6() {
        Session session = HibernateUtil.getSession() ;
        Transaction transaction = session.beginTransaction() ;
        
        Query query = session.createQuery("from Customer c inner join fetch c.linkmans ") ;
        List<Object []> list = query.list() ;
        for (Object [] objects : list) {
            for (Object object : objects) {
                System.out.println(object) ;
            }
        }
        transaction.commit() ;
    }
    
    /**
     * 迫切內連接
     */
    @Test
    public void demo7() {
        Session session = HibernateUtil.getSession() ;
        Transaction transaction = session.beginTransaction() ;
        
        Query query = session.createQuery("from Customer c inner join fetch c.linkmans ") ;
        List<Customer> list = query.list() ;
        for (Customer customer : list) {
            System.out.println(customer) ;
        }
        transaction.commit() ;
    }
    /**
     * 外連接
     */
    @Test
    public void demo8() {
        Session session = HibernateUtil.getSession() ;
        Transaction transaction = session.beginTransaction() ;
        
        Query query = session.createQuery("from Customer c left join fetch c.linkmans ") ;
        List<Customer> list = query.list() ;
        for (Customer customer : list) {
            System.out.println(customer) ;
        }
        transaction.commit() ;
    }
    
}

 

　　TestQBCDemo

package com.xujingyang.test ;

import java.util.List ;
import org.hibernate.Criteria ;
import org.hibernate.Session ;
import org.hibernate.Transaction ;
import org.hibernate.criterion.DetachedCriteria ;
import org.hibernate.criterion.Order ;
import org.hibernate.criterion.Projection ;
import org.hibernate.criterion.Projections ;
import org.hibernate.criterion.Restrictions ;
import org.junit.Test ;
import com.xujingyang.utils.HibernateUtil ;

/**
 * @author oldmonk
 * @date   2017年4月19日
 */
public class TestQBCDemo {
    
    /**
     * 基本查詢
     */
    @Test
    public void demo1() {
        Session session = HibernateUtil.getSession() ;
        Transaction transaction = session.beginTransaction() ;
        
        Criteria criteria = session.createCriteria(Customer.class) ;
        List<Customer> list = criteria.list() ;
        for (Customer customer : list) {
            System.out.println(customer) ;
        }
        transaction.commit() ;
    }
    
    /**
     * 條件查詢
     */
    @Test
    public void demo2() {
        Session session = HibernateUtil.getSession() ;
        Transaction transaction = session.beginTransaction() ;
        
        Criteria criteria = session.createCriteria(Customer.class) ;
        // criteria.add(Restrictions.gt("cust_id", 3L));
        criteria.add(Restrictions.between("cust_id", 3L, 4L)) ;
        List<Customer> list = criteria.list() ;
        for (Customer customer : list) {
            System.out.println(customer) ;
        }
        transaction.commit() ;
    }
    
    /**
     * 分頁查詢
     */
    @Test
    public void demo3() {
        Session session = HibernateUtil.getSession() ;
        Transaction transaction = session.beginTransaction() ;
        
        Criteria criteria = session.createCriteria(Customer.class) ;
        criteria.setFirstResult(0) ;
        criteria.setMaxResults(2) ;
        List<Customer> list = criteria.list() ;
        for (Customer customer : list) {
            System.out.println(customer) ;
        }
        transaction.commit() ;
    }
    
    /**
     * 排序查詢
     */
    @Test
    public void demo4() {
        Session session = HibernateUtil.getSession() ;
        Transaction transaction = session.beginTransaction() ;
        
        Criteria criteria = session.createCriteria(Customer.class) ;
        criteria.addOrder(Order.desc("cust_id")) ;
        List<Customer> list = criteria.list() ;
        for (Customer customer : list) {
            System.out.println(customer) ;
        }
        transaction.commit() ;
    }
    
    /**
     * 統計查詢
     */
    @Test
    public void demo5() {
        Session session = HibernateUtil.getSession() ;
        Transaction transaction = session.beginTransaction() ;
        
        Criteria criteria = session.createCriteria(Customer.class) ;
        // criteria.setProjection(Projections.id());
        criteria.setProjection(Projections.sum("cust_id")) ;
        List list = criteria.list() ;
        for (Object obj : list) {
            System.out.println(obj) ;
        }
        transaction.commit() ;
    }
    
    /**
     * 離線條件查詢:DetachedCriteria(SSH整合經常使用.).
     * * 可以脫離session設置參數.
     */
    @Test
    public void demo6() {
        DetachedCriteria detachedCriteria = DetachedCriteria.forClass(Customer.class) ;
        detachedCriteria.add(Restrictions.gt("cust_id", 3L)) ;
        Session session = HibernateUtil.getSession() ;
        Transaction transaction = session.beginTransaction() ;
        
        List list = detachedCriteria.getExecutableCriteria(session).list() ;
        for (Object obj : list) {
            System.out.println(obj) ;
        }
        transaction.commit() ;
    }
    
}