Spring基础系列——事务Transaction

在spring的事务管理高层抽象层中主要包含3个借口：TransactionDefinition,PlatformTransactionManager,TransactionStatus

TransactionDefinition用于描述隔离级别、超时时间、是否为只读事务和事务传播规则

TransactionStatus代表一个事务的具体运行状态、以及保存点

PlatformTransactionManager一个高层次的接口，包含3个方法commit、rollback和getTramsaction

事务传播级别：

PROPAGATION_REQUIRED--支持当前事务，如果当前没有事务，就新建一个事务。这是最常见的选择。适用于save、update、delete等操作
PROPAGATION_SUPPORTS--支持当前事务，如果当前没有事务，就以非事务方式执行。一般读db的操作可是使用此方式，同时将事物设置为ReadOnly。
PROPAGATION_MANDATORY--支持当前事务，如果当前没有事务，就抛出异常。
PROPAGATION_REQUIRES_NEW--新建事务，如果当前存在事务，把当前事务挂起。
PROPAGATION_NOT_SUPPORTED--以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。适用于优先级别很高的方法。
PROPAGATION_NEVER--以非事务方式执行，如果当前存在事务，则抛出异常。
PROPAGATION_NESTED--如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则进行与PROPAGATION_REQUIRED类似的操作。

三种事务管理方式：编程式事务管理、使用xml配置声明式事务、使用注解配置声明式事务

1.编程式事务管理

略

2.使用xml配置声明式事务

事务属性信息配置规则

<!-- 传播行为，隔离级别(可选)，是否为只读(可选)，发生这些异常时回滚(可选)，发生这些异常时照样提交(可选)-->
<prop>PROPAGATION,ISOLATION,readOnly,_Exception,+Exception</prop>

 

第一种：也是我们最常用的方法了，它适用于你的库表比较少的情况下。

<bean id="fundServiceDAOProxy"
   class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
   <!-- 配置事务管理器 -->
   <property name="transactionManager">
    <ref bean="transactionManager" />
   </property>
   <!-- 此属性指定目标类本省是否是代理的对象，如果目标类没有实现任何类，就设为true代表自己 -->
   <property name="proxyTargetClass">
    <value>false</value>
   </property>
   <!-- 目标实现的接口 -->
   <property name="proxyInterfaces">
    <value>com.jack.fund.service.IFundService</value>
   </property>
   <!-- 目标bean -->
   <property name="target">
    <ref bean="fundService" />
   </property>
   <!-- 配置事务属性 -->
   <property name="transactionAttributes">
    <props>
     <prop key="delete*">PROPAGATION_REQUIRED</prop>
     <prop key="add*">PROPAGATION_REQUIRED</prop>
     <prop key="update*">PROPAGATION_REQUIRED</prop>
     <prop key="save*">PROPAGATION_REQUIRED</prop>
     <prop   key="find*">PROPAGATION_REQUIRED,readOnly</prop>
    </props>
   </property>
</bean> 

以下可能还有其他的xxxServiceDAOProxy.大家可以看出针对每一个功能模块配置一个业务代理服务。如果模块多大话，就显得代码有点多了，发现他们只是稍微一点不一样。这时我们就应该想到继承的思想。用第二种方法。

第二种：配置声明式事务的方法如下。这种情况适合相对比较多的模块时使用。

<!-- 利用继承的思想简化配置，要把abstract="true" -->
<bean id="transactionBase"
   class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean"
   lazy-init="true" abstract="true">
   <!-- 配置事务管理器 -->
   <property name="transactionManager">
    <ref bean="transactionManager" />
   </property>
   <!-- 配置事务属性 -->
   <property name="transactionAttributes">
    <props>
     <prop key="delete*">PROPAGATION_REQUIRED</prop>
     <prop key="add*">PROPAGATION_REQUIRED</prop>
     <prop key="update*">PROPAGATION_REQUIRED</prop>
     <prop key="save*">PROPAGATION_REQUIRED</prop>
     <prop key="find*">PROPAGATION_REQUIRED,readOnly</prop>
    </props>
   </property>
