Hibernate 原汁原味的四種抓取策略(轉載)

連線抓取（Join fetching） - Hibernate通過 在SELECT語句使用OUTER JOIN
（外連線）來 獲得物件的關聯例項或者關聯集合.
--------------------------------------------------------------------------------

查詢抓取（Select fetching） - 另外傳送一條 SELECT 語句抓取當前物件的關聯實
體或集合。除非你顯式的指定lazy="false"禁止 延遲抓取（lazy fetching），否
則只有當你真正訪問關聯關係的時候，才會執行第二條select語句.
--------------------------------------------------------------------------------

子查詢抓取（Subselect fetching） - 另外傳送一條SELECT 語句抓取在前面查詢到
（或者抓取到）的所有實體物件的關聯集合。除非你顯式的指定lazy="false" 禁止延遲
抓取（lazy fetching），否則只有當你真正訪問關聯關係的時候，才會執行第二條
select語句
--------------------------------------------------------------------------------

批量抓取（Batch fetching） - 對查詢抓取的優化方案， 通過指定一個主鍵或外來鍵
列表，Hibernate使用單條SELECT語句獲取一批物件例項或集合
這是文件中的四種抓取策略, 我用 Customer 與 Order 的一個雙向一對多例子來使用四種

抓取策略看看他們的不同之處;

Customer :


view plaincopy to clipboardprint?

public class Customer {
private long id;
private String name;
private Set<Order> orders;
// getter/setter 略
}


Order :


view plaincopy to clipboardprint?

public class Order {
private long id;
private String name;
private Customer customer;
// getter/setter略
}


Order 的對映檔案是不變的, 放在這 :


view plaincopy to clipboardprint?

<hibernate-mapping package="com.purking.strategys.endUpOne">
<class name="Order" table="Order_Table">
<id name="id">
<generator class="native" />
</id>
<property name="name" length="20" column="Order_Name" />
<many-to-one name="customer"
class="Customer"
lazy="proxy"
fetch="select"
column="Cus_ID"
cascade="save-update" />
</class>
</hibernate-mapping>


連線抓取（Join fetching）

連線抓取, 使用連線抓取可以將原本需要查詢兩次(或多次)表的多次查詢 整合到只需

要一次查詢即可完成, 舉個例子, 我們在初始化一個含有一對多關係的 Customer 與

Order 的時候, 會先查詢 Customer 表,找到需要的 Customer , 然後再根據

Customer.id 到 Order 表中查詢將Order 集合初始化, 那麼在此完成初始化則需要

傳送至少兩條 SQL 語句, 而如果使用 join 查詢的話, 其會根據需要查詢的

Customer.id, 將 Customer 表與 Order 表連線起來進行查詢,僅僅一條 SQL 語

句就可以將需要的資料全部查詢回來;

使用連線抓取的配置檔案 :

view plaincopy to clipboardprint?

<hibernate-mapping package="com.purking.strategys.endUpOne">
<class name="Customer" table="Customer_Table" lazy="true">
<id name="id">
<generator class="native" />
</id>
<property name="name" length="20" column="Cus_Name" />
<set name="orders"
inverse="true"
fetch="join" //---- Here
<!-- 這裡關閉懶載入是為了試驗明顯 -->
lazy="false">
<key column="Cus_ID" />
<one-to-many class="Order" />
</set>
</class>
</hibernate-mapping>
我們使用如此查詢語句 :

view plaincopy to clipboardprint?

Customer c1 = (Customer)session.get(Customer.class, 11l);
c1.getOrders().size();
Hibernate 發出的 SQL 語句為 :

view plaincopy to clipboardprint?

select
customer0_.id as id0_1_,
customer0_.Cus_Name as Cus2_0_1_,
orders1_.Cus_ID as Cus3_3_,
orders1_.id as id3_,
orders1_.id as id1_0_,
orders1_.Order_Name as Order2_1_0_,
orders1_.Cus_ID as Cus3_1_0_
from
Customer_Table customer0_
left outer join
Order_Table orders1_
on customer0_.id=orders1_.Cus_ID
where
customer0_.id=?
在此, Hibernate 使用了 left outer join 連線兩個表以一條 SQL 語句將 Order 集合

