学海拾遗

在这里我试着翻译一下，有部分地方改变了一下，希望看到的朋友多多指正。

Hibernate和延迟装载

Hibernate ORM（关系-对象映射）针对对象的初始化分别提供了延迟和非延迟模式。非延迟装载将在读取时获得对象和其所关联的所有对象，这样当获取一个实体对象时，将会导致成千上万的select语句产生。这个问题在使用双向关联的时候将更加混乱，经常会导致在初始化请求就需要读取整个数据库。当然，某个人可以去繁重地检查每一个对象之间的关系，并且花费更多的代价去手动地移除它们。但是最终，我们可能已经失去了使用ORM工具换来的易用性。

因此，显而易见的解决方案是使用Hibernate提供的延迟加载机制。这种初始化策略仅在当那些字段访问时读取这个对象的一对多和多对多关系。这种情况对于开发者实际上是透明的，并且只创建一小部分数量的数据库请求，这样就可以很大地提升性能。这种技术的一个缺点就是当这个数据对象在使用时，延迟加载就需要Hibernate session一直打开。这就导致了一个主要问题：当尝试通过DAO（数据访问对象）模式来抽象化持久层时，为了完整地抽象持久化机制，所有的数据库逻辑，包括打开和关闭session，都将不会被应用层调用执行。最经常的情况，这些逻辑被后面的实现某些DAO接口的类来关注。但是，这个快速但不好的解决方案违反了DAO模式，并且在应用层包含了数据库连接逻辑。这样做对于小型应用可能适合，但是在大型系统中，这会产生一个重大的设计失误，阻止了应用的扩展。

在WEB层上延迟

我们是幸运的，Spring框架开发了一个开箱即用（out of box）的WEB解决方案，用来在组合Hibernate延迟加载时使用DAO模式。对于不熟悉使用Spring如何组合Hibernate的人，在这里我不会进入详细的细节，但是我鼓励你去阅读使用Spring框架进行Hibernate数据访问《Hibernate Data Access with the Spring Framework》。就一个WEB应用来说，Spring提供了OpenSessionInViewFilter和OpenSessionInViewInterceptor，一个可替换另一个使用而得到同样的功能。两者的唯一区别就是拦截器（Interceptor）在Spring容器中运行并且在WEB应用程序上下文（Application Context）中被配置，而过滤器（Filter）运行Spring之前并且是在web.xml中配置的。不管使用哪一个，它们都在绑定了session到当前线程的请求中打开Hibernate Session。一旦绑定到了线程，打开的Hibernate Session就能够透明地在DAO实现类中使用了。这个Session将一直打开，为视图（view）提供对数据库值对象的延迟访问。视图逻辑如果完成了，Hibernate Session就会在过滤器的doFilter或拦截器的postHandle方法中关闭。下面是各个部件配置的一个例子：

拦截器配置

 1 <beans>
 2   <bean id="urlMapping"     
 3      class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">    
 4        <property name="interceptors">
 5          <list>
 6               <ref bean="openSessionInViewInterceptor"/>
 7          </list>
 8        </property>
 9        <property name="mappings">
10   
11   </bean>
12   
13   <bean name="openSessionInViewInterceptor"  
14     class="org.springframework.orm.hibernate.support.OpenSessionInViewInterceptor">
15        <property name="sessionFactory"><ref bean="sessionFactory"/></property>
16   </bean>
17 </beans>

过滤器配置

 1 <web-app>                           
 2   <filter>
 3     <filter-name>hibernateFilter</filter-name>
 4     <filter-class>
 5       org.springframework.orm.hibernate.support.OpenSessionInViewFilter
 6     </filter-class>
 7    </filter>
 8         
 9   <filter-mapping>
10     <filter-name>hibernateFilter</filter-name>
11      <url-pattern>*.spring</url-pattern>
12   </filter-mapping>
13   
14 </web-app>            

实现Hibernate DAO来使用打开的Session很简单。实际上，如果你准备用Spring框架来实现你的Hibernate DAO，最可能的是你不需要改变任何一处代码。强制DAO必须通过方便的HibernateTemplate工具来访问Hibernate，将会使得数据库访问是小菜一碟。下面是一个DAO的例子。

