Hibernate - 檢索策略入門與詳解

阿新 • • 發佈：2018-11-01

檢索資料時的 2 個問題：

不浪費記憶體：當 Hibernate 從資料庫中載入 Customer 物件時, 如果同時載入所有關聯的 Order 物件, 而程式實際上僅僅需要訪問 Customer 物件, 那麼這些關聯的 Order 物件就白白浪費了許多記憶體。
更高的查詢效率：傳送儘可能少的 SQL 語句。

其實檢索策略就是圍繞記憶體和效率這兩個核心問題來展開的。

【1】類級別的檢索策略

類級別可選的檢索策略包括立即檢索和延遲檢索, 預設為延遲檢索。

立即檢索: 立即載入檢索方法指定的物件
延遲檢索: 延遲載入檢索方法指定的物件。在使用具體的屬性時，再進行載入

類級別的檢索策略可以通過 <class>元素的 lazy 屬性進行設定(注意出現懶載入異常)。

如果程式載入一個物件的目的是為了訪問它的屬性, 可以採取立即檢索。

如果程式載入一個持久化物件的目的是僅僅為了獲得它的引用, 可以採用延遲檢索。

不過需要注意的是無論<class>元素的 lazy 屬性是 true 還是 false, Session 的 get() 方法及 Query 的 list() 方法在類級別總是使用立即檢索策略。

若 <class>元素的 lazy 屬性為 true 或取預設值, Session 的 load() 方法不會執行查詢資料表的 SELECT 語句, 僅返回代理類物件的例項, 該代理類例項有如下特徵:

由 Hibernate 在執行時採用 CGLIB 工具動態生成
Hibernate 建立代理類例項時, 僅初始化其 OID 屬性
在應用程式第一次訪問代理類例項的非 OID 屬性時, Hibernate 會初始化代理類例項。

測試程式碼如下：

	@Test
	public void testClassLevelStrategy(){
		Customer customer = (Customer) session.load(Customer.class, 1);
		System.out.println(customer.getClass()); 
	}

預設情況下，使用懶載入方式，將會得到Customer的代理物件，如下所示：

class com.jane.strategy.Customer_$$_jvstf42_1

修改Customer.hbm.xml在class節點將屬性lazy設定為false:

<class name="Customer" table="CUSTOMERS" lazy="false" >
		//...
</class>

再次測試結果如下：

Hibernate: 
    select
        customer0_.CUSTOMER_ID as CUSTOMER1_0_0_,
        customer0_.CUSTOMER_NAME as CUSTOMER2_0_0_ 
    from
        CUSTOMERS customer0_ 
    where
        customer0_.CUSTOMER_ID=?
class com.jane.strategy.Customer

再次將lazy設定為true，測試程式碼如下：

	@Test
	public void testClassLevelStrategy(){
		Customer customer = (Customer) session.load(Customer.class, 4);
		System.out.println(customer.getClass()); 
		
		System.out.println(customer.getCustomerId()); 
		System.out.println(customer.getCustomerName()); 
	}

測試結果如下：

class com.jane.strategy.Customer_$$_jvstf42_1
4
Hibernate: 
    select
        customer0_.CUSTOMER_ID as CUSTOMER1_0_0_,
        customer0_.CUSTOMER_NAME as CUSTOMER2_0_0_ 
    from
        CUSTOMERS customer0_ 
    where
        customer0_.CUSTOMER_ID=?
AA

可以看到 load懶載入時，代理物件例項擁有屬性值OID為4，訪問其他屬性時才傳送select查詢。

【2】一對多和多對多的檢索策略

在對映檔案中, 用 <set> 元素來配置一對多關聯及多對多關聯關係。

<set>元素有 lazy 和 fetch及 batch-size 屬性：

