Hibernate框架筆記04HQL_QBC查詢詳解_抓取策略優化機制

阿新 • • 發佈：2019-04-25

新項目 long ini title 右外連接 int 方式 set 不包含

1. Hibernate的查詢方式
- 1.1 方式一：OID查詢
- 1.2 方式二：對象導航查詢
- 1.3 方式三：HQL方式
- 1.4 方式四：QBC查詢
- 1.5 方式五：SQL查詢
2. 環境搭建
3. HQL查詢
- 3.1 簡單查詢
- 3.2 別名查詢
- 3.3 排序查詢
- 3.4 條件查詢
- 3.4 投影查詢
- 3.5 分頁查詢
- 3.6 分組統計查詢
- 3.7 HQL的多表查詢
  - 3.7.1 SQL的多表查詢
  - 3.7.2 HQL的多表查詢
4. QBC查詢
- 4.1 簡單查詢
- 4.2 排序查詢
- 4.3 分頁查詢
- 4.4 條件查詢
- 4.5 統計查詢
- 4.6 離線條件查詢（***）DetachedCriteria
5. SQL查詢
6. Hibernate的抓取策略
- 6.1 延遲加載的概述
  - 6.1.1 什麽是延遲加載
  - 6.1.2 延遲加載的分類
- 6.2 抓取策略
  - 6.2.1 抓取策略概述
  - 6.2.2 set上的fetch和lazy
  - 6.2.3 many-to-one上的fetch和lazy
  - 6.2.4 批量抓取

技術分享圖片

1. Hibernate的查詢方式

在Hibernate中提供了5種查詢方式。

1.1 方式一：OID查詢

OID查詢：Hibernate根據對象的OID（主鍵）進行檢索。
使用get()方法
- Customer customer = session.get(Customer.class,1L);
使用load()方法
- Customer customer = session.load(Custoemr.class,1L);

1.2 方式二：對象導航查詢

對象導航檢索：Hibernate根據一個已經查詢到的對象，獲得其關聯的對象的一種查詢方式。

LinkMan linkMan = session.get(LinkMan.class,1L);
Customer customer = linkMan.getCustomer();

Customer customer = session.get(Customer.class,2L);
Set<LinkMan> linkMans = customer.getLinkMans();

1.3 方式三：HQL方式

HQL查詢：Hibernate Query Language，Hibernate的查詢語言，是一種面向對象的方式的查詢語言，語法類似SQL。通過session.createQuery()，接收一個HQL進行查詢方式。

1.4 方式四：QBC查詢

QBC查詢：Query By Criteria，條件查詢。是一種更加面向對象化的查詢方式。

1.5 方式五：SQL查詢

SQL查詢：通過使用SQL語句進行查詢。

2. 環境搭建

創建一個新項目，導入相關jar包
新建數據庫，新建數據表，分別為cst_custoemr和cst_linkman
新建兩個實體，分別為Customer和LinkMan
- Customer中生成toString方法，不包含LinkMan
- LinkMan中生成toString方法，不包含Customer
準備工具類，配置文件，映射文件

生成測試的數據，該方法執行3次

/**
 *    HQL的查詢方式的測試類
 * @author itzhouq
 *
 */
public class HibernateDemo1 {

  @Test
  public void test1() {
      Session session = HibernateUtils.getCurrentSession();
      Transaction transaction = session.beginTransaction();
      Customer customer = new Customer();
      customer.setCust_name("莫爾德");
      for (int i = 0; i < 10; i++) {
          LinkMan linkMan = new LinkMan();
          linkMan.setLkm_name("老馬"+i);

          customer.getLinkMans().add(linkMan);

          session.save(linkMan);
      }
      session.save(customer);
      transaction.commit();

  }
}

3. HQL查詢

3.1 簡單查詢

@Test
    public void test2() {//HQL的簡單查詢
        Session session = HibernateUtils.getCurrentSession();
        Transaction transaction = session.beginTransaction();
        // 簡單查詢
        Query query = session.createQuery("from Customer");
        List<Customer> list = query.list();
        
        // sql中支持*號的寫法：select * from cst_customer;但是在HQL中不支持*號的寫法。
//      Query query2 = session.createQuery("select * from from Customer");// 報錯
//      List<Customer> list2 = query.list();
        
        for (Customer customer : list) {
            System.out.println(customer);
            
        }
        transaction.commit();
    }

3.2 別名查詢

