spring事物

事务 ( acid )
  atomic : 原子性 ，有多个行为组成的一组工作单元，这组操作要么都发生，要么都不发

生。

  consistent : 一致性 ， 事务结束之后(不管成功或者失败 ) 系统所处的状态和他的业务规

则应当是一致的

  isolated : 隔离性，不同的事务之间不能相互干扰，这通常要以为着对数据库加锁

  duration : 持久性，一旦事务提交，事务的结果就会持久保存，无论什么样的系统崩溃，

他们都将幸免遇难 。

Spring的事物支持 Spring 提供了对程序控制事务的支持，同时也支持声明式事务，Spring 采取了一种回调机制，将事务的控制从应用中抽取出来。选择程序控制或者声明式事务取决于事务控制的粒度。

Spring的TransactionManager
针对不同的事务实现，Spring提供了不同的事务管理工具 。

JDBC :   org.springframework.jdbc.datasource.DataSourceTransactionManager

Hibernate: org.springframework.orm.hibernate.HibernateTransactionManager .



** 每种管理器都充当了针对特定平台的事务实现代理 。
在Spring中通过程序控制事务 ：


编程式事物主要依靠TransactionTemplate接口来完成。

TransactionTemplate.execute（）；



1）声明事物管理器( transaction manager ) : 提供基本的事物服务。

2）声明事物模板( TransactionTemplate) ,并向TransactionTemplate中注入事物管理器

3) 向业务组件中注入TransactionTemplate。

4）在业务组件中通过TransactionTemplate的execute方法来进行事物控制。



1) 声明事务管理器, 在事务管理器中注入DataSource 或SessionFactory , 这取决于事务管理器的类型:

<bean id="transactionManager"  
     class="org.springframework.orm.hibernate3.HibernateTransactionManager">
      <property name="sessionFactory">
                     <ref bean="sessionFactory"/>
      </property>
</bean>




2) 声明事务模板类 , 为事务模板类注入事务管理器 :

  <bean id="transactionTemplate"
       class="org.springframework.transaction.support.TransactionTemplate">
      <property name="transactionManager">
         <ref bean="transactionManager"/>
      </property>
   </bean>
在事物模板类( TransactionTemplate )中定义了一个方法 ：

template.execute( TransationCallBack callBack ) ;


需要运行在事务中的代码因该编写在 TransactionCallBack中 。在这个模型里我们可以这样理解几种组件之间的关系 ：

TransactionManager : 提供基本的事务服务 ：通过TransactionManager，完成对事物的

                       提交或会滚 。

transactionTemplate : 为需要事务服务的方法添加事务处理功能。具体的事务操作会调

用transactionManager完成 。

TransactionCallBack ; 提供运行在事务中的代码，TransactionCallBack提供的代码会被

Template加上事务环境 。

3) 编写事务模板所需要的回调接口 TransactionCallBack ， 该接口通常以匿名内部类的方式实现。

     public interface TransactionCallBack{
              Object doInTransaction( TransactionStatus ts ) ；
     }


将需要放在事务中的代码写在doInTransaction方法中 。

public class AdminService{   
       private TransactionTemplate transactionTemplate = null ;
       private AdminDao dao = null ;
       ....... ;
       public void createAdmins(final List<Admin> admins){
          transactionTemplate.execute( new TransactionCallback(){
                      public Object doInTransaction( TransactionStatus ts ){
                          try{
                             for( Admin a : admins){
                             dao.insert( a );
                           }catch( Exception e){
                                ts.setRollbackOnly() ;
                        }
                           return null ;
                       }});
     }
}
  ** dao 和 transactionTemplate 是通过依赖注入 到AdminService方法中的。


声明式事务 ：


在Spring中使用声明式事务我们需要使用TransactionProxyFactoryBean .这个Bean的作用是为目标对象生成代理，在生成的代理中，会将目标的方法包装在事务上下文中 。



<bean id="adminService"
         class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
     <property name="proxyInterfaces">
           <list>
                            <value>package.AdminService</value>
           </list>
     </property>
     <property name="target">
          <ref bean="xxxx"/>
     </property>


     <property name="transactionManager">
           <bean ref=""/>
     </property>
     <!-- 事务属性 -->
     <property name="transactionAttributeResource">
          <bean ref=""/>
     </property>
</bean>


事物属性
所谓事务属性，是对事务策略如何应用到方法中的描述 。这些描述包括这样一些属性

  * 传播行为

  * 只读提示

  * 隔离级别

  * 事务超时间隔



声明简单的事务策略 ：
TransactionProxyFactoryBean 有一个transactionAttributeSource 属性，这个属性就是

用于指定事务策略的 。该接口定义如下 ：





public interface TransactionAttributeSource{
      TransactionAttribute getTransactionAttribute( Method , targetClass);
}
getTransactionAttribute方法根据目标类和方法获得事务属性 。

在spring为此接口提供了一个默认实现， MatchAlwaysTransactionAttributeSource

该接口在配置文件中的配置如下 ：

<bean id="transactionAttributeSource" class="org.springframework.transaction
.interceptor.MatchAlwaysTransactionAttributeSource"
</bean>


在指定该策略时，我们没有指定采用什么样的事物策略，也没有指定哪个类的那个方法需要使用这个策略，因为MatchAlwaysTransactionAttributeSource 总是返回相同的事务策略而不管这个事务中包含了哪些方法。

默认的事物属性是 (PROPAGATION_REQUIRED | ISOLATION_DEFAULT)

:

替换默认的事物策略
为MatchAlwaysTransactionAttributeSource注入DefaultTransactionAttribute,

在DefaultTransactionActtibute中，制定我们需要的事物属性。



<bean id="defaultTransactionAttribute" class="org.springframework.transaction.interceptor.
                           DefualtTransactionAttribute">


