Hibernate性能：fetching策略

来源：互联网发布：不是方阵有逆矩阵吗编辑：程序博客网时间：2024/05/16 09:29

Hibernate有一些fetching策略，来优化Hibernate所生成的select语句，以尽可能地提高效率。在映射关系中声明fetching策略，定义Hibernate怎样获取其相关的集合和实体。
有四种fetching策略：

fetch-“join”：禁用延迟加载，总是立即加载所有的集合和实体。
fetch-“select”(默认)：延迟加载所有的集合和实体。
batch-size=”N”：获取上限为“N”个的集合或实体，没有记录。
fetch-“subselect”：将其集合组织到一个子查询语句中。

下面是一个“一对多关系”示例，用来演示fetching策略。一个Stock属于许多SockDailyRecord。
在XML映射文件中声明fetch策略：

<hibernate-mapping>
　　<class name="com.xuejava.common.Stock" table="stock">
　　　　<set name="stockDailyRecords" cascade="all" inverse="true"
　　　　　　　　table="stock_daily_record" batch-size="10" fetch="select">
　　　　　　<key>
　　　　　　　　<column name="STOCK_ID" not-null="true" />
　　　　　　</key>
　　　　　　<one-to-many class="com.xuejava.common.StockDailyRecord" />
　　　　</set>
　　</class>
</hibernate-mapping>

复制代码

以标注的形式声明fetch策略：

@Entity
@Table(name = "stock", catalog = "xuejava")
public class Stock implements Serializable{
...
　　@OneToMany(fetch = FetchType.LAZY, mappedBy = "stock")
　　@Cascade(CascadeType.ALL)
　　@Fetch(FetchMode.SELECT)
　　@BatchSize(size = 10)
　　public Set<StockDailyRecord> getStockDailyRecords() {
　　　　return this.stockDailyRecords;
　　}
...
}

复制代码

下面我们来探讨fetch策略如何影响到Hibernate生成的SQL语句。
1、fetch=”select” 或 @Fetch(FetchMode.SELECT)
这是默认的fetch策略。这可以延迟加载所有相关的集合。请看示例代码：

//call select from stock
　　Stock stock = (Stock)session.get(Stock.class, 114);
　　Set sets = stock.getStockDailyRecords();
　　//call select from stock_daily_record
　　for ( Iterator iter = sets.iterator();iter.hasNext(); ) {
　　　　StockDailyRecord sdr = (StockDailyRecord) iter.next();
　　　　System.out.println(sdr.getDailyRecordId());
　　　　System.out.println(sdr.getDate());
　　}

复制代码

输出如下：

Hibernate:
　　select ...from xuejava.stock
　　where stock0_.STOCK_ID=?
Hibernate:
　　select ...from xuejava.stock_daily_record
　　where stockdaily0_.STOCK_ID=?

复制代码

Hibernate生成两个select语句：

获取Stock记录的select语句-session.get(Stock.class,114)
获取其相关集合的select语句-sets.iterator()

2、fetch=”join” 或 @Fetch(FetchMode.JOIN)
“join”fetch策略将禁用延迟加载所有相关的集合。请看示例代码：

//call select from stock and stock_daily_record
　　Stock stock = (Stock)session.get(Stock.class, 114);
　　Set sets = stock.getStockDailyRecords();
　　//no extra select
　　for ( Iterator iter = sets.iterator();iter.hasNext(); ) {
　　　　StockDailyRecord sdr = (StockDailyRecord) iter.next();
　　　　System.out.println(sdr.getDailyRecordId());
　　　　System.out.println(sdr.getDate());
　　}

复制代码

输出如下：

Hibernate:
　　select ...
　　from
　　　　xuejava.stock stock0_
　　left outer join
　　　　xuejava.stock_daily_record stockdaily1_
　　　　on stock0_.STOCK_ID=stockdaily1_.STOCK_ID
　　where
　　　　stock0_.STOCK_ID=?

复制代码

Hibernate只生成一个select语句，当Stock被初始化时，它获取所有其相关的集合。
3、batch-size=”10” 或 @BatchSize(size=10) 这个“batch-size”fetching策略总是被许多Hibernate开发者感到难以理解。请看示例代码：