@Test
    public void test3() {// 別名查詢
        Session session = HibernateUtils.getCurrentSession();
        Transaction transaction = session.beginTransaction();
        // 別名查詢
//      Query query = session.createQuery("from Customer c");
//      List<Customer> list = query.list();
        
        Query query = session.createQuery("select c from Customer c");
        List<Customer> list = query.list();
        
        for (Customer customer : list) {
            System.out.println(customer);
            
        }
        transaction.commit();
    }

3.3 排序查詢

@Test
    public void test5() {// 排序查詢
        Session session = HibernateUtils.getCurrentSession();
        Transaction transaction = session.beginTransaction();
        // 排序查詢
        // 默認情況
        //List<Customer> list = session.createQuery("from Customer order by cust_id").list();
        
        // 設置兼降序排序       升序使用asc 降序使用desc
        List<Customer> list = session.createQuery("from Customer order by cust_id desc").list();
        
        
        
        for (Customer customer : list) {
            System.out.println(customer);
            
        }
        transaction.commit();
    }

3.4 條件查詢

@Test
    public void test4() {// 排序查詢
        Session session = HibernateUtils.getCurrentSession();
        Transaction transaction = session.beginTransaction();
        // 排序查詢
        // 1. 按位置綁定：根據參數的位置進行綁定
        // 一個條件
//      Query query = session.createQuery("from Customer where cust_name = ?");
//      query.setParameter(0, "朱元璋");
        
        // 多個條件
//      Query query = session.createQuery("from Customer where cust_source = ? and cust_name like ?");
//      query.setParameter(0, "朋友推薦");
//      query.setParameter(1, "朱%");
        
        // 2. 按名稱綁定
        Query query = session.createQuery("from Customer where cust_source = :aaa and cust_name like :bbb");
        // 設置參數：
        query.setParameter("aaa", "朋友推薦");
        query.setParameter("bbb", "朱%");
        List<Customer> list = query.list();
        
        for (Customer customer : list) {
            System.out.println(customer);
            
        }
        transaction.commit();
    }

3.4 投影查詢

投影查詢：查詢對象的某個或某些屬性

@Test
    public void test6() {// 投影查詢
        Session session = HibernateUtils.getCurrentSession();
        Transaction transaction = session.beginTransaction();
        // 投影查詢
        // 單個屬性
//      List<Object> list = session.createQuery("select c.cust_name from Customer c").list();
//      for (Object customer : list) {
//          System.out.println(customer);
//          
//      }
        
        // 多個屬性：
//      List<Object[]> list = session.createQuery("select c.cust_name,c.cust_source from Customer c").list();
//      for (Object[] objects : list) {
//          System.out.println(Arrays.toString(objects));
//      }
        
        // 查詢多個屬性，但我想封裝到對象中-----需要這兩個參數的構造函數
        List<Object[]> list = session.createQuery("select c.cust_name,c.cust_source from Customer c").list();
        for (Object[] customer : list) {
            System.out.println(Arrays.toString(customer));
        }
        
        transaction.commit();
    }

3.5 分頁查詢

@Test
    public void test7() {// 分頁查詢
        Session session = HibernateUtils.getCurrentSession();
        Transaction transaction = session.beginTransaction();
        // 分頁查詢
        Query query = session.createQuery("from LinkMan");
        query.setFirstResult(20);
        query.setMaxResults(5);
        List<LinkMan> list = query.list();
        for (LinkMan linkMan : list) {
            System.out.println(linkMan);
        }
        
        transaction.commit();
    }

3.6 分組統計查詢

@Test
    public void test8() {// 分組統計查詢
        Session session = HibernateUtils.getCurrentSession();
        Transaction transaction = session.beginTransaction();
        // 分組統計查詢
        Object object = session.createQuery("select count(*) from Customer").uniqueResult();
        System.out.println(object);
        
        //分組統計：
        Query query = session.createQuery("select cust_source,count(*) from Customer group by cust_source");
        List<Object[]> list = query.list();
        for (Object[] objects : list) {
            System.out.println(Arrays.toString(objects));
        }
        transaction.commit();
    }

3.7 HQL的多表查詢

3.7.1 SQL的多表查詢

連接查詢
- 交叉連接：笛卡爾積
- 內連接：innner join(inner可以省略)
  - 隱式內連接：select * from A,B where A.id = B.aid;
  - 顯式內連接：select * from A inner join B on A.id = B.aid;
- 外連接：outer可以省略
  - 左外連接：select * from A left outer join B on A.id = B.id;
  - 右外連接：select * from A right outerjoin B on A.id = B.id;
子查詢