給初始化了;


查詢抓取（Select fetching）
查詢抓取, 這種策略是在集合抓取的時候的預設策略, 即如果集合需要初始化, 那麼

會重新發出一條 SQL 語句進行查詢; 這是集合預設的抓取策略, 也就是我們常會出現

N+1次查詢的查詢策略;

配置檔案 :


view plaincopy to clipboardprint?

<hibernate-mapping package="com.purking.strategys.endUpOne">
<class name="Customer" table="Customer_Table" lazy="true">
<id name="id">
<generator class="native" />
</id>
<property name="name" length="20" column="Cus_Name" />
<set name="orders"
inverse="true"
fetch="select">
<key column="Cus_ID" />
<one-to-many class="Order" />
</set>
</class>
</hibernate-mapping>
查詢語句不變, 看看 Hibernate 發出的 SQL 語句:


view plaincopy to clipboardprint?

Hibernate:
select
customer0_.id as id0_0_,
customer0_.Cus_Name as Cus2_0_0_
from
Customer_Table customer0_
where
customer0_.id=?
Hibernate:
select
orders0_.Cus_ID as Cus3_1_,
orders0_.id as id1_,
orders0_.id as id1_0_,
orders0_.Order_Name as Order2_1_0_,
orders0_.Cus_ID as Cus3_1_0_
from
Order_Table orders0_
where
orders0_.Cus_ID=?


這就是, 重新發出一條 SQL 語句, 初始化了 Orders 集合;

子查詢抓取（Subselect fetching）

子查詢抓取, 另外傳送一條SELECT 語句抓取在前面查詢到（或者抓取到）的所有實

體物件的關聯集合. 這個理解起來有點糊塗, 舉個例子 : 如果你使用 Query 查詢出了

4 個 Customer 實體, 由於開啟了懶載入,那麼他們的 Orders 都沒有被初始化, 那麼我

現在手動初始化一個Customer 的 Orders ,此時由於我選的是 Subselect fetching

策略,所以 Hibernate 會將前面查詢到的實體物件(4 個 Customer)的關聯集合(在

<set name="orders" fetch="subselect" /> )使用一條 Select 語句一次性抓取

回來, 這樣減少了與資料庫的互動次數, 一次將每個物件的集合都給初始化了;

[他是如何這麼智慧的呢? 原來,他是將上一次查詢的 SQL 語句作為這一次查詢的 SQL

語句的 where 子查詢, 所以上次查詢到幾個物件,那麼這次就初始化幾個物件的集

合----- 正因為如此, 所以 subselect 只在 <set> 集合中出現 ];

配置檔案:

view plaincopy to clipboardprint?

<hibernate-mapping package="com.purking.strategys.endUpOne">
<class name="Customer" table="Customer_Table" lazy="true">
<id name="id">
<generator class="native" />
</id>
<property name="name" length="20" column="Cus_Name" />
<set name="orders"
inverse="true"
fetch="subselect"
lazy="true">
<key column="Cus_ID" />
<one-to-many class="Order" />
</set>
</class>
</hibernate-mapping>
測試的語句有變化 :

view plaincopy to clipboardprint?

List results = session
.createQuery("From Customer c where c.id in (11,14,17,20)")
.list();
// 這裡的四個 id 是我資料庫中已經準備好的資料
Customer c0 = (Customer)results.get(0);
c0.getOrders().size();
這個時候再來看看 Hibernate 發出了什麼樣的 SQL 語句 :

view plaincopy to clipboardprint?

Hibernate:
select
customer0_.id as id0_,
customer0_.Cus_Name as Cus2_0_
from
Customer_Table customer0_
where
customer0_.id in (
11 , 14 , 17 , 20
)
Hibernate:
select
orders0_.Cus_ID as Cus3_1_,
orders0_.id as id1_,
orders0_.id as id1_0_,
orders0_.Order_Name as Order2_1_0_,
orders0_.Cus_ID as Cus3_1_0_
from
Order_Table orders0_
where
orders0_.Cus_ID in (
select
customer0_.id
from
Customer_Table customer0_
where
customer0_.id in (
11 , 14 , 17 , 20
)
)
是不是發出的 SQL 語句形式與這個抓取策略的名字一樣? Hibernate 的命名很清晰的;

