spring事务详解及配置、实例

一、spring是怎样进行事务管理的：

（一）Spring事务策略

　　Spring事务策略,也就是spring事务管理的实现方式.它有一个统一的抽象是由实现下面这个接口完成的.

　　org.springframework.transaction.PlatformTransactionManager

　　此接口的内容如下:

　　Public interfacePlatformTransactionManager()...{

　　TransactionStatue getTransaction(TransactionDefinition definition) throws TransactionException;

　　Void commit(TransactionStatus status) throws TransactionException;

　　Void rollback(TransactionStatus status) throws TransactionException;

　　}

　　不管是声明式的还是编程式的事务管理都需要此抽象来完成.

　　解释一下这个接口,这样可以更好的理解spring的事务控制的原理.

　　getTransaction()根据类型为TransactionDefinition的参数返回一个TransactionStatus对象.返回的TransactionStatus对象可能代表一个新的或已经存在的事务(如果在当前调用堆栈有一个符合条件的事务).如同J2EE事务上下文,一个TransactionStatus也是和执行的线程关联的.

　　同时,在框架中还存在TransactionDefinition接口,即上边的参数类型.此接口指定了事务隔离程度、事务传播、事务超时、只读状态。

　　另外，还有TransactionStatus接口。这个接口为处理事务提供简单的控制事务执行和查询事务状态的方法。

（二）两种spring事务管理方式

      1编程式：

　　Spring提供两种方式的编程式事务管理，分别是：使用TransactionTemplate和直接使用PlatformTransactionManager。

　　ⅰ. TransactionTempale采用和其他Spring模板，如JdbcTempalte和HibernateTemplate一样的方法。它使用回调方法，把应用程序从处理取得和释放资源中解脱出来。如同其他模板，TransactionTemplate是线程安全的。

　　代码片段：

　　Object result =tt.execute(newTransactionCallback()...{

　　publicObject doTransaction(TransactionStatus status)...{

　　updateOperation();

　　returnresultOfUpdateOperation();

　　}

　　});

　　使用TransactionCallback()可以返回一个值。

　　如果使用TransactionCallbackWithoutResult则没有返回值。

　　ⅱ. 也可以使用PlatformTransactionManager直接管理事务。简单地通过一个bean引用给你的bean传递一个你使用的PlatformTransaction对象。然后，使用TransactionDefinition和TransactionStatus对象就可以发起、回滚、提交事务。

　　如下片段：

　　DefaultTransactionDefinition def=newDefaultTransactionDefinition(); //new 一个事务

　　def.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED); //初始化事务,参数定义事务的传播类型;

　　TransactionStatus status =transactionManager.getTransaction(def); //获得事务状态

　　try...{

　　……………..

　　transactionManager.commit(status); //提交事务;

　　}catch(…..)...{

　　transactionManager.rollback(status); //回滚事务;

　　}

      2声明式：

　　Spring也提供声明式事务管理。这是通过AOP实现的。

　　大多数Spring用户选择声明式事务管理，这是最少影响应用代码的选择，因而这是和非侵入性的轻量级容器的观念是一致的。

　　① 通常通过TransactionProxyFactoryBean设置Spring事务代理。需要一个目标对象包装在事务代理中。这个目标对象一般是一个普通Javabean。当我们定义TransactionProxyFactoryBean时，必须提供一个相关的PlatformTransactionManager的引用和事务属性。事务属性含有事务定义。例如:

　　PROPAGATION_REQUIRED,-MyCheckedException

　　PROPAGATION_REQUIRED

　　PROPAGATION_REQUIRED,readOnly

　　事务代理会实现目标对象的接口:这里是属性名是target的引用。id是transactionServiceControl。(●使用CGLIB也可以实现具体类的代理。只要设置proxyTargetClass属性为true即可。如果目标对象没有实现任何接口，这将自动设置该属性为true。通常，我们希望面向接口编程。) ●使用proxyInterfaces属性来限定事务代理来代理指定接口也是可以。 ●也可以通过从org.springframework.aop.framework.ProxyConfig继承或所有AOP代理工厂共享的属性来定制TransactionProxyFactoryBean行为。