3.7.2 HQL的多表查詢

連接查詢
- 交叉連接
- 內連接：
  - 顯式內連接
  - 隱式內連接
  - 迫切內連接
- 外連接：
  - 左外連接
  - 右外連接
  - 迫切左外連接

@Test
    public void test7() { // 多表查詢
        Session session = HibernateUtils.getCurrentSession();
        Transaction transaction = session.beginTransaction();
        
        // SQL：select * from cst_customer c inner join cst_linkman l on c.cust_id = l.lkm_cust_id
        // HQL:內連接from Customer c inner join c.linkMans
        // 內連接得到的是一個數組
        
//      List<Object[]> list = session.createQuery("from Customer c inner join c.linkMans").list();
//      for (Object[] objects : list) {
//          System.out.println(Arrays.toString(objects));
//      }
        
        // HQL：迫切內連接，其實就是在普通的內連接inner join後添加一個關鍵字fetch.
        // 迫切內連接的到的是一個對象，在Customer的toString中給定LinkMans可以得到全部字段
        List<Customer> list2 = session.createQuery("select distinct c from Customer c inner join fetch c.linkMans").list();
        for (Customer customer : list2) {
            System.out.println(customer);
        }
        
        transaction.commit();
    }

4. QBC查詢

4.1 簡單查詢

@Test
    public void test1() { // 簡單查詢
        Session session = HibernateUtils.getCurrentSession();
        Transaction transaction = session.beginTransaction();
        //獲得Criteria的對象
        Criteria criteria = session.createCriteria(Customer.class);
        List<Customer> list = criteria.list();
        for (Customer customer : list) {
            System.out.println(customer);
        }
        
        transaction.commit();
    }

4.2 排序查詢

@Test
    public void test2() { // 排序查詢
        Session session = HibernateUtils.getCurrentSession();
        Transaction transaction = session.beginTransaction();
        //獲得Criteria的對象
        Criteria criteria = session.createCriteria(Customer.class);
//      criteria.addOrder(Order.desc("cust_id"));   // 降序
        criteria.addOrder(Order.asc("cust_id"));    // 升序
        List<Customer> list = criteria.list();
        for (Customer customer : list) {
            System.out.println(customer);
        }
        
        transaction.commit();
    }

4.3 分頁查詢

@Test
    public void test3() { // 分頁查詢
        Session session = HibernateUtils.getCurrentSession();
        Transaction transaction = session.beginTransaction();
        //獲得Criteria的對象
        Criteria criteria = session.createCriteria(LinkMan.class);
        criteria.setFirstResult(20);
        criteria.setMaxResults(5);
        
        List<LinkMan> list = criteria.list();
        for (LinkMan linkMan : list) {
            System.out.println(linkMan);
        }
        
        transaction.commit();
    }

4.4 條件查詢

@Test
    public void test4() { // 條件查詢
        Session session = HibernateUtils.getCurrentSession();
        Transaction transaction = session.beginTransaction();
        //獲得Criteria的對象
        Criteria criteria = session.createCriteria(Customer.class);
        // 設置條件
        /*
         *  =       eq
         *  >       gt
         *  >=      ge
         *  <       lt
         *  <=      le
         *  <>      ne
         *  like
         *  in
         *  and
         *  or
         */
        criteria.add(Restrictions.eq("cust_source", "小廣告"));
        criteria.add(Restrictions.like("cust_name", "李%"));
        List<Customer> list = criteria.list();
        for (Customer customer : list) {
            System.out.println(customer);
        }
        
        transaction.commit();
    }

4.5 統計查詢

@Test
    public void test5() { // 條件查詢
        Session session = HibernateUtils.getCurrentSession();
        Transaction transaction = session.beginTransaction();
        //獲得Criteria的對象
        Criteria criteria = session.createCriteria(Customer.class);
        /**
         *  add     :普通的條件。where後面條件
         *  addOrder:排序
         *  setProjecttion:聚合函數和group by having
         */
        
        criteria.setProjection(Projections.rowCount());
        Long num = (Long) criteria.uniqueResult();
        System.out.println(num);
        
        transaction.commit();
    }

4.6 離線條件查詢（***）DetachedCriteria

離線條件查詢在前臺需要傳遞多個條件，用於篩選的時候很方便，可以不用在dao層拼接字符串
代碼