批量抓取（Batch fetching）

批量抓取:"對查詢抓取的優化方案,通過指定一個主鍵或外來鍵列表，Hibernate使用

單條SELECT語句獲取一批物件例項或集合", 也就是說其本質與 select fetching 是

一樣的,只不過將一次一條的 select 策略改為一次 N 條的批量 select 查詢; 舉個例

子 : 還是借用 Subselect fetching 的例子,我查詢出了 4 個 Customer 實體,

Orders 開啟了懶載入, 所以我現在來手動初始化一個 Customer 的 orders 屬性,

這種策略本質上就是 select fetching,所以如此設定 :

<set name="orders" fetch="select" batch-size="3" /> 那麼此時我初始化

一個 Customer 的 orders 集合的時候, Hibernate 還是發出了一條 SQL 語句,

不過這條 SQL 與是通過指定了 Order 表中的 Customer_ID 外來鍵列表(2個), 這個

時候 Hibernate 會以一條 SQL 語句初始化 batch-size 指定的數量的 orders 集合;

[他是如何做到的呢? 通過一個主鍵或外來鍵 列表 做到的, 他將 4 個 Customer 根據

batch-size 分成了兩組, 一組有三個 Customer id 值的列表,第二組只有一個,

在初始化 orders 集合的時候就是根據這兩個列表來初始化的]

配置檔案 :

view plaincopy to clipboardprint?

<hibernate-mapping package="com.purking.strategys.endUpOne">
<class name="Customer" table="Customer_Table" lazy="true">
<id name="id">
<generator class="native" />
</id>
<property name="name" length="20" column="Cus_Name" />
<set name="orders"
inverse="true"
fetch="select"
lazy="true"
batch-size="3">
<key column="Cus_ID" />
<one-to-many class="Order" />
</set>
</class>
</hibernate-mapping>
在此,我關閉了集合預設的懶載入, 更有利於試驗結果測試程式碼不變,

再來看看 Hibernate 發出的 SQL 語句 :

view plaincopy to clipboardprint?

Hibernate:
select
customer0_.id as id0_,
customer0_.Cus_Name as Cus2_0_
from
Customer_Table customer0_
where
customer0_.id in (
11 , 14 , 17 , 20
)
Hibernate:
select
orders0_.Cus_ID as Cus3_1_,
orders0_.id as id1_,
orders0_.id as id1_0_,
orders0_.Order_Name as Order2_1_0_,
orders0_.Cus_ID as Cus3_1_0_
from
Order_Table orders0_
where
orders0_.Cus_ID in (
?, ?, ?
)
Hibernate:
select
orders0_.Cus_ID as Cus3_1_,
orders0_.id as id1_,
orders0_.id as id1_0_,
orders0_.Order_Name as Order2_1_0_,
orders0_.Cus_ID as Cus3_1_0_
from
Order_Table orders0_
where
orders0_.Cus_ID=?
原本需要四次 Select 的查詢, 由於 Batch-size=3 只用了兩次

就完成了;


--------------------------------------------------------------------------------

總結:
好了, 這裡的四種抓取策略說明完了, 來全域性看一下, 通過例子可以看出, 這四種抓取

策略並不是所有的情況都合適的, 例如, 如果我需要初始化的是一個單獨的實體, 那

麼 subselect 對其就沒有效果,因為其本身就只需要查詢一個物件, 所以 :

Join fetching , Select fetching 與 Batch-size 可以為單個實體的抓取進
行效能優化;
Join fetching , Select fetching ,Subselect fetching , Batch fetching
都可以為集合的抓取進行效能優化;
注: 這裡對於單個實體可以使用 Batch-size 可能會有點疑惑, 其實在 <class > 上是

具有 Batch-size 抓取策略的; 試想, 使用一個如果是一對一關係呢? 例如 Customer

與 IdCard, 利用 HQL 查詢出 4 個 Customer , 我們想一次性初始化 4 個 Customer

的 IdCard 怎麼辦, 設定 <class name="IdCard" batch-size="4" > , 可能我們

想設定的地方是 <one-to-one batch-size> 但是這裡沒有提供這個屬性, 可能是因為

如果設定了不好理解吧..