lazy: 主要決定 orders 集合被初始化的時機。即到底是在載入 Customer 物件時就被初始化, 還是在程式訪問 orders 集合時被初始化(預設值lazy=true)。
fetch: 取值為 “select” 或 “subselect” 時, 決定初始化 orders 的查詢語句的形式; 若取值為”join”, 則決定 orders 集合被初始化的時機。若把 fetch 設定為 “join”, lazy 屬性將被忽略。
batch-size 屬性：用來為延遲檢索策略或立即檢索策略設定批量檢索的數量。批量檢索能減少 SELECT 語句的數目, 提高延遲檢索或立即檢索的執行效能。

① 測試lazy

預設set節點的lazy屬性為true，則在程式訪問orders集合時傳送select查詢orders。

測試程式碼如下：

@Test
public void testOne2ManyLevelStrategy(){
	Customer customer = (Customer) session.get(Customer.class, 4);
	System.out.println(customer.getCustomerName()); 
	
	System.out.println(customer.getOrders().size());
}

測試結果如下：

Hibernate: 
    select
        customer0_.CUSTOMER_ID as CUSTOMER1_0_0_,
        customer0_.CUSTOMER_NAME as CUSTOMER2_0_0_ 
    from
        CUSTOMERS customer0_ 
    where
        customer0_.CUSTOMER_ID=?
AA
Hibernate: 
    select
        orders0_.CUSTOMER_ID as CUSTOMER3_1_0_,
        orders0_.ORDER_ID as ORDER_ID1_1_0_,
        orders0_.ORDER_ID as ORDER_ID1_1_1_,
        orders0_.ORDER_NAME as ORDER_NA2_1_1_,
        orders0_.CUSTOMER_ID as CUSTOMER3_1_1_ 
    from
        ORDERS orders0_ 
    where
        orders0_.CUSTOMER_ID=? 
    order by
        orders0_.ORDER_NAME desc
2

若將set節點的lazy屬性設定為false，則在查詢Customer時立即查詢關聯的Order。

如下所示：

Hibernate: 
    select
        customer0_.CUSTOMER_ID as CUSTOMER1_0_0_,
        customer0_.CUSTOMER_NAME as CUSTOMER2_0_0_ 
    from
        CUSTOMERS customer0_ 
    where
        customer0_.CUSTOMER_ID=?
Hibernate: 
    select
        orders0_.CUSTOMER_ID as CUSTOMER3_1_0_,
        orders0_.ORDER_ID as ORDER_ID1_1_0_,
        orders0_.ORDER_ID as ORDER_ID1_1_1_,
        orders0_.ORDER_NAME as ORDER_NA2_1_1_,
        orders0_.CUSTOMER_ID as CUSTOMER3_1_1_ 
    from
        ORDERS orders0_ 
    where
        orders0_.CUSTOMER_ID=? 
    order by
        orders0_.ORDER_NAME desc
AA
2

② 延遲檢索和增強延遲檢索

在延遲檢索(lazy 屬性值為 true) 集合屬性時, Hibernate 在以下情況下初始化集合代理類例項：

應用程式第一次訪問集合屬性: iterator(), size(), isEmpty(), contains() 等方法；
通過 Hibernate.initialize() 靜態方法顯式初始化；

增強延遲檢索(lazy 屬性為 extra) 與 lazy=“true” 類似，主要區別是增強延遲檢索策略能進一步延遲 Customer 物件的 orders 集合代理例項的初始化時機：

當程式第一次訪問 orders 屬性的 iterator() 方法時, 會導致 orders 集合代理類例項的初始化；
當程式第一次訪問 order 屬性的 size(), contains() 和 isEmpty() 方法時, Hibernate 不會初始化 orders 集合類的例項, 僅通過特定的 select 語句查詢必要的資訊, 不會檢索所有的 Order 物件。

測試程式碼如下(lazy=“extra”)：

@Test
public void testOne2ManyLevelStrategy(){
	Customer customer = (Customer) session.get(Customer.class, 4);
	System.out.println(customer.getCustomerName()); 
	
	System.out.println(customer.getOrders().size());
	Hibernate.initialize(customer.getOrders()); 
}