　　然后，说说属性名是transactionAttributes意义：

　　这里的transactionAttributes属性是定义在org.springframework.transaction.interceptor.NameMathTransactionAttributeSource中的属性格式设置。这个包括通配符的方法名称映射是很直观的，如”insert*”。注意insert*的映射的值包括回滚规则。”-MyCheckException”指定如果方法抛出MyCheckException或它的子类，事务会自动回滚。可以用逗号分隔多个回滚规则。“-”前缀强制回滚，“+”前缀指定提交(这允许即使抛出unchecked异常时也可以提交事务)。“PROPAGATION_REQUIRED”指定事务传播范围。

　　TransactionProxyFactoryBean允许你通过“preInterceptors”和“postInterceptors”属性设置前或后的拦截操作。可以设置任意数量的前和后通过，它们的类型可以是Advistor(切入点)，MethodInterceptor或被当前Spring配置支持的通知类型。例如：ThrowAdvice，AfterReturningAdvice或BeforeAdvice。这些通知必须支持实例共享模式。如果你需要高级AOP特性操作事务，通过org.springframework.aop.framework.ProxyFactoryBean，而不是TransactionProxyFactory实用代理创建者。

　　② 另一种声明方式：BeanNameAutoProxyCreator

　　使用TransactionProxyFactoryBean当事务代理包装对象，你可以完全控制代理。如果需要用一致方式包装大量bean。使用一个BeanFactoryPostProcessor的一个实现，BeanNameAutoProxyCreator，可以提供另外一种方法。(Spring中，一旦ApplicationContext读完它的初始化信息，它将初始化所有实现BeanPostProcessor接口的bean，并且让它们后处理ApplicationContext中所有其他的bean。所以使用这种机制，正确配置的BeanNameAutoProxyCreator可以用来后处理所有ApplicationContext中所有其他的bean),并且把它们用事务代理包装起来。真正生成的事务代理和使用TransactionProxyFactoryBean生成的基本一致。

 (三)总结：

1统观spring事务，围绕着两个核心PlatformTransactionManager和TransactionStatus

spring提供了几个关于事务处理的类： 
TransactionDefinition //事务属性定义
TranscationStatus //代表了当前的事务，可以提交，回滚。
PlatformTransactionManager这个是spring提供的用于管理事务的基础接口，其下有一个实现的抽象类AbstractPlatformTransactionManager,我们使用的事务管理类例如DataSourceTransactionManager等都是这个类的子类。

一般事务定义步骤：

TransactionDefinition td = new TransactionDefinition();

TransactionStatus ts = transactionManager.getTransaction(td);

try

{ //do sth

  transactionManager.commit(ts);

}

catch(Exception e){transactionManager.rollback(ts);}

 

spring提供的事务管理可以分为两类：编程式的和声明式的。编程式的，比较灵活，但是代码量大，存在重复的代码比较多；声明式的比编程式的更灵活。

编程式主要使用transactionTemplate。省略了部分的提交，回滚，一系列的事务对象定义，需注入事务管理对象.

void add()

