Spring结合Hibernate事务实现小例

前面几篇文章讲解了Spring实现事务的原理，下面我们就实现几个对数据库事务操作的小例子。

一. Hibernate实现编程式事务

Dao访问接口：

<span style="font-size:14px;">/**
 * <pre>
 * 项目名： common-spring-transaction
 * 类名： GenericDao.java
 * 类描述： Dao接口
 * 创建日期：2015-5-20
 * 创建时间：下午2:04:26
 * </pre>
 */

public interface GenericDao<K extends Serializable,T> {
 
	/**
	 * 保存记录
	 * @param t
	 */
	public void save(T t);
	
	/**
	 * 更新记录
	 * @param t
	 */
	public void update(T t);
	
	/**
	 * 删除记录
	 * @param k
	 */
	public void delete(K k);
	
	/**
	 * 查询记录
	 * @param k
	 * @return
	 */
	public T query(K k);
}</span>

Dao事务访问实现类：

<span style="font-size:14px;">/**
 * 
 * <pre>
 * 项目名： common-spring-base
 * 类名： GenericDaoImpl.java
 * 类描述： Dao实现类
 * 创建日期：2015-5-21
 * 创建时间：下午8:45:07
 * @param <K>
 * @param <T>
 * </pre>
 */</span>
<span style="font-size:14px;">public class GenericDaoImpl<K extends Serializable,T> implements GenericDao<K,T> {

	private Logger log = Logger.getLogger(GenericDaoImpl.class);
	
	private Class<T> persistentClass;
	
	private SessionFactory sessionFactory;
	
	public GenericDaoImpl() {
		super();
	}

	public GenericDaoImpl(final Class<T> persistentClass){
		this.persistentClass = persistentClass;
	}
	
	@Autowired
	public void setSessionFactory(SessionFactory sessionFactory) {
		this.sessionFactory = sessionFactory;
	}

	@Override
	public void save(T t) {
		Session session = sessionFactory.openSession();
		Transaction transaction = session.beginTransaction();
		try{
			transaction.begin();
			session.save(t);
			transaction.commit();
		}catch(Exception e){
			log.error("保存实体表发生异常"+e.getMessage());
			e.printStackTrace();
			transaction.rollback();
		}finally{
			session.close();
		}
	}

	@Override
	public void update(T t) {
		save(t);
	}

	@Override
	public void delete(K k) {
		Session session = sessionFactory.openSession();
		Transaction transaction = session.beginTransaction();
		try{
			transaction.begin();
			session.delete(session.get(persistentClass, k));
			transaction.commit();
		}catch(Exception e){
			log.error("删除实体表发生异常"+e.getMessage());
			e.printStackTrace();
			transaction.rollback();
		}finally{
			session.close();
		}
	}

	@SuppressWarnings("unchecked")
	@Override
	public T query(K k) {
		Session session = sessionFactory.openSession();	
		return (T) session.get(persistentClass, k);
	}
}</span>

二. 基于HibernateTemplate实现保存事务操作

HibernateTemplate对数据库的操作是自带事务的，故使用该类的时候，我们可以不用考虑事务的问题。如上面的save方法只需改成下面的方式即可。

<span style="font-size:14px;">public void save(T t) {
		hibernateTemplate.save(t);
	}</span>

三. 基于Spring配置的拦截器模式事务实现

<span style="font-size:14px;"><bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager"> 
 		<property name="sessionFactory" ref="sessionFactory" />
    </bean>
    
    <!-- 使用拦截器方式开启事务 -->
	<bean id="transactionInterceptor" class="org.springframework.transaction.interceptor.TransactionInterceptor">  
        <property name="transactionManager" ref="transactionManager" />  
        <!-- 配置事务属性   -->
        <property name="transactionAttributes">  
            <props>  
                <prop key="*">PROPAGATION_REQUIRED</prop>  
            </props>  
        </property>  
    </bean>
      
    <bean class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">  
        <property name="beanNames">  
            <list>  
                <value>schoolManager</value><!-- 业务dao实现类 -->
                <value>studentManager</value><!-- 业务dao实现类 -->
            </list>  
        </property>  
        <property name="interceptorNames">  
            <list>  
                <value>transactionInterceptor</value>  
            </list>  
        </property>  
    </bean> </span>