測試結果如下：

Hibernate: 
    select
        customer0_.CUSTOMER_ID as CUSTOMER1_0_0_,
        customer0_.CUSTOMER_NAME as CUSTOMER2_0_0_ 
    from
        CUSTOMERS customer0_ 
    where
        customer0_.CUSTOMER_ID=?
AA
Hibernate: 
    select
        count(ORDER_ID) 
    from
        ORDERS 
    where
        CUSTOMER_ID =?
2
Hibernate: 
    select
        orders0_.CUSTOMER_ID as CUSTOMER3_1_0_,
        orders0_.ORDER_ID as ORDER_ID1_1_0_,
        orders0_.ORDER_ID as ORDER_ID1_1_1_,
        orders0_.ORDER_NAME as ORDER_NA2_1_1_,
        orders0_.CUSTOMER_ID as CUSTOMER3_1_1_ 
    from
        ORDERS orders0_ 
    where
        orders0_.CUSTOMER_ID=? 
    order by
        orders0_.ORDER_NAME desc

③ 測試batch-size

不設定set節點的batch-size屬性時，測試程式碼如下：

	@Test
	public void testSetBatchSize(){
		List<Customer> customers = session.createQuery("FROM Customer").list();
		
		System.out.println(customers.size()); 
		
		for(Customer customer: customers){
			if(customer.getOrders() != null)
				System.out.println(customer.getOrders().size());
		}
	}

測試結果如下：

Hibernate: 
    select
        customer0_.CUSTOMER_ID as CUSTOMER1_0_,
        customer0_.CUSTOMER_NAME as CUSTOMER2_0_ 
    from
        CUSTOMERS customer0_
2
Hibernate: 
    select
        orders0_.CUSTOMER_ID as CUSTOMER3_1_0_,
        orders0_.ORDER_ID as ORDER_ID1_1_0_,
        orders0_.ORDER_ID as ORDER_ID1_1_1_,
        orders0_.ORDER_NAME as ORDER_NA2_1_1_,
        orders0_.CUSTOMER_ID as CUSTOMER3_1_1_ 
    from
        ORDERS orders0_ 
    where
        orders0_.CUSTOMER_ID=? 
    order by
        orders0_.ORDER_NAME desc
3
Hibernate: 
    select
        orders0_.CUSTOMER_ID as CUSTOMER3_1_0_,
        orders0_.ORDER_ID as ORDER_ID1_1_0_,
        orders0_.ORDER_ID as ORDER_ID1_1_1_,
        orders0_.ORDER_NAME as ORDER_NA2_1_1_,
        orders0_.CUSTOMER_ID as CUSTOMER3_1_1_ 
    from
        ORDERS orders0_ 
    where
        orders0_.CUSTOMER_ID=? 
    order by
        orders0_.ORDER_NAME desc
3

即，有多少customer，就需要傳送多少條SQL來額外查詢關聯的order。

為Customer.hbm.xml的set節點設定batch-size屬性如下：

<set name="orders" table="ORDERS" 
  inverse="true" order-by="ORDER_NAME DESC" 
  batch-size="2">
  	<key column="CUSTOMER_ID"></key>
  	<one-to-many class="Order"/>
  </set>

測試結果如下：

Hibernate: 
    select
        customer0_.CUSTOMER_ID as CUSTOMER1_0_,
        customer0_.CUSTOMER_NAME as CUSTOMER2_0_ 
    from
        CUSTOMERS customer0_
2
Hibernate: 
    select
        orders0_.CUSTOMER_ID as CUSTOMER3_1_1_,
        orders0_.ORDER_ID as ORDER_ID1_1_1_,
        orders0_.ORDER_ID as ORDER_ID1_1_0_,
        orders0_.ORDER_NAME as ORDER_NA2_1_0_,
        orders0_.CUSTOMER_ID as CUSTOMER3_1_0_ 
    from
        ORDERS orders0_ 
    where
        orders0_.CUSTOMER_ID in (
            ?, ?
        ) 
    order by
        orders0_.ORDER_NAME desc