@Test
    public void test6() { // 離線條件查詢
        DetachedCriteria detachedCriteria = DetachedCriteria.forClass(Customer.class);
        detachedCriteria.add(Restrictions.like("cust_name", "李%"));
        
        Session session = HibernateUtils.getCurrentSession();
        Transaction transaction = session.beginTransaction();
        Criteria criteria = detachedCriteria.getExecutableCriteria(session);
        List<Customer> list = criteria.list();
        for (Customer customer : list) {
            System.out.println(customer);
        }
        
        transaction.commit();
    }

5. SQL查詢


    @Test
    public void test1() {
        Session session = HibernateUtils.getCurrentSession();
        Transaction transaction = session.beginTransaction();
        
        // 調用的createSQLQuery，返回的值遍歷後是數組形式的集合
//      SQLQuery sqlQuery = session.createSQLQuery("select * from cst_customer");
//      List<Object[]> list = sqlQuery.list();
//      for (Object[] objects : list) {
//          System.out.println(Arrays.toString(objects));
//      }
        
        SQLQuery sqlQuery = session.createSQLQuery("select * from cst_customer");
        sqlQuery.addEntity(Customer.class); //封裝到實體Customer中
        List<Customer> list = sqlQuery.list();
        for (Customer customer : list) {
            System.out.println(customer);
        }
        
        transaction.commit();
    }

6. Hibernate的抓取策略

6.1 延遲加載的概述

6.1.1 什麽是延遲加載

延遲加載：lazy（懶加載）。執行到該行代碼的時候，不會發送語句去進行查詢，在真正使用這個對象的屬性的時候才會發送SQL語句進行查詢。

6.1.2 延遲加載的分類

類級別的延遲加載
- 指的是通過load方法查詢某個對象的時候，是否采用延遲加載。session.load(Customer.class,1L);
- 類級別的延遲加載通過<class>上的lazy進行配置。讓lazy失效的方法有：
  - 將lazy設置為false
  - 將持久化類使用final修改
  - Hibernate.ininialize()
關聯級別的延遲加載
- 指的是在查詢到某個對象的時候，查詢其關聯對象的時候，是否采用延遲加載。
```
Customer customer = session.get(Customer.class,1L);
customer.getLinkMans();
//通過客戶獲得聯系人的時候，聯系人對象是否采用了延遲記載，稱為關聯級別的延遲加載。
```
- 抓取策略往往會和關聯級別的延遲加載一起使用，優化語句。

6.2 抓取策略

Customer.hbm.xml

<set name="linkMans" fetch="select" lazy="true">
    <!-- column多的一方的外鍵的名稱 -->
    <key column="lkm_cust_id"></key>
    <!-- class：多的一方的類的全限定名 -->
    <one-to-many class="com.itzhouq.hibernate.domain.LinkMan"/>
</set>

6.2.1 抓取策略概述

通過一個對象抓取到關聯對象需要發送SQL語句，SQL語句如何發送，發送成什麽樣格式？這些可以通過策略進行配置。
- 通過<set>或者<many-to-one>上的fetch屬性進行配置
- fetch和這些標簽上的lazy如何設置，優化發送的SQL語句。

6.2.2 set上的fetch和lazy

fetch：抓取策略，控制SQL語句格式
- select：默認值，發送普通的select語句，查詢關聯對象。
- join：發送一條迫切左外連接查詢關聯對象。
- subeselect：發送一條子查詢查詢其關聯對象。
lazy：延遲加載，控制查詢關聯對象的時候是否采用延遲加載
- true：默認值，查詢關聯對象的時候，采用延遲加載
- false：查詢關聯對象的時候，不采用延遲加載
- extra：及其懶惰。
實際開發過程中，一般采用默認值。如果有特殊需求，可能需要配置join。

6.2.3 many-to-one上的fetch和lazy

fetch：抓取策略，控制SQL語句格式
- select：默認值，發送普通的select語句，查詢關聯對象。
- join：發送一條迫切左外連接
lazy：延遲加載，控制查詢關聯對象的時候是否采用延遲加載
- proxy：默認值，proxy具體的取值，取決於另一端的class上的lazy的值。
- false：查詢關聯對象，不采用延遲。
- no-proxy：不用
在實際開發過程中，一般采用默認值。如果有特殊的需求，可能需要配置join。

6.2.4 批量抓取

一批關聯對象一起抓取，betch-size。

package com.itzhouq.hibernate.demo;

import java.util.List;

import org.hibernate.Session;
import org.hibernate.Transaction;
import org.junit.Test;

import com.itzhouq.hibernate.domain.Customer;
import com.itzhouq.hibernate.domain.LinkMan;
import com.itzhouq.hibernate.utils.HibernateUtils;