四. 基于tx标签配置的拦截器配置模式

<span style="font-size:14px;"><bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager"> 
 		<property name="sessionFactory" ref="sessionFactory" />
    </bean> 
    
   	<!--  使用tx标签配置的拦截器配置方式开启事务 -->
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
    	<tx:attributes>
    		<tx:method name="save*" propagation="REQUIRED"/>
    	</tx:attributes>
    </tx:advice>
    
    <aop:config>
         <aop:pointcut id="pointcut" expression="execution(* hibernate.daoImpl.*.*(..))" />
         <aop:advisor advice-ref="txAdvice" pointcut-ref="pointcut"/>
    </aop:config>  </span>

五. 全注解的模式

<span style="font-size:14px;"><!-- 使用@Transactional注解方式开启事务 -->
   <tx:annotation-driven/>
 	
 	<bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager"> 
 		<property name="sessionFactory" ref="sessionFactory" />
    </bean> </span>

然后在想要进行事务控制的类或者方法上加入@Transactional注解即可。

六. 定义每个bean都有一个代理

<span style="font-size:14px;"><!-- 定义事务管理器（声明式的事务） -->  
    <bean id="transactionManager"
        class="org.springframework.orm.hibernate3.HibernateTransactionManager">
        <property name="sessionFactory" ref="sessionFactory" />
    </bean>
    
    <!-- 配置DAO -->
    <bean id="userDaoTarget" class="com.bluesky.spring.dao.UserDaoImpl">
        <property name="sessionFactory" ref="sessionFactory" />
    </bean>
    
    <bean id="userDao"  
        class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">  
           <!-- 配置事务管理器 -->  
           <property name="transactionManager" ref="transactionManager" />     
        <property name="target" ref="userDaoTarget" />  
         <property name="proxyInterfaces" value="com.bluesky.spring.dao.GeneratorDao" />
        <!-- 配置事务属性 -->  
        <property name="transactionAttributes">  
            <props>  
                <prop key="*">PROPAGATION_REQUIRED</prop>
            </props>  
        </property>  
    </bean> </span>

七. 所有的Bean共享一个代理类

<span style="font-size:14px;"><!-- 定义事务管理器（声明式的事务） -->  
    <bean id="transactionManager"
        class="org.springframework.orm.hibernate3.HibernateTransactionManager">
        <property name="sessionFactory" ref="sessionFactory" />
    </bean>
    
    <bean id="transactionBase"  
            class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean"  
            lazy-init="true" abstract="true">  
        <!-- 配置事务管理器 -->  
        <property name="transactionManager" ref="transactionManager" />  
        <!-- 配置事务属性 -->  
        <property name="transactionAttributes">  
            <props>  
                <prop key="*">PROPAGATION_REQUIRED</prop>  
            </props>  
        </property>  
    </bean>    
   
    <!-- 配置DAO -->
    <bean id="userDaoTarget" class="com.bluesky.spring.dao.UserDaoImpl">
        <property name="sessionFactory" ref="sessionFactory" />
    </bean>
    
    <bean id="userDao" parent="transactionBase" >  
        <property name="target" ref="userDaoTarget" />   
    </bean></span>

关于既然HibernateTemplate和Spring都能实现事务的情况下，为何二者还会都存在，网上有种说法：

在通常的情况下，一个操作（CURD）一个回滚，但是有时候你需要将多个操作放到同一个事物当中，因为这几个操作必须同时完成，否则只要有一个操作失败，整个事务就要

回滚。hibernate与spring结合之后，将事务管理的责任扔给了spring，spring中通常配置事务时是将事务的开启放在service层（也就是那个XXXmananger类），因为service层

是业务逻辑层，就是进行业务逻辑处理的，一次业务处理当中可以进行多次操作，比如插入数据，然后写个日志等等，等这些操作都完成了，spring再帮你提交事务。

一句话来说就是，hibernate自己管理事务时，事务的范围较小，而由spring控制事务时，事务的范围可以按需要扩大。