3
3

此時只額外發送了一條(batch-size>=cutomers.size)SQL語句來初始化關聯的order。

④ set節點的fetch屬性

fetch預設值為select，即以select語句的形式查詢關聯實體。若取值為”join”, 則決定 orders 集合被初始化的時機。若把 fetch 設定為 “join”, lazy 屬性將被忽略。

當 fetch 屬性為 “subselect” 時：

假定 Session 快取中有 n 個 orders 集合代理類例項沒有被初始化, Hibernate 能夠通過帶子查詢的 select 語句, 來批量初始化 n 個 orders 集合代理類例項；
batch-size 屬性將被忽略；
子查詢中的 select 語句為查詢 CUSTOMERS 表 OID 的 SELECT 語句。

將Customer.hbm.xml的set節點中fetch屬性設定為subselect，測試程式碼如下：

<set name="orders" table="ORDERS" 
	inverse="true" order-by="ORDER_NAME DESC"
	 batch-size="2"  fetch="subselect">
	<key column="CUSTOMER_ID"></key>
	<one-to-many class="Order"/>
</set>

	@Test
	public void testSetBatchSize(){
		List<Customer> customers = session.createQuery("FROM Customer").list();
		
		System.out.println(customers.size()); 
		
		for(Customer customer: customers){
			if(customer.getOrders() != null)
				System.out.println(customer.getOrders().size());
		}
		
	}

測試結果如下：

Hibernate: 
    select
        customer0_.CUSTOMER_ID as CUSTOMER1_0_,
        customer0_.CUSTOMER_NAME as CUSTOMER2_0_ 
    from
        CUSTOMERS customer0_
2
Hibernate: 
    select
        orders0_.CUSTOMER_ID as CUSTOMER3_1_1_,
        orders0_.ORDER_ID as ORDER_ID1_1_1_,
        orders0_.ORDER_ID as ORDER_ID1_1_0_,
        orders0_.ORDER_NAME as ORDER_NA2_1_0_,
        orders0_.CUSTOMER_ID as CUSTOMER3_1_0_ 
    from
        ORDERS orders0_ 
    where
        orders0_.CUSTOMER_ID in (
            select
                customer0_.CUSTOMER_ID 
            from
                CUSTOMERS customer0_
        ) //這裡用到了子查詢
    order by
        orders0_.ORDER_NAME desc
3
3

通過子查詢的方式來初始化所有的 set 集合。子查詢作為 where 子句的 in 的條件出現, 子查詢查詢所有 1 的一端的 ID，此時 lazy 有效但batch-size失效。

迫切左外連線檢索–將fetch設定為join

當 fetch 屬性為 “join” 時:

檢索 Customer 物件時, 會採用迫切左外連線(通過左外連線載入與檢索指定的物件關聯的物件)策略來檢索所有關聯的 Order 物件；
lazy 屬性將被忽略；
Query 的list() 方法會忽略對映檔案中配置的迫切左外連線檢索策略, 而依舊採用延遲載入策略。

set節點lazy和fetch屬性組合情況

lazy	fetch	檢索策略
true	select	延遲檢索策略，即預設檢索策略
false	select	立即檢索策略，使用Hibernate的二級快取時可以考慮該種方式
extra	select	加強延遲檢索策略，會盡可能延遲Customer關聯的orders集合被初始化的時機
true,false/extra	select	lazy屬性決定採用的檢索策略，即決定初始化orders集合的時機。fetch屬性為select意味著通過select語句來初始化orders集合。
true,false/extra	subselect	lazy屬性決定採用的檢索策略，即決定初始化orders集合的時機。fetch屬性為select意味著通過subselect語句來初始化orders集合。
true	join	採用迫切左外連線策略

【3】多對一和一對一關聯的檢索策略