/*
 *    批量抓取測試
 */
public class HibernateDemo4 {


  @Test
  public void test1() {
      // 獲取客戶的時候，批量抓取聯系人
      // 在Customer.hbm.xml中set上配置batch-size
      Session session = HibernateUtils.getCurrentSession();
      Transaction transaction = session.beginTransaction();
      List<Customer> list = session.createQuery("from Customer").list();
      for (Customer customer : list) {
          System.out.println(customer.getCust_name());
          for (LinkMan linkMan : customer.getLinkMans()) {
              System.out.println(linkMan.getLkm_name());
          }
      }

      transaction.commit();
  }
}

<set name="linkMans" batch-size="5">
    <!-- column多的一方的外鍵的名稱 -->
    <key column="lkm_cust_id"></key>
    <!-- class：多的一方的類的全限定名 -->
    <one-to-many class="com.itzhouq.hibernate.domain.LinkMan"/>
</set>

Hibernate框架筆記04HQL_QBC查詢詳解_抓取策略優化機制

新項目 long ini title 右外連接 int 方式 set 不包含目錄 1. Hibernate的查詢方式 1.1 方式一：OID查詢 1.2 方式二：對象導航查詢

Hibernate(四) - HQL_QBC查詢詳解--抓取策略優化機制

load i++ lec for 簡單的測試類 domain 字符 main.c Hibernate 的查詢方式　　在 Hibernate 中提供了很多種的查詢的方式。Hibernate 共提供了五種查詢方式。 1、Hibernate 的查詢方式：OID 查詢　　OI

【Hibernate（四）】HQL_QBC查詢詳解——抓取策略優化機制

1.2 Hibernate的查詢的方式 Hibernate共提供了五種查詢方式。 1.2.1 Hibernate的查詢方式：OID查詢 OID檢索：Hibernate根據物件的OID（主鍵）進行檢索 1.2.1.1 使用get方法 Customer customer

hibernate查詢&抓取策略優化機制

param sets 常用 detached action tin println distinct exec 一 HQL查詢 1 一次存1個客戶，10個聯系人。執行三次，存3個客戶，30個聯系人，為分頁查詢做準備　　@Test //來3個客戶，

Hibernate框架環境搭建（詳解）

obj 模型 junit demo 半成品 src 數據表 mys 種類具體說hibernate框架的項目搭建之前，首先說一下什麽是框架。。。框架可以理解成一個半成品的項目，它封裝了一些功能，我麽需要掌握的是如何駕馭這些功能，不需要操心它是怎麽實現的。其實他

分享知識-快樂自己：Hibernate 中Criteria Query查詢詳解

limit all des 結合 project 實現簡單 result eager sele 1）：Hibernate 中Criteria Query查詢詳解當查詢數據時，人們往往需要設置查詢條件。在SQL或HQL語句中，查詢條件常常放在where子句中。此外，Hib

hibernate框架學習筆記11：Criteria查詢詳解

code 關系 style 獲得排序 void 技術 private lap 創建實體類對象： package domain; import java.util.HashSet; import java.util.Set; //客戶實體 public class

java利用myeclipse自帶三大框架搭建三大框架（Hibernate+Struts2+Spring）過程詳解

sun 過程 9.png att alt 分享圖片 struts apach sch 搭建過程因人而異，我的搭建過程大致是這樣的：　　1.創建一個javaweb項目；　　2.導入Spring框架，上圖：　　　　2.1：　　　　2.2：　　　　2.3：　　3.

資料庫工作筆記012---mysql觸發器trigger 例項詳解_保證資料庫完整性還是不錯的

mysql的觸發器,可以挺好的保證資料庫的資料的完整性,這個還是不錯的 JAVA技術交流QQ群：170933152 比如: 我一個表中的資料有變化,那麼與之關聯的幾個表可以通過觸發器來實現同步 --------

day78_淘淘商城專案_11_實現SSO系統的登入註冊功能 + 門戶首頁展示使用者名稱 + ajax請求跨域問題詳解_匠心筆記

淘淘商城專案_11 1、服務介面實現 1.1、檢查資料是否可用介面開發 1.1.1、功能分析 1.1.2、Dao 1.1.3、Service 1.1.4、釋出服務

【筆記】webpack4.0教程_配置詳解_圖文_新手入門_快速上手

