Struts Spring Hibernate 事务管理的例子

Struts Spring Hibernate 事务管理的例子。
关键词： Struts Spring Hibernate 事务管理

这两天比较清闲，试着配置了一下Struts Spring Hibernate 。由Spring来接管Struts的Action和Hibernate的事务管理。现做一下笔记。

1. Struts配置文件struts-config.xml

首先加上Spring的Context Loader插件

<plug-in
className="org.springframework.web.struts.ContextLoaderPlugIn">
<set-property property="contextConfigLocation"
value="/WEB-INF/beans.xml" />
</plug-in>

其中beans.xml是Spring的配置文件。

添加一个Action

<action path="/sample"
type="org.springframework.web.struts.DelegatingActionProxy">
</action>
注意type变成了Spring的代理类，当然这儿可以加入一些Forward

2. Spring的配置文件 beans.xml

添加action的对应bean，由于struts已经把这个bean委托给spring来管了，所以当然应该在spring中配置对应的class

<bean name="/sample" class="com.windrift.action.SampleAction">
<property name="sampleManager" ref="sampleManager" />
</bean>

对 sampleManager的配置，实际上对应的是 com.windrift.manager.SampleManager，由于需要对这个 manager配置事务，所以给他指定了一个模板parent="baseService"，注意这个parent并不是指继承关系，稍后我们会对这个模板指定事务的策略。

<bean id="sampleManager" parent="baseService">
<property name="target">
<bean class="com.windrift.manager.SampleManager" autowire="byName">
<property name="sampleDAO" ref="sampleDAO" />
</bean>
</property>
</bean>

配置sampleDAO，这里的模板baseDao我们不关心，这儿不详述。

<bean id="sampleDAO" parent="baseDao">
<property name="target">
<bean class="com.windrift.dao.imp.SampleDAOImp" autowire="byName"></bean>
</property>
</bean>

下面配置Hibernate的数据源，这儿用的是MySQL数据库，由于数据库的处理等已经交由Spring处理，因此不再需要Hibernate的配置文件。除了表和PO的映射文件外（如Sample.hbm.xml）

<bean id="dataSource"
class="org.apache.commons.dbcp.BasicDataSource"
destroy-method="close">
<property name="driverClassName">
<value>com.mysql.jdbc.Driver</value>
</property>
<property name="url">
<value>jdbc:mysql://localhost/shop</value>
</property>
<property name="username">
<value>root</value>
</property>
<property name="password">
<value>root</value>
</property>
</bean>

sessionFactory依据数据源创建Session链接

<bean id="sessionFactory"
class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
<property name="dataSource">
<ref local="dataSource" />
</property>
<property name="mappingResources">
<list>
<value>SystemInfo.hbm.xml</value>
<value>Ad.hbm.xml</value>
<value>Good.hbm.xml</value>
<value>Logo.hbm.xml</value>
<value>Member.hbm.xml</value>
<value>News.hbm.xml</value>
<value>NSort.hbm.xml</value>
<value>Pub.hbm.xml</value>
<value>Sort.hbm.xml</value>
<value>Sub.hbm.xml</value>
<value>Basket.hbm.xml</value>
<value>Sample.hbm.xml</value>
</list>
</property>
<property name="hibernateProperties">
<props>
<prop key="hibernate.connection.useUnicode">true</prop>
<prop key="hibernate.connection.characterEncoding">
UTF-8
</prop>
<prop key="hibernate.cglib.use_reflection_optimizer">
false
</prop>
<prop key="hibernate.connection.pool.size">2</prop>
<prop key="hibernate.show_sql">true</prop>
<prop key="jdbc.fetch_size">50</prop>
<prop key="jdbc.batch_size">25</prop>
<prop key="jdbc.use_scrollable_resultset">false</prop>
<prop key="hibernate.hbm2ddl.auto">update</prop>
<prop key="hibernate.dialect">
org.hibernate.dialect.MySQLDialect
</prop>
</props>
</property>
</bean>

事务管理类，通过SessionFactory来获取session
<bean id="transactionManager"
class="org.springframework.orm.hibernate3.HibernateTransactionManager">
<property name="sessionFactory">
<ref local="sessionFactory" />
</property>
</bean>

配置一个切入器，它依据配置的一些事务策略，会调用 transactionManager来进行事务管理。

这个例子中需要进行事务管理的类（所有parent是baseService的类）的所有以Get开头的方法会在一个只读事务环境中运行。其余方法需要进行事务传递，并且一旦这个方法抛出BaseException异常则回滚事务。（如果希望强制commit事务，则把BaseException前面的-改成+）

<bean id="transactionInterceptor"
class="org.springframework.transaction.interceptor.TransactionInterceptor">
<property name="transactionManager">
<ref bean="transactionManager" />
</property>
<property name="transactionAttributes">
<props>
<prop key="get*">PROPAGATION_REQUIRED,readOnly</prop>
<prop key="*">
PROPAGATION_REQUIRED,-BaseException
</prop>
</props>
</property>
</bean>

这个就是前面提到的模板，它说明所有应用此模板的类（parent=baseService的 类）都会被 置于transactionInterceptor中配置的事务环境中。

<bean id="baseService" abstract="true"
class="org.springframework.aop.framework.ProxyFactoryBean">
<property name="interceptorNames">
<list>
<value>transactionInterceptor</value>
</list>
</property>
</bean>

