Spring 与 Hibernate 的延迟加载和 Dao 模式

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 ：

Example 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 interceptor HibernateInterceptor 来使得延迟加载变得很容易实现。这个 Hibernate interceptor 透明地将调用配置在 Spring 应用程序上下文中的业务对象中方法的请求拦截下来，在调用方法之前打开一个 Hibernate 会话，然后在方法执行完之后将会话关闭。让我们来看一个简单的例子，假设我们有一个接口 BussinessObject ：

public interface BusinessObject {
public void doSomethingThatInvolvesDaos();
}
The class BusinessObjectImpl implements 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);
}
}

由于要求在项目中使用泛型的DAO，所以上网Google了一下，找到了IBM的一篇文章。文章讲得不错，但是有些地方不清楚，如果完全按照那篇文章可能还会遇到一些困难。所以写了这篇文章，解释如何在项目中加入泛型的DAO实现。

首先是总的类关系的UML图:

然后是在配置文件中的关系图：

其中，IStaffDao是我们自己定义的接口，这个接口类似：

public interface IStaffDAO extends GenericDao < Staff,Integer > {

public ListlistAll();

public StaffgetByLogonAndId(Stringlogon,Integerid);

// more

}

GenericDao<T , PK extends Serilizable> 是泛型的 Dao 接口：

/***/ /**
*2006-11-22
*范型DAO接口
* @author ZouAng
*Contact<ahref="mailto:richardeee@gmail.com">ZouAng</a>
*/
public interface GenericDao < T,PK extends Serializable > {

/***/ /**
*保存一个对象到数据库
* @param newInstance需要保存的对象
* @return
*/
PKcreate(TnewInstance);
/***/ /**
*从数据库读取一个对象
* @param id主键
* @return
*/
Tread(PKid);

/***/ /**
*更新一个对象
* @param transientObject被更新的对象
*/
void update(TtransientObject);

/***/ /**
*删除一个对象
* @param transientObject被删除的对象
*/
void delete(TtransientObject);
}

GenericDaoHibernateImpl 是 GenericDao 接口的泛型实现 :

/***/ /**
*2006-11-22
*范型DAO实现
* @author ZouAng
*Contact<ahref="mailto:richardeee@gmail.com">ZouAng</a>
*/
public class GenericDaoHibernateImpl < T,PK extends Serializable >
extends HibernateDaoSupport
implements GenericDao < T,PK > ,FinderExecutor {

private Class < T > type;
private FinderNamingStrategynamingStrategy = new SimpleFinderNamingStrategy(); // Default.Canoverrideinconfig
private FinderArgumentTypeFactoryargumentTypeFactory = new SimpleFinderArgumentTypeFactory(); // Default.Canoverrideinconfig

public GenericDaoHibernateImpl(Class < T > type) {
this .type = type;
}

/**/ /* (non-Javadoc)
*@seecom.gdnfha.atcs.common.service.dao.GenericDao#create(java.lang.Object)
*/
public PKcreate(TnewInstance) {
return (PK)getHibernateTemplate().save(newInstance);
}

/**/ /* (non-Javadoc)
*@seecom.gdnfha.atcs.common.service.dao.GenericDao#delete(java.lang.Object)
*/
public void delete(TtransientObject) {
getHibernateTemplate().delete(transientObject);
}

/**/ /* (non-Javadoc)
*@seecom.gdnfha.atcs.common.service.dao.GenericDao#read(java.io.Serializable)
*/
public Tread(PKid) {
return (T)getHibernateTemplate().get(type,id);
}

/**/ /* (non-Javadoc)
*@seecom.gdnfha.atcs.common.service.dao.GenericDao#update(java.lang.Object)
*/
public void update(TtransientObject) {
getHibernateTemplate().update(transientObject);
}

public List < T > executeFinder(Methodmethod, final Object[]queryArgs)
{
final QuerynamedQuery = prepareQuery(method,queryArgs);
return (List < T > )namedQuery.list();
}

public Iterator < T > iterateFinder(Methodmethod, final Object[]queryArgs)
{
final QuerynamedQuery = prepareQuery(method,queryArgs);
return (Iterator < T > )namedQuery.iterate();
}

private QueryprepareQuery(Methodmethod,Object[]queryArgs)
{
final StringqueryName = getNamingStrategy().queryNameFromMethod(type,method);
final QuerynamedQuery = getSession().getNamedQuery(queryName);
String[]namedParameters = namedQuery.getNamedParameters();
if (namedParameters.length == 0 )
{
setPositionalParams(queryArgs,namedQuery);
} else {
setNamedParams(namedParameters,queryArgs,namedQuery);
}
return namedQuery;
}

private void setPositionalParams(Object[]queryArgs,QuerynamedQuery)
{
// Setparameter.UsecustomHibernateTypeifnecessary
if (queryArgs != null )
{
for ( int i = 0 ;i < queryArgs.length;i ++ )
{
Objectarg = queryArgs[i];
TypeargType = getArgumentTypeFactory().getArgumentType(arg);
if (argType != null )
{
namedQuery.setParameter(i,arg,argType);
}
else
{
namedQuery.setParameter(i,arg);
}
}
}
}

private void setNamedParams(String[]namedParameters,Object[]queryArgs,QuerynamedQuery)
{
// Setparameter.UsecustomHibernateTypeifnecessary
if (queryArgs != null )
{
for ( int i = 0 ;i < queryArgs.length;i ++ )
{
Objectarg = queryArgs[i];
TypeargType = getArgumentTypeFactory().getArgumentType(arg);
if (argType != null )
{
namedQuery.setParameter(namedParameters[i],arg,argType);
}
else
{
if (arg instanceof Collection) {
namedQuery.setParameterList(namedParameters[i],(Collection)arg);
}
else