前言這篇筆記會從node安裝開始，到搭建基礎的webpack環境為止。中間每一步的配置和遇到的術語、名詞，我都會做簡單的解釋。同時，這篇博文是一篇記錄我學習webpack的過程筆記，因為我也在學習過程，如果有記述錯誤之處，歡迎指正。【注：全程系統環境

【Hibernate步步為營】--hql查詢過濾器及相關聚合函式查詢詳解

上篇文章討論了hql查詢中的連線查詢，它的查詢語法在功能上和sql的連線查詢是相同的，內連線查詢取得的是關係之間的笛卡爾積，外連線查詢是獲取一個關係表及與另一個關係表的合集部分，具體的使用方法見上篇文章，並在最後討論了外接命名查詢的方法。該篇文章將會對hql

yii Yii 框架裡資料庫操作詳解-[增加、查詢、更新、刪除的方法

======================================= public function getMinLimit () { $sql = "..."; $result = yii::app()->db

10.5-全棧Java筆記:常見流詳解（三）

java上節我們講到「Java中常用流：緩沖流」，本節我們學習數據流和對象流~ 數據流數據流將“基本數據類型變量”作為數據源，從而允許程序以與機器無關方式從底層輸入輸出流中操作java基本數據類型。 DataInputStream和DataOutputStream提供了可以存取與機器無關的所有Java基礎類

Python爬蟲從入門到放棄（十三）之 Scrapy框架的命令行詳解

directory xpath idf 成了 spider i386 名稱 4.2 不同的這篇文章主要是對的scrapy命令行使用的一個介紹創建爬蟲項目 scrapy startproject 項目名例子如下： localhost:spider zhaofan$ sc

MySQL（九）之數據表的查詢詳解（SELECT語法）二

clas reg 3.2 查詢語句我們 lin where 過濾情況上一篇講了比較簡單的單表查詢以及MySQL的組函數，這一篇給大家分享一點比較難得知識了，關於多表查詢，子查詢，左連接，外連接等等。希望大家能都得到幫助！在開始之前因為要多表查詢，所以搭建好環境：

UML類圖詳解_關聯關系_多對多

col c++代碼一個 image 技術 pub 每一個 push_back cnblogs 在關聯關系中，很多情況下我們的多重性並不是多對一或者一對多的，而是多對多的。不過因為我們要考慮裏面的導航性，如果直接搞的話就是需要去維護兩群對象之間多對多的互指鏈接，這就

UML類圖詳解_聚合關系

聚合分享產生 .com 特殊 begin blank .html 表達結合UML關系，以看臺和基金來介紹聚合關系 aggregation，是一種特殊的關聯關系，既有關聯關系的特質，還獨有“整體 —— 部分（whole &md

Hibernate框架學習(八)——查詢-HQL語法

封裝 bsp rom 連接 inner 笛卡爾積 out 原生部分一、單表查詢 1、基礎語法 2、排序 3、條件 4、分頁 5、聚合 6、投影二、多表查詢 1、回顧原生SQL 　1>交叉連接-笛卡爾積（避免）select

Hibernate框架學習(十)——查詢優化

語句沒有 sql語句抓取 select 數量客戶使用懶加載一、類級別查詢 1、get方法：沒有任何策略，調用即立即查詢數據庫加載數據。 2、load方法：是在執行時不發送任何SQL語句，返回一個對象，使用該對象時才執行查詢；應用類級別的加載策略。

Hibernate框架筆記04HQL_QBC查詢詳解_抓取策略優化機制

1. Hibernate的查詢方式

1.1 方式一：OID查詢

1.2 方式二：對象導航查詢

1.3 方式三：HQL方式

1.4 方式四：QBC查詢

1.5 方式五：SQL查詢

2. 環境搭建

3. HQL查詢

3.1 簡單查詢

3.2 別名查詢

3.3 排序查詢

3.4 條件查詢

3.4 投影查詢

3.5 分頁查詢

3.6 分組統計查詢

3.7 HQL的多表查詢

3.7.1 SQL的多表查詢

3.7.2 HQL的多表查詢

4. QBC查詢

4.1 簡單查詢

4.2 排序查詢

4.3 分頁查詢

4.4 條件查詢

4.5 統計查詢

4.6 離線條件查詢（***）DetachedCriteria

5. SQL查詢

6. Hibernate的抓取策略

6.1 延遲加載的概述

6.1.1 什麽是延遲加載

6.1.2 延遲加載的分類

6.2 抓取策略

6.2.1 抓取策略概述

6.2.2 set上的fetch和lazy

6.2.3 many-to-one上的fetch和lazy

6.2.4 批量抓取

相關推薦