3. SampleAction.java

只是简单的调用了一下manager的方法

package com.windrift.action;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.apache.struts.action.Action;
import org.apache.struts.action.ActionForm;
import org.apache.struts.action.ActionForward;
import org.apache.struts.action.ActionMapping;

import com.windrift.manager.SampleManager;

public class SampleAction extends Action{
private SampleManager sampleManager;
public ActionForward execute(ActionMapping aMapping, ActionForm aForm,
HttpServletRequest aRequest, HttpServletResponse aResponse)
throws Exception {
sampleManager.doSomething();
return null;

}
public void setSampleManager(SampleManager sampleManager) {
this.sampleManager = sampleManager;
}
}

4. SampleManager.java

方法doSomething中我们往数据库里加了两个记录Sample1和Sample2

但是在最后我们强制抛出了一个BaseException，根据前面设置的事务环境和策略，这两条插入的记录都会被回滚。

package com.windrift.manager;

import com.windrift.dao.SampleDAO;
import com.windrift.dao.persist.Sample;
import com.windrift.exception.BaseException;

public class SampleManager {
private SampleDAO sampleDAO;

public void setSampleDAO(SampleDAO sampleDAO) {
this.sampleDAO = sampleDAO;
}

public void doSomething() throws BaseException{
Sample sample1 = new Sample();
sample1.setSample("sample1");
sampleDAO.addSample(sample1);
Sample sample2 = new Sample();
sample2.setSample("sample2");
sampleDAO.addSample(sample2);
throw new BaseException();
}

}

5. SampleDAOImp.java

简单的调用了父类的方法。

package com.windrift.dao.imp;

import com.windrift.dao.SampleDAO;
import com.windrift.dao.persist.Sample;

public class SampleDAOImp extends BaseDAOImp implements SampleDAO {

public void addSample(Sample sample) {
this.save(sample);
}
}

补充一个需要使用回调函数的方法。由于我们的session的管理（包括事务）都交给spring来处理了。所以通常情况下我们是无法访问session的。但是有时候我们又需要使用session，这时候就需要使用回调函数，以取得session。

public List getAllSortASC() {
return getHibernateTemplate().executeFind(new HibernateCallback() {
public Object doInHibernate(Session session)
throws HibernateException, SQLException {
Query query = session.createQuery("from Sort order by sort_id asc");
List sorts = query.list();
return sorts;
}});}

public Sort getSortById(final int id) {
List list = getHibernateTemplate().executeFind(new HibernateCallback() {
public Object doInHibernate(Session session)
throws HibernateException, SQLException {
Query query = session
.createQuery("from Sort where sort_ID = ?");
query.setInteger(0, id);
return query.list();
}
});
if (list != null && list.isEmpty() == false) {
return (Sort) list.get(0);
} else {
return null;
}
}

6. DAO的基类

注意由于所有dao都需要继承自HibernateDaoSupport ，所以我们在基类中做这个动作。

package com.windrift.dao.imp;

import java.io.Serializable;

import org.springframework.orm.hibernate3.support.HibernateDaoSupport;

import com.windrift.dao.BaseDAO;

public class BaseDAOImp extends HibernateDaoSupport implements BaseDAO {
/* (non-Javadoc)
* @see com.windrift.dao.imp.BaseDAO#delete(java.lang.Object)
*/
public void delete(Object o) {
getHibernateTemplate().delete(o);
}

/* (non-Javadoc)
* @see com.windrift.dao.imp.BaseDAO#flush()
*/
public void flush() {
getHibernateTemplate().flush();
}

/* (non-Javadoc)
* @see com.windrift.dao.imp.BaseDAO#get(java.lang.Class, java.io.Serializable)
*/
public Object get(Class clazz, Serializable id) {
return getHibernateTemplate().get(clazz, id);
}

/* (non-Javadoc)
* @see com.windrift.dao.imp.BaseDAO#load(java.lang.Class, java.io.Serializable)
*/
public Object load(Class clazz, Serializable id) {
return getHibernateTemplate().load(clazz, id);
}

/* (non-Javadoc)
* @see com.windrift.dao.imp.BaseDAO#refresh(java.lang.Object)
*/
public void refresh(Object o) {
getHibernateTemplate().refresh(o);
}

/* (non-Javadoc)
* @see com.windrift.dao.imp.BaseDAO#remove(java.lang.Class, java.io.Serializable)
*/
public void remove(Class clazz, Serializable id) {
getHibernateTemplate().delete(get(clazz, id));
}

/* (non-Javadoc)
* @see com.windrift.dao.imp.BaseDAO#save(java.lang.Object)
*/
public void save(Object o) {
getHibernateTemplate().save(o);
}

/* (non-Javadoc)
* @see com.windrift.dao.imp.BaseDAO#saveOrUpdate(java.lang.Object)
*/
public void saveOrUpdate(Object o) {
getHibernateTemplate().saveOrUpdate(o);
}

/* (non-Javadoc)
* @see com.windrift.dao.imp.BaseDAO#update(java.lang.Object)
*/
public void update(Object o) {
getHibernateTemplate().update(o);
}
}

自此圆满完成这个小例子。最后说一点，由于hibernate进行了一次版本更新，因此存在hibernate3和hibernate两个包（如：import org.springframework.orm.hibernate3.support.HibernateDaoSupport;）。大家一定都使用 hibernate3，不然出错比较难找。