Stock stock = (Stock)session.get(Stock.class, 114);
　　Set sets = stock.getStockDailyRecords();
　　for ( Iterator iter = sets.iterator();iter.hasNext(); ) {
　　　　StockDailyRecord sdr = (StockDailyRecord) iter.next();
　　　　System.out.println(sdr.getDailyRecordId());
　　　　System.out.println(sdr.getDate());
　　}

复制代码

　输出如下：

Hibernate:
　　select ...from xuejava.stock
　　where stock0_.STOCK_ID=?
Hibernate:
　　select ...from xuejava.stock_daily_record
　　where stockdaily0_.STOCK_ID=?

复制代码

batch-size什么也没做。请看下面的解释：

batch-size fetching策略并不是定义集合中有多少记录被预加载。相反，它其实是定义有多少集合应该被加载。
4、另一个示例
接下来看一看另一个例子。假设想要打印输出所有的股票记录以及其相关的股票日记录（集合），one  by one。

List<Stock> list = session.createQuery("from Stock").list();
　　for(Stock stock : list){
　　　　Set sets = stock.getStockDailyRecords();
　　　　for ( Iterator iter = sets.iterator();iter.hasNext(); ) {
　　　　　　StockDailyRecord sdr = (StockDailyRecord) iter.next();
　　　　　　System.out.println(sdr.getDailyRecordId());
　　　　　　System.out.println(sdr.getDate());
　　　　}
　　}

复制代码

1、没有batch-size fetching策略时，输出：

Hibernate:
　　select ...
　　from xuejava.stock stock0_
Hibernate:
　　select ...
　　from xuejava.stock_daily_record stockdaily0_
　　where stockdaily0_.STOCK_ID=?
Hibernate:
　　select ...
　　from xuejava.stock_daily_record stockdaily0_
　　where stockdaily0_.STOCK_ID=?
继续重复select语句....这取决于数据表中有多少条stock记录。

复制代码

如果在数据库中有20条股票记录，Hibernate默认的fetching策略将生成20+1个select语句，这将对数据库造成一定的冲击。

获取所有Stock记录的select语句
获取其相关集合的select语句
获取其相关集合的select语句
获取其相关集合的select语句
……

生成的查询非常没有效率，并引起一系列性能问题。
2、启用batch-size=”10” fetching策略时，输出：

Hibernate:
　　select ...
　　from xuejava.stock stock0_
Hibernate:
　　select ...
　　from xuejava.stock_daily_record stockdaily0_
　　where
　　　　stockdaily0_.STOCK_ID in (
　　　　　　?, ?, ?, ?, ?, ?, ?, ?, ?, ?
　　　　)

复制代码

现在，Hibernate将预提取集合，使用select in语句。如果在数据库中有20条股票记录，Hibernate将生成3个select语句。

获取所有Stock记录的select语句
预提取其相关集合的select in语句（一次10个集合）
预提取其相关集合的select in语句（接下来一次10个集合）

启用batch-size策略，将查询语句从21个select语句简化至3个select语句。

5、 fetch=”subselect” 或 @Fetch(FetchMode.SUBSELECT)
Fetching策略能够将其所有相关集合放在一个子select语句中。请看下面的查询：

List<Stock> list = session.createQuery("from Stock").list();
　　for(Stock stock : list){
　　　　Set sets = stock.getStockDailyRecords();
　　　　for ( Iterator iter = sets.iterator();iter.hasNext(); ) {
　　　　　　StockDailyRecord sdr = (StockDailyRecord) iter.next();
　　　　　　System.out.println(sdr.getDailyRecordId());
　　　　　　System.out.println(sdr.getDate());
　　　　}
　　}

复制代码

启用“subselect”，它将生成两个select语句：

获取所有Stock记录的select语句；
在一个子查询语句中获取其相关集合的语句。

6、结论
Fetching策略非常具有弹性，是一个优化Hibernate查询的非常重要的技巧。不过如果用在错误的地方，那将会是一个灾难。