Hibernate 與延遲加載：
Hibernate 對象關系映射提供延遲的與非延遲的對象初始化。非延遲加載在讀取一個對象的時候會將與這個對象所有相關的其他對象一起讀取出來。這有時會導致成百的（如果不是成千的話） select 語句在讀取對象的時候執行。這個問題有時出現在使用雙向關系的時候，經常會導致整個數據庫都在初始化的階段被讀出來了。當然，你可以不厭其煩地檢查每一個對象與其他對象的關系，并把那些最昂貴的刪除，但是到最后，我們可能會因此失去了本想在 ORM 工具中獲得的便利。
一個明顯的解決方法是使用 Hibernate 提供的延遲加載機制。這種初始化策略只在一個對象調用它的一對多或多對多關系時才將關系對象讀取出來。這個過程對開發者來說是透明的，而且只進行了很少的數據庫操作請求，因此會得到比較明顯的性能提升。這項技術的一個缺陷是延遲加載技術要求一個 Hibernate 會話要在對象使用的時候一直開著。這會成為通過使用 DAO 模式將持久層抽象出來時的一個主要問題。為了將持久化機制完全地抽象出來，所有的數據庫邏輯，包括打開或關閉會話，都不能在應用層出現。最常見的是，一些實現了簡單接口的 DAO 實現類將數據庫邏輯完全封裝起來了。一種快速但是笨拙的解決方法是放棄 DAO 模式，將數據庫連接邏輯加到應用層中來。這可能對一些小的應用程序有效，但是在大的系統中，這是一個嚴重的設計缺陷，妨礙了系統的可擴展性。
在 Web 層進行延遲加載
幸運的是， Spring 框架為 Hibernate 延遲加載與 DAO 模式的整合提供了一種方便的解決方法。對那些不熟悉 Spring 與 Hibernate 集成使用的人，我不會在這里討論過多的細節，但是我建議你去了解 Hibernate 與 Spring 集成的數據訪問。以一個 Web 應用為例， Spring 提供了 OpenSessionInViewFilter 和 OpenSessionInViewInterceptor 。我們可以隨意選擇一個類來實現相同的功能。兩種方法唯一的不同就在于 interceptor 在 Spring 容器中運行并被配置在 web 應用的上下文中，而 Filter 在 Spring 之前運行并被配置在 web.xml 中。不管用哪個，他們都在請求將當前會話與當前（數據庫）線程綁定時打開 Hibernate 會話。一旦已綁定到線程，這個打開了的 Hibernate 會話可以在 DAO 實現類中透明地使用。這個會話會為延遲加載數據庫中值對象的視圖保持打開狀態。一旦這個邏輯視圖完成了， Hibernate 會話會在 Filter 的 doFilter 方法或者 Interceptor 的 postHandle 方法中被關閉。下面是每個組件的配置示例：
Interceptor的配置:
< beans >
< bean id ="urlMapping"
class ="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping" >
< property name ="interceptors" >
< list >
< ref bean ="openSessionInViewInterceptor" />
</ list >
</ property >
< property name ="mappings" >
</ bean >
< bean name ="openSessionInViewInterceptor"
class ="org.springframework.orm.hibernate.support.OpenSessionInViewInterceptor" >
< property name ="sessionFactory" >< ref bean ="sessionFactory" /></ property >
</ bean >
</ beans >
Filter的配置
< web-app >
< filter >
< filter-name > hibernateFilter </ filter-name >
< filter-class >
org.springframework.orm.hibernate.support.OpenSessionInViewFilter
</ filter-class >
</ filter >
< filter-mapping >
< filter-name > hibernateFilter </ filter-name >
< url-pattern > *. spring </ url-pattern >
</ filter-mapping >
</ web-app >
實現 Hibernate 的 Dao 接口來使用打開的會話是很容易的。事實上，如果你已經使用了 Spring 框架來實現你的 Hibernate Dao, 很可能你不需要改變任何東西。方便的 HibernateTemplate 公用組件使訪問數據庫變成小菜一碟，而 DAO 接口只有通過這個組件才可以訪問到數據庫。下面是一個示例的 DAO ：
public class HibernateProductDAO extends HibernateDaoSupport implements ProductDAO {
public Product getProduct(Integer productId) {
return (Product)getHibernateTemplate().load(Product. class , productId);
}
public Integer saveProduct(Product product) {
return (Integer) getHibernateTemplate().save(product);
}
public void updateProduct(Product product) {
getHibernateTemplate().update(product);
}
}
在業務邏輯層中使用延遲加載
即使在視圖外面， Spring 框架也通過使用 AOP 攔截器 HibernateInterceptor 來使得延遲加載變得很容易實現。這個 Hibernate 攔截器 透明地將調用配置在 Spring 應用程序上下文中的業務對象中方法的請求攔截下來，在調用方法之前打開一個 Hibernate 會話，然后在方法執行完之后將會話關閉。讓我們來看一個簡單的例子，假設我們有一個接口 BussinessObject ：
public interface BusinessObject {
public void doSomethingThatInvolvesDaos();
}
類BusinessObjectImpl實現了BusinessObject接口:
public class BusinessObjectImpl implements BusinessObject {
public void doSomethingThatInvolvesDaos() {
// lots of logic that calls
// DAO classes Which access
// data objects lazily
}
}
通過在Spring應用程序上下文中的一些配置，我們可以讓將調用BusinessObject的方法攔截下來，再令它的方法支持延遲加載。看看下面的一個程序片段：
< beans >
< bean id ="hibernateInterceptor" class ="org.springframework.orm.hibernate.HibernateInterceptor" >
< property name ="sessionFactory" >
< ref bean ="sessionFactory" />
</ property >
</ bean >
< bean id ="businessObjectTarget" class ="com.acompany.BusinessObjectImpl" >
< property name ="someDAO" >< ref bean ="someDAO" /></ property >
</ bean >
< bean id ="businessObject" class ="org.springframework.aop.framework.ProxyFactoryBean" >
< property name ="target" >< ref bean ="businessObjectTarget" /></ property >
< property name ="proxyInterfaces" >
< value > com.acompany.BusinessObject </ value >
</ property >
< property name ="interceptorNames" >
< list >
< value > hibernateInterceptor </ value >
</ list >
</ property >
</ bean >
</ beans >
當 businessObject 被調用的時候， HibernateInterceptor 打開一個 Hibernate 會話，并將調用請求傳遞給 BusinessObjectImpl 對象。當 BusinessObjectImpl 執行完成后， HibernateInterceptor 透明地關閉了會話。應用層的代碼不用了解任何持久層邏輯，還是實現了延遲加載。
在單元測試中測試延遲加載
最后，我們需要用 J-Unit 來測試我們的延遲加載程序。我們可以輕易地通過重寫 TestCase 類中的 setUp 和 tearDown 方法來實現這個要求。我比較喜歡用這個方便的抽象類作為我所有測試類的基類。
public abstract class MyLazyTestCase extends TestCase {
private SessionFactory sessionFactory;
private Session session;
public void setUp() throws Exception {
super .setUp();
SessionFactory sessionFactory = (SessionFactory) getBean( " sessionFactory " );
session = SessionFactoryUtils.getSession(sessionFactory, true );
Session s = sessionFactory.openSession();
TransactionSynchronizationManager.bindResource(sessionFactory, new SessionHolder(s));
}
protected Object getBean(String beanName) {
// Code to get objects from Spring application context
}
public void tearDown() throws Exception {
super .tearDown();
SessionHolder holder = (SessionHolder) TransactionSynchronizationManager.getResource(sessionFactory);
Session s = holder.getSession();
s.flush();
TransactionSynchronizationManager.unbindResource(sessionFactory);
SessionFactoryUtils.closeSessionIfNecessary(s, sessionFactory);
}
}