       <property name="propagationBehaviorName">
                     <value>PROPAGATION_REQUIRED_NEW</value>
       </property>


      <property name="isolationLevelName">
                     <value>ISOLATION_READ_COMMITED</value>
      </property>
</bean>


为MatchAlwaysTransactionAttributeSource 注入自定义的事务属性 ：

<bean id="transactionAttributeSource"  class="org.springframework.transaction.interceptor
.MatchAlwaysTransactionAttributeSource">
   <property name="transactionAttribute">
      <ref bean="defaultTransactionAttribute"/>
   </property>
</bean>


为不同的方法指定不同的事物策略
MatchAlwaysTransactionAttributeSource 对每一个方法均采用相同的事务属性，这对于

简单应用时十分方便的 ， 但是如果在不同方法需要采用不同事务属性的情况下，这种方式

就不适用 了，我们可以通过另外一种TransactionAttributeSource来为每一个方法声明事务

属性 。



<bean id="transactionAttributeSource"
    class="org.springframework.transction.interceptor.NameMatchTransactionAttributeSource">
        <property name="properties">
           <props>
                 <prop key="methodName">
                    PROPAGATION_REQUIRED_NEW,ISOLATION_READ_COMMITED
                  </prop>
           </props>
   </property>
</bean>


在指定方法名称时，可以使用通配符简化声明方式 ：

<property name="properties">
  <props>
     <prop key="delete*">
           PROPAGATION_REQUIRED_NEW,ISOLATION_READ_COMMITED
     </prop>
  </props>
</property>


指定事务回滚策略 ：
当事务执行的过程中出现异常时，事务可以被声明为回滚或者不回滚，默认规则是RutimeException事务回滚，CheckedException 事务不会滚，但是可以通过配置改变策略。

<bean id="transactionAttributeSource"
    class="org.springframework.transaction.interceptor.NameMathTransactionAttributeSource">
   
<property name="properties">
         <props>
               <prop name="methodname">
                 PROPAGATION_REQUIRED,-DAOException
             </prop>
         </props>
   </property>
</bean>


DAOExcepton前面使用+ 或 - 修饰

  + 表示异常发生时提交事务。

  - 表示异常发生时会滚事务。



名称匹配事务的捷径 ：
   以前我们是通过为TransactionProxyFactoryBean 注入TransactionAttributeSource来指定

事务属性，还用另外一种更加简便的方法来指定事务属性，在这种方式中，不需要定义单独的TransactionAttributeSource



<bean id="adminService"
        class="org.springframework.transaction.interceptor.TransactionFactoryBean">
     <property name="transactionProperties">
        <props>
               <prop key="mehtodName">
                  PROPOAGATION_REQUIRED,ISOLATION_READ_COMMITED
               </prop>
       </props>
     </property>
</bean>


实现声明式事务的一般步骤
1）编写目标对象，即要运行在事物中的对象，通常为业务接口的实现类

2) 根据持久化技术的不同，声明transactionManager.

3)  为目标对象声明代理 ( TrnasactionProxyFactoryBean )并为其注入以下属性

        a, proxyInterfaces

     b,target

     c,transactionManager

     d, transacitonAttribute 或者 transactionProperteis.



1)      声明目标对象

    <bean id="adminServiceTarget" class="xxxx.AdminServiceImpl">
          <property name="adminDao">
                            <ref bean=""/>
          </property>
   </bean>






2)      声明事务管理器

 

<bean id="transactionManager"
       class="org.springframework.orm.hibernate3.HibernateTransactionManager">


      <property name="sessionFactory">
               <ref bean="xxxx"/>
      </property>
  </bean>


3) 声明TransactionAttributeSource来指定事务属性，有两种常用事务属性实现可以采用

   <bean id="transactionAttributeSource" class="org.springframework.transaction.interceptor.
MatchAlwaysTransactionAttributeSource">
      <property name="properties">
           <props>
                            <prop key="mehtodName">
                             xxxxxxxxxxxxxxxx ;
                 </prop>
           </props>
          </property>
      </bean>


4) 通过TransactionProxFactoryBean 将事务控制织入到目标对象的代理中 。



   <bean id="adminService"
      class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
         <property name="proxyInterfaces">
               <list>
                 <value>xxx.AdminService</value>
               </list>
         </property>
       <property name="transactionManager">
                <ref bean="transactionManager"/>
        </property>
       <property name="target">
              <ref bane="adminServiceTarget"/>
        </property>
        <property name="transactionAttributeSource">
               <ref bean="transactionAttributeSource"/>
        </property>
   </bean>






事务属性 :



     transactionAttributeSource :

        |- MatchAlwaysTransactionAttributeResource :

        |     不管什么方法，什么类型总是返回相同的事务属性 ， 对于简单

        |     应用非常方便，但是对于不同的方法，需要采用不同的事物属性

        |     时就不适用了。

        |-  NameMatchTransactionAttributeResource ：

             可以根据不同的方法名称，指定不同的事务属性