和 <set> 一樣,<many-to-one>元素也有一個 lazy 屬性和 fetch 屬性。

lazy	fetch	檢索order物件時對關聯的Customer物件使用的檢索策略
proxy	select	延遲檢索
no-proxy	select	無代理延遲檢索
false	select	立即檢索
proxy	join	迫切左外連線策略

注意，many-to-one節點lazy屬性和fetch屬性取值與set節點的不同。

Note：

若 fetch 屬性設為 join, 那麼 lazy 屬性被忽略；
迫切左外連線檢索策略的優點在於比立即檢索策略使用的 SELECT 語句更少.；
無代理延遲檢索需要增強持久化類的位元組碼才能實現；
Query 的 list 方法會忽略對映檔案配置的迫切左外連線檢索策略, 而採用延遲檢索策略；
如果在關聯級別使用了延遲載入或立即載入檢索策略, 可以設定批量檢索的大小, 以幫助提高延遲檢索或立即檢索的執行效能.；
Hibernate 允許在應用程式中覆蓋對映檔案中設定的檢索策略。

① 測試一-lazy=false，fetch=join

配置檔案Order.hbm.xml如下：

<many-to-one 
			name="customer" class="Customer" 
			column="CUSTOMER_ID"
			lazy="false"
			fetch="join">
			</many-to-one>

測試程式碼如下：

@Test
public void testMany2OneStrategy(){
	Order order = (Order) session.get(Order.class, 7);
	System.out.println(order.getCustomer().getCustomerName()); 
}

測試結果如下：

Hibernate: 
    select
        order0_.ORDER_ID as ORDER_ID1_1_0_,
        order0_.ORDER_NAME as ORDER_NA2_1_0_,
        order0_.CUSTOMER_ID as CUSTOMER3_1_0_,
        customer1_.CUSTOMER_ID as CUSTOMER1_0_1_,
        customer1_.CUSTOMER_NAME as CUSTOMER2_0_1_ 
    from
        ORDERS order0_ 
    left outer join
        CUSTOMERS customer1_ 
            on order0_.CUSTOMER_ID=customer1_.CUSTOMER_ID 
    where
        order0_.ORDER_ID=?
AA

無論是fetch屬性設定為join或者HQL顯示使用left join fetch關鍵字，都會對應標準SQLleft outer join。

② 測試class節點的batch-size屬性

遍歷orders關聯的customers,此時需要在Customer.hbm.xml中的class節點設定batch-size屬性：

<class name="Customer" table="CUSTOMERS" lazy="true" batch-size="5">

作用為一次初始化 1 的這一端代理物件的個數。

測試程式碼如下：

	@Test
	public void testMany2OneStrategy(){
		
		List<Order> orders = session.createQuery("FROM Order o").list();
		for(Order order: orders){
			if(order.getCustomer() != null){
				System.out.println(order.getCustomer().getCustomerName()); 
			}
		}
    }

測試結果如下：

Hibernate: 
    select
        order0_.ORDER_ID as ORDER_ID1_1_,
        order0_.ORDER_NAME as ORDER_NA2_1_,
        order0_.CUSTOMER_ID as CUSTOMER3_1_ 
    from
        ORDERS order0_
Hibernate: 
    select
        customer0_.CUSTOMER_ID as CUSTOMER1_0_0_,
        customer0_.CUSTOMER_NAME as CUSTOMER2_0_0_ 
    from
        CUSTOMERS customer0_ 
    where
        customer0_.CUSTOMER_ID in (
            ?, ?
        )
AA
AA
BB
BB
AA
BB

【4】檢索策略小結

① 類級別和關聯級別可選的檢索策略及預設的檢索策略

作用域	可選的檢索策略	預設的檢索策略	執行時行為受影響的方法
類級別	立即檢索/延遲檢索	延遲檢索	僅影響session的load方法
關聯級別	立即檢索/延遲檢索/迫切左外連線檢索	延遲檢索	影響session的load和get方法，以及Query API和Criteria API。例外情況是Query API會忽略對映檔案中設定的迫切左外連線檢索策略