{

    transactionTemplate.execute( new TransactionCallback(){

        pulic Object doInTransaction(TransactionStatus ts)

       { //do sth}

    }

}

声明式：

使用TransactionProxyFactoryBean:

<bean id="userManager" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
  <property name="transactionManager"><ref bean="transactionManager"/></property>
  <property name="target"><ref local="userManagerTarget"/></property>
  <property name="transactionAttributes">
   <props>
    <prop key="insert*">PROPAGATION_REQUIRED</prop>
    <prop key="update*">PROPAGATION_REQUIRED</prop>
    <prop key="*">PROPAGATION_REQUIRED,readOnly</prop>
   </props>
  </property>
 </bean>

2围绕Poxy的动态代理 能够自动的提交和回滚事务

org.springframework.transaction.interceptor.TransactionProxyFactoryBean

• PROPAGATION_REQUIRED--支持当前事务，如果当前没有事务，就新建一个事务。这是最常见的选择。
  
• PROPAGATION_SUPPORTS--支持当前事务，如果当前没有事务，就以非事务方式执行。
  
• PROPAGATION_MANDATORY--支持当前事务，如果当前没有事务，就抛出异常。
  
• PROPAGATION_REQUIRES_NEW--新建事务，如果当前存在事务，把当前事务挂起。
  
• PROPAGATION_NOT_SUPPORTED--以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。
  
• PROPAGATION_NEVER--以非事务方式执行，如果当前存在事务，则抛出异常。
  
• PROPAGATION_NESTED--如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则进行与PROPAGATION_REQUIRED类似的操作。   
  

- MyCheckException”指定如果方法抛出MyCheckException或它的子类，事务会自动回滚。可以用逗号分隔多个回滚规则。“－” 前缀强制回滚，“＋”前缀指定提交（这允许即使抛出unchecked异常时也可以提交事务）。

Readonly的解释：

“只读事务”并不是一个强制选项，它只是一个“暗示”，提示数据库驱动程序和数据库系统，这个事务并不包含更改数据的操作，那么JDBC驱动程序和数据库就有可能根据这种情况对该事务进行一些特定的优化，比方说不安排相应的数据库锁，以减轻事务对数据库的压力，毕竟事务也是要消耗数据库的资源的。 

但是你非要在“只读事务”里面修改数据，也并非不可以，只不过对于数据一致性的保护不像“读写事务”那样保险而已。 

因此，“只读事务”仅仅是一个性能优化的推荐配置而已，并非强制你要这样做不可

（四）最后，总结一下Spring的优点：

◆为不同的事务ＡＰＩ提供一致的编程模型，如JTA、JDBC、Hibernate、iBATIS数据库层ＪＤＯ
◆提供比大多数事务API更简单的、易于使用的编程式事务管理API
◆整合Spring数据访问抽象
◆支持Spring声明式事务管理

二、Spring事务配置的五种方式

Spring配置文件中关于事务配置总是由三个组成部分，分别是DataSource、TransactionManager和代理机制这三部分，无论哪种配置方式，一般变化的只是代理机制这部分。

    DataSource、TransactionManager这两部分只是会根据数据访问方式有所变化，比如使用Hibernate进行数据访问时，DataSource实际为SessionFactory，TransactionManager的实现为HibernateTransactionManager。

    具体如下图：

    根据代理机制的不同，总结了五种Spring事务的配置方式，配置文件如下：

    第一种方式：每个Bean都有一个代理

<? xml version="1.0" encoding="UTF-8" ?>
< beans xmlns ="http://www.springframework.org/schema/beans"
    xmlns:xsi ="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:context ="http://www.springframework.org/schema/context"
    xmlns:aop ="http://www.springframework.org/schema/aop"
    xsi:schemaLocation ="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
           http://www.springframework.org/schema/context
           http://www.springframework.org/schema/context/spring-context-2.5.xsd
           http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd" >

    < bean id ="sessionFactory"  
            class ="org.springframework.orm.hibernate3.LocalSessionFactoryBean" >  
        < property name ="configLocation" value ="classpath:hibernate.cfg.xml"   />  
        < property name ="configurationClass" value ="org.hibernate.cfg.AnnotationConfiguration"   />
    </ bean >  

    <!-- 定义事务管理器（声明式的事务） -->  
    < 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 >  
</ beans >

    第二种方式：所有Bean共享一个代理基类

<? xml version="1.0" encoding="UTF-8" ?>
< beans xmlns ="http://www.springframework.org/schema/beans"
    xmlns:xsi ="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:context ="http://www.springframework.org/schema/context"
    xmlns:aop ="http://www.springframework.org/schema/aop"
    xsi:schemaLocation ="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
           http://www.springframework.org/schema/context
           http://www.springframework.org/schema/context/spring-context-2.5.xsd
           http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd" >

    < bean id ="sessionFactory"  
            class ="org.springframework.orm.hibernate3.LocalSessionFactoryBean" >  
        < property name ="configLocation" value ="classpath:hibernate.cfg.xml"   />  
        < property name ="configurationClass" value ="org.hibernate.cfg.AnnotationConfiguration"   />
    </ bean >  

    <!-- 定义事务管理器（声明式的事务） -->  
    < 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 >
</ beans >

    第三种方式：使用拦截器

<? xml version="1.0" encoding="UTF-8" ?>
< beans xmlns ="http://www.springframework.org/schema/beans"
    xmlns:xsi ="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:context ="http://www.springframework.org/schema/context"
    xmlns:aop ="http://www.springframework.org/schema/aop"
    xsi:schemaLocation ="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
           http://www.springframework.org/schema/context
           http://www.springframework.org/schema/context/spring-context-2.5.xsd
           http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd" >

    < bean id ="sessionFactory"  
            class ="org.springframework.orm.hibernate3.LocalSessionFactoryBean" >  
        < property name ="configLocation" value ="classpath:hibernate.cfg.xml"   />  
        < property name ="configurationClass" value ="org.hibernate.cfg.AnnotationConfiguration"   />
    </ bean >  

    <!-- 定义事务管理器（声明式的事务） -->  
    < 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 > *Dao </ value >
            </ list >  
        </ property >  
        < property name ="interceptorNames" >  
            < list >  
                < value > transactionInterceptor </ value >  
            </ list >  
        </ property >  
    </ bean >  
 
    <!-- 配置DAO -->
    < bean id ="userDao" class ="com.bluesky.spring.dao.UserDaoImpl" >
        < property name ="sessionFactory" ref ="sessionFactory"   />
    </ bean >
</ beans >

    第四种方式：使用tx标签配置的拦截器

<? xml version="1.0" encoding="UTF-8" ?>
< beans xmlns ="http://www.springframework.org/schema/beans"
    xmlns:xsi ="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:context ="http://www.springframework.org/schema/context"
    xmlns:aop ="http://www.springframework.org/schema/aop"
    xmlns:tx ="http://www.springframework.org/schema/tx"
    xsi:schemaLocation ="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
           http://www.springframework.org/schema/context
           http://www.springframework.org/schema/context/spring-context-2.5.xsd
           http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
           http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd" >

    < context:annotation-config />
    < context:component-scan base-package ="com.bluesky"   />

    < bean id ="sessionFactory"  
            class ="org.springframework.orm.hibernate3.LocalSessionFactoryBean" >  
        < property name ="configLocation" value ="classpath:hibernate.cfg.xml"   />  
        < property name ="configurationClass" value ="org.hibernate.cfg.AnnotationConfiguration"   />
    </ bean >  

    <!-- 定义事务管理器（声明式的事务） -->  
    < bean id ="transactionManager"
        class ="org.springframework.orm.hibernate3.HibernateTransactionManager" >
        < property name ="sessionFactory" ref ="sessionFactory"   />
    </ bean >

    < tx:advice id ="txAdvice" transaction-manager ="transactionManager" >
        < tx:attributes >
            < tx:method name ="*" propagation ="REQUIRED"   />
        </ tx:attributes >
    </ tx:advice >
   
    < aop:config >
        < aop:pointcut id ="interceptorPointCuts"
            expression ="execution(* com.bluesky.spring.dao.*.*(..))"   />
        < aop:advisor advice-ref ="txAdvice"
            pointcut-ref ="interceptorPointCuts"   />        
    </ aop:config >      
</ beans >

    第五种方式：全注解

<? xml version="1.0" encoding="UTF-8" ?>
< beans xmlns ="http://www.springframework.org/schema/beans"
    xmlns:xsi ="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:context ="http://www.springframework.org/schema/context"
    xmlns:aop ="http://www.springframework.org/schema/aop"
    xmlns:tx ="http://www.springframework.org/schema/tx"
    xsi:schemaLocation ="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
           http://www.springframework.org/schema/context
           http://www.springframework.org/schema/context/spring-context-2.5.xsd
           http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
           http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd" >

    < context:annotation-config />
    < context:component-scan base-package ="com.bluesky"   />

    < tx:annotation-driven transaction-manager ="transactionManager" />

    < bean id ="sessionFactory"  
            class ="org.springframework.orm.hibernate3.LocalSessionFactoryBean" >  
        < property name ="configLocation" value ="classpath:hibernate.cfg.xml"   />  
        < property name ="configurationClass" value ="org.hibernate.cfg.AnnotationConfiguration"   />
    </ bean >  

    <!-- 定义事务管理器（声明式的事务） -->  
    < bean id ="transactionManager"
        class ="org.springframework.orm.hibernate3.HibernateTransactionManager" >
        < property name ="sessionFactory" ref ="sessionFactory"   />
    </ bean >
   
</ beans >

    此时在DAO上需加上@Transactional注解，如下：

package com.bluesky.spring.dao;

import java.util.List;

import org.hibernate.SessionFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;
import org.springframework.stereotype.Component;

import com.bluesky.spring.domain.User;

@Transactional
@Component( " userDao " )
public   class UserDaoImpl extends HibernateDaoSupport implements UserDao {

    public List < User > listUsers() {
        return   this .getSession().createQuery( " from User " ).list();
    }
   
   
}

默认让其回滚@TransactionConfiguration(defaultRollback = true, transactionManager = "transactionManager")

三、实例

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:p="http://www.springframework.org/schema/p"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:mvc="http://www.springframework.org/schema/mvc"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd                                
http://www.springframework.org/schema/context 
http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/mvc
http://www.springframework.org/schema/mvc/spring-mvc-3.1.xsd">


	<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
		<property name="driverClassName" value="${jdbc.driver}" />
		<property name="url" value="${jdbc.url}" />
		<property name="username" value="${jdbc.username}" />
		<property name="password" value="${jdbc.password}" />
		<property name="maxActive" value="10" />
	</bean>
  
	<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
		<property name="dataSource" ref="dataSource" />
	</bean>

	<bean id="transactionAttributeSource" class="org.springframework.transaction.interceptor.NameMatchTransactionAttributeSource">
		<property name="properties">
			<props>
				<prop key="insert*">PROPAGATION_REQUIRED</prop>
				<prop key="update*">PROPAGATION_REQUIRED</prop>
				<prop key="delete*">PROPAGATION_REQUIRED</prop>
				<prop key="select*">PROPAGATION_REQUIRED,readOnly</prop>
			</props>
		</property>
	</bean>
  
	<bean id="transactionInterceptor" class="org.springframework.transaction.interceptor.TransactionInterceptor">
		<property name="transactionManager" ref="transactionManager" />
		<property name="transactionAttributeSource" ref="transactionAttributeSource" />
	</bean>

	<bean id="beanNameAutoProxy" class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">
		<property name="interceptorNames">
			<list>
				<value>transactionInterceptor</value>
			</list>
		</property>
		<property name="beanNames">
			<list>
				<value>*Service</value>
			</list>
		</property>
	</bean>
  
	<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
		<property name="dataSource" ref="dataSource" />
		<property name="mapperLocations" value="classpath*:maps/**/*.xml" />
		
	</bean>
	
	<bean id="baseDao" class="AbstractDao" abstract="true">
		<property name="sqlSessionFactory" ref="sqlSessionFactory" />
	</bean>
	
</beans>