</bean> 

而具体的模块可以简单的这样配置。只要指明它的parent（父类）就可以了。父类一般把abstract="true"，因为在容器加载的时候不需要初始化，等到用的时候再有它的子类调用的时候，再去初始化。

<bean id="fundServiceDAOProxy" parent="transactionBase" >
   <property name="target">
   <ref bean="fundService" />
   </property>
</bean> 

这样配置的话，如果有多个像fundService这样模块时，可以少些很多重复的代码。

第三种：配置声明式事务的方法如下。主要利用BeanNameAutoProxyCreator自动创建事务代理

 

<bean id="transactionInterceptor"
   class="org.springframework.transaction.interceptor.TransactionInterceptor"> 
   <property name="transactionManager">
    <ref bean="transactionManager" />
   </property>
   <!-- 配置事务属性 -->
   <property name="transactionAttributes">
    <props>
     <prop key="delete*">PROPAGATION_REQUIRED</prop>
     <prop key="add*">PROPAGATION_REQUIRED</prop>
     <prop key="update*">PROPAGATION_REQUIRED</prop>
     <prop key="save*">PROPAGATION_REQUIRED</prop>
     <prop key="find*">PROPAGATION_REQUIRED,readOnly</prop>
    </props>
   </property>
</bean> 
<bean
   class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">
   <property name="beanNames">
    <list>
     <value>fundService</value>
    </list>
   </property>
   <property name="interceptorNames">
    <list>
     <value>transactionInterceptor</value>
    </list>
   </property>
</bean> 

这种方法主要利用了拦截器的原理。
前三种方法一般都必需指定具体的模块bean.如果模块过多话，比如一个大型的网站一般有几十个模块。我们就得考虑用第四种的配置方式了。自动创建事务代理的方式了。

第四种：配置声明式事务的方法如下。

<bean id="transactionInterceptor"
   class="org.springframework.transaction.interceptor.TransactionInterceptor"> 
   <property name="transactionManager">
    <ref bean="transactionManager" />
   </property> 
<!-- 自动代理 -->
<bean id="autoproxy"
   class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">
   <!-- 可以是Service或DAO层（最好是针对业务层*Service） -->
   <property name="beanNames">
    <list>
     <value>*Service</value>
    </list>
   </property>
   <property name="interceptorNames">
    <list>
        <value>transactionInterceptor</value>
    </list>
   </property>
</bean> 

自动代理还有一种用法就是结合正规表达式和advice使用。

<bean id="transactionInterceptor"
   class="org.springframework.transaction.interceptor.TransactionInterceptor"> 
   <property name="transactionManager">
    <ref bean="transactionManager" />
   </property> 
<bean id="autoProxyCreator"
   class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator" /> 
<bean id="regexpMethodPointcutAdvisor"
   class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
   <property name="advice">
   <ref bean="transactionInterceptor" />
   </property>
   <property name="pattern">
   <value>.*</value>
   </property>
</bean> 

这个方法可以针对具体的模块进行拦截并进行事务处理。
在你的实际项目中，你可以根据你的情况选用不同的方法。

详细：http://www.cnblogs.com/rushoooooo/archive/2011/08/28/2155960.html

3.使用注解配置声明式事务 @Transaction

注解本身具有一些普遍使用的默认属性，所以往往只加一个@Transaction就可以了

@Transaction注解属性说明

value：可以绑定到不同的事务管理器上

propagation:事务传播行为

isolation:事务隔离级别

readOnly:是否为只读

timeout:超时时间

rollbackFor:一组异常类，遇到时进行回滚,类型为Class<? extemds Tjrpwab;e>[]，默认为{}

rollbackForClassName:一组异常类，遇到时进行回滚，类型为String[],默认为{}

noRollbackFor:一组异常类，遇到时不回滚,类型为Class<? extemds Tjrpwab;e>[]，默认为{}

noRollbackForClassName:一组异常类，遇到时不回滚，类型为String[],默认为{}