DAO例子

 1  public class HibernateProductDAO extends HibernateDaoSupport implements ProductDAO {
 2                                 
 3        public Product getProduct(Integer productId) {
 4               return (Product)getHibernateTemplate().load(Product.class, productId);
 5        }
 6 
 7        public Integer saveProduct(Product product) {
 8               return (Integer) getHibernateTemplate().save(product);
 9        }       
10 
11        public void updateProduct(Product product) {
12               getHibernateTemplate().update(product);
13        }
14  }               

在业务层延迟

即使是在视图外面，Spring框架通过AOP拦截器HibernateInterceptor，也让延迟加载初始化变得很容易使用。这个Hibernate拦截器透明地拦截在Spring应用程序上下文（Application Context）中配置的任何业务对象的调用，在调用前打开一个Hibernate Session，同时在调用后关闭Session。让我们通过一个快速的例子来运行一下。假设我们有一个BusinessObject接口：

1 public interface BusinessObject {
2 
3     public void doSomethingThatInvolvesDaos(); 
4 }             

BusinessObjectImpl类实现了BusinessObject接口：

1 public class BusinessObjectImpl implements BusinessObject {
2 
3     public void doSomethingThatInvolvesDaos() {
4         // lots of logic that calls
5         // DAO classes Which access 
6         // data objects lazily
7     }
8 }              

通过在Spring应用程序上下文（Application Context）中的一些配置，我们能构造HibernateInterceptor来拦截BusinessObjectImpl的调用，以允许它的方法延迟访问数据对象。看一看下面的代码片断：

 1 <beans>
 2     <bean id="hibernateInterceptor" class="org.springframework.orm.hibernate.HibernateInterceptor">
 3          <property name="sessionFactory">
 4            <ref bean="sessionFactory"/>
 5          </property>
 6     </bean>
 7     <bean id="businessObjectTarget" class="com.acompany.BusinessObjectImpl">
 8        <property name="someDAO"><ref bean="someDAO"/></property>
 9     </bean>
10     <bean id="businessObject" class="org.springframework.aop.framework.ProxyFactoryBean">
11          <property name="target"><ref bean="businessObjectTarget"/></property>
12          <property name="proxyInterfaces">
13            <value>com.acompany.BusinessObject</value>
14          </property>
15          <property name="interceptorNames">
16            <list>
17               <value>hibernateInterceptor</value>
18            </list>
19          </property>
20      </bean>            
21 </beans>               

当businessObject bean被引用时，HibernateInterceptor打开一个Hibernate Session并且将调用传递给BusinessObjectImpl。当BusinessObjectImpl完成执行时，HibernateInterceptor透明地关闭这个Session。应用程序代码没有任何的持久化逻辑，然而它也能够延迟地访问数据对象。

在你的单元测试中延迟

最后一项重点是，我们需要能够从Junit中测试我们的延迟应用的能力。这很容易通过覆盖用例测试（TestCase）类中的setUp和tearDown方法做到。我更趋向于将这些代码放于一个方便的能被我所有的测试继承的抽象测试用例（TestCase）类中。

 

 1 public abstract class MyLazyTestCase extends TestCase {
 2 
 3         public void setUp() throws Exception {
 4                 super.setUp();
 5                 SessionFactory sessionFactory = (SessionFactory) getBean("sessionFactory");
 6                 Session s = sessionFactory.openSession();
 7                 TransactionSynchronizationManager.bindResource(sessionFactory, new SessionHolder(s));
 8 
 9         }
10 
11         protected Object getBean(String beanName) {
12             //Code to get objects from Spring application context
13         }
14 
15         public void tearDown() throws Exception {
16                 super.tearDown();
17                 SessionHolder holder = (SessionHolder) TransactionSynchronizationManager.
18                                getResource(sessionFactory);
19                Session s = holder.getSession(); 
20                s.flush();
21                TransactionSynchronizationManager.unbindResource(sessionFactory);
22                SessionFactoryUtils.closeSessionIfNecessary(s, sessionFactory);
23        }
24}