Hibernate 的效能優化的時候碰到了"抓取策略",有四種
最近在研究 Hibernate 的效能優化的時候碰到了"抓取策略", 由於以前沒有詳細的研究過,
所以到處找資料, 但是無論從一些講 Hibernate 書籍,還是他人 Blog 中都沒有找到詳細
介紹 Hibernate 文件中所說的原汁原味的抓取策略, 綜合懶載入等等特性混在了一起, 所
以在這自己在借鑑了他人的基礎上研究了下原汁原味的 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 :
public class Customer {
private long id;
private String name;
private Set<Order> orders;
// getter/setter 略
} Order :
public class Order { private long id; private String name; private Customer customer; // getter/setter略 }
Order 的對映檔案是不變的, 放在這 :
<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 語
句就可以將需要的資料全部查詢回來;
使用連線抓取的配置檔案 :
<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>我們使用如此查詢語句 :
Customer c1 = (Customer)session.get(Customer.class, 11l);
c1.getOrders().size(); Hibernate 發出的 SQL 語句為 :
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次查詢的查詢策略;
配置檔案 :
<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 語句:
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> 集合中出現 ];
配置檔案:
<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>測試的語句有變化 :
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 語句 :
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 集合的時候就是根據這兩個列表來初始化的]
配置檔案 :
<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 語句 :
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> 但是這裡沒有提供這個屬性, 可能是因為
如果設定了不好理解吧..