② 3種檢索策略的執行機制

檢索策略的型別	類級別	關聯級別
立即檢索	立即載入檢索方法指定的物件	立即載入與檢索方法指定的物件的關聯物件，可以設定批量檢索數量
延遲檢索	延遲載入檢索方法指定的物件	延遲載入與檢索方法指定的物件的關聯物件，可以設定批量檢索數量
迫切左外連線檢索	不適用	通過左外連線載入與檢索方法指定的物件的關聯物件

③ 對映檔案中用於檢索策略的幾個屬性

屬性	類級別	一對多關聯級別	多對多關聯級別
lazy	class元素lazy屬性取值為true/false，預設值true	set元素lazy屬性取值：true/false/extra，預設值true	many-to-one元素中lazy屬性取值：proxy、no-proxy和false，預設值proxy
fetch	無此屬性	set元素fetch屬性取值：select/subselect/join，預設值select	many-to-one元素中fetch屬性取值：select和join，預設值select

batch-size：設定批量檢索的數量可選值為一個正整數，合理的取值範圍為3-10。僅適用於關聯級別的立即檢索和延遲檢索。在class節點和set節點中均有次屬性。

④ 三種檢索策略優缺點

檢索策略	優點	缺點	優先考慮使用的場合
立即檢索	對應用程式完全透明，不管物件處於持久化狀態還是遊離狀態，應用程式都可以方便地從一個物件導航到與他關聯的物件	1.select語句數目會多；2.可能會載入應用程式不需要的物件，白白浪費許多記憶體空間。	1.類級別；2.應用程式需要立即訪問的物件；3.使用了二級快取
延遲檢索	由應用程式決定需要載入哪些物件，可以避免執行多餘的select語句，以及避免載入應用程式不需要訪問的物件。因此能提高檢索效能並且節省內在空間	應用程式如果希望訪問遊離狀態的代理類例項，必須保證它在持久化狀態時已經被初始化	1.一對多或者多對多關聯；2.應用程式不需要立即訪問或者根本不會訪問的物件
迫切左外連線檢索	1.對應用程式完全透明，不管物件處於持久化狀態還是遊離狀態，應用程式都可以方便地從一個物件導航到與他關聯的物件。2.使用了外連線，select語句數目少。	1.可能會載入應用程式不需要的物件，白白浪費許多記憶體空間。2.複雜的資料庫表連線也會影響檢索效能	1.多對一或多對多關聯；2.應用程式需要立即訪問的物件；3.資料庫系統具有良好的表連線效能。

Hibernate - 檢索策略入門與詳解

【1】類級別的檢索策略

【2】一對多和多對多的檢索策略

【3】多對一和一對一關聯的檢索策略

【4】檢索策略小結

Hibernate - 檢索策略入門與詳解

Java NIO入門與詳解

Hibernate學習（八）———— Hibernate檢索策略(類級別，關聯級別，批量檢索)詳解

Hibernate檢索策略與檢索方式

Caffe入門例項與詳解人工智慧框架

Vagrant使用與入門技巧詳解

Hibernate入門——基礎詳解

Android入門——Fragment詳解之基本概念與用法（一）

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

Scrapy 爬蟲框架入門案例詳解

Nginx簡單使用與詳解

用戶和組管理命令介紹與詳解

Hibernate檢索策略

wav文件格式分析與詳解

linux下iptables命令的應用與詳解

[轉]springmvc+mybatis需要的jar包與詳解

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

無鎖的同步策略——CAS操作詳解

Hibernate框架環境搭建（詳解）

Hibernate映射文件詳解(News***.hbm.xml)一

Hibernate - 檢索策略入門與詳解

【1】類級別的檢索策略

【2】一對多和多對多的檢索策略

【3】多對一和一對一關聯的檢索策略

【4】檢索策略小結

相關推薦