Spring事务管理

Spring提供了一流的事务管理。在Spring中可以支持声明式事务和编程式事务。 
    本章主要目标如下： 
    1，Spring事务 
    2，事务属性 
    3，事务管理器 
    4，声明式事务       
     
 1.1Spring的事务 
    事务管理在应用程序中起着至关重要的作用：它是一系列任务的组成工作单元，在这个工作单元中，所有的任务必须同时执行。它们只有二种可能执行结果，要么所有任务全部执行成功，要么所有任务全部执行失败。 
    Spring中提供了丰富的事务管理功能，它们超过了EJB并且和EJB一样支持声明式事务，重要的是Spring提供了致的事务管理，它有如下优点。 
    1，为不同的事务的API提供一致的编程模式 
    2，提供更简单，更易地使用的编程式事务管理 
    3，支持Spring声明事务 
    4，整合Spring对数据访问的抽像 
     
 1.2事务的ACID特性 
    事务使用ACID特性来衡量事务的质量。介绍如下： 
    1，原子性 
        事务必须是原子的，在事务结束的时候，事务中的所有任务必须全部成功完成，否则全部失败，事务回滚到事务开始之间的状态。 
    2，一致性 
        事务必须保证和数据库的一致性，即数据库中的所有数据和现实保持一致。如果事务失败数据必须返回到事务执行之前的状态，反之修改数据和现实的同步。 
    3，隔离性 
        隔离性是事务与事务之间的屏障，每个事务必须与其他事务的执行结果隔离开，直到该事务执行完毕，它保证了事务的访问的任何数据不会受其他事务执行结果的影响。 
    4，持久性 
        如果事务成功执行，无论系统发生任何情况，事务的持久性都必须保证事务的执行结果是永久的。 
  
        1.3事务之间的缺陷 
    在事务处理中有违返ACID特性的3个问题：脏读取，不可重复读和幻读行。如果存在多个并发事务在运行，而这种事务操作了同一个数据来完成它们的任务，就会导致3个问题的存生。要解决它们，就必须在事务之间定义合适的隔离级别。 
    为保证事务的完整性，必须解决事务之间可能存在的3个问题。 
    （1）脏读取 
    当一个事务读取了另一个事务尚未提交的更新，就叫脏读取。在另一个事务回滚的情况下，当前事务所读取的另一个事务的数据就是无效的。 
    （2）不可重复读取 
    在一个事务中执行多次同样的查询操作，但每次查询的结果都不一样，就叫做不可重复读取，通常这种情况是由于数据在二次查询之间被另一个并发的事务所修改。 
    （3）幻影行 
    这是对事务危害最小的一个问候，它类似不可重复读取，也是一个事务的更新结果影响到另一个事务问题。但是它不仅影响另一个事务查询结果，而且还会使查询语句返回一些不同的行录行。 
    这3个问题危害程度依次为：脏读取最大-->不可重复读取-->幻影行最小。 
 
          1.4事务的属性 
    本节主要介绍将事务策略应用到方法的属性描述，其内容包括事务的传播行为，事务的隔离级别，事务的只读和超时属性。 
    1，事务的传播行为 
        传播行为是事务应用于方法的边界，它定义了事务的建立，暂停等行为属性。 
 
在Spring中共有7种，EJB CMT共6种。 
 
*PROPAGATION_MANDATORY: 
规定了方法必须在事务中运行，否则会抛出异常 
 
*PROPAGATION_NESTED: 
使方法运行在嵌套事务中，否则这个属性和PROPAGATION_REQUIRED属性的义相同 
 
PROPAGATION_NEVER 
使当前方法永远不在事务中运行，否则抛出异常 
 
PROPAGATION_NOT_SUPPORTED 
定义为当前事务不支持的方法，在该方法运行期间正在运行的事务会被暂停 
 
*PROPAGATION_REQUIRED 
规定当前的方法必须在事务中，如果没有事务就创建一个新事务，一个新事务和方法一同开始，随着方法的返回或抛出异常而终止 
 
*PROPAGATION_REQUIRED_NEW 
当前方法必须创建新的事务来运行，如果现存的事务正在运行就暂停它 
 
PROPAGATION_SUPPORTS 
规定当前方法支持当前事务处理，但如果没有事务在运行就使用非事务方法执行 
 
以上定义Spring在事务中的传播行为分别对应EJB的事务CMT中的所有传播行为，其在PROPAGATION_NESTED是Spring在CMT之外定义的事务传播行为。 
 
  
    例如： 
    <property name="transactionAttributes"> 
            <props> 
                <prop key="query*">PROPAGATION_REQUIRED,timeout_5,readOnly</prop> 
                <prop key="insert*">PROPAGATION_REQUIRED</prop> 
                <prop key="delete*">PROPAGATION_REQUIRED</prop> 
            </props> 
        </property>     
 
     
     
    2，事务的隔离级别 
        为解决事务之间的3个缺陷，必须在事务之间建立隔离关系来保证事务的完整性。 
    ISOLATION_DEFAULT         
        使用数据库默认的隔离级别 
    ISOLATION_COMMITTED     
        允许读取其他并发事务已经提交的更新（防此脏读） 
    ISOLATION_READ_UNCOMMITTED 
        允许读取其他并发事务还未提交的更新，会导致事务之                间的3个缺陷发生，这是速度最快的一个隔离级别，但同                时它的隔离级别也是最低 
    ISOLATION_REPEATABLE_READ 
        除非事务自身修改了数据，否则规定事务多次重复读取        数据必须相同（防此脏读，不可重复读） 
    ISOLATION_SERIALIZABLE 
        这是最高的隔离级别，它可以防此脏读，不可重复读和        幻读等问题，但因其侵占式的数据记录完全锁定，导致 
        它影响事务的性能，成为隔离级别中最展慢的一个。 
    注意：并不是所有的资源管理器都支持所有的隔离级别，可针对不同的资源管理使用以上的隔离级别。 
 
 
    3，事务的只读属性 
        在对数据库的操作中，查询是使用最频繁的操作，每次执行查询时都要从数据库中重新读取数据，有时多次读取的数据都是相同的，这样的数据操作不仅浪费了系统资源，还影响了系统速度。对访问量大的程序来说，节省这部分资源可以大大提    升系统速度。 
        如果将事务声明为只读的，那么数据库可以根据事务的特性优化事务的读取操作。事务的只读属性需要配合事务的传播行为共同设置。例如： 
    <prop key="query*">PROPAGATION_REQUIRED,readOnly</prop> 
 
 
 
     
    4，事务的超时属性     
        这个属性和事务的只读属性一样需要搭配事务的传播行为共同设置，它设置了事务的超时时间，事务本身可能会因某种原因很长没有回应，在这期间事务可能锁定了数据库的表格，这样会出现严重的性能问题。通过设置事务的超时时间，从开始执行事务起，在规定的超时时间内如果没有事务就将它回滚。事务的超时属性以timeout_为前缀和一个整型数字定义，例如： 
    <prop key="query*">PROPAGATION_REGUIRED,timeout_5,readOnly</prop> 
 
 
 
     
        1.5Spring的事务管理器 
    Spring的事务管理器有5个，都实现了PlatformTransactionManager接口，如下所示： 
 
DataSourceTransactionManager           JDBC事务管理器 
HibernateTransactionManager            Hibernate事务管理器 
JdoTransactionManager                  JDO事务管理器 
JtaTransactionManager                   JTA事务管理器      
PersistenceBrokerTransactionManager    Apache的OJB事务管理器         
<!-- 配置JDBC事务管理器 --> 
    <bean id="transactionManager" 
        class="org.springframework.jdbc.datasource.DataSourceTransactionManager"> 
        <property name="dataSource"> 
            <ref bean="dataSource"/> 
        </property> 
    </bean> 
 
--------------------------------------------------------- 
 
<!-- 配置HibernateSessionFactory工厂 --> 
    <bean id="sessionFactory" 
        class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"> 
        <property name="dataSource" ref="dataSource" /> 
        <property name="mappingResources"> 
            <list> 
                <value>tarena/hbm/catelog.hbm.xml</value> 
                <value>tarena/hbm/bookinfo.hbm.xml</value> 
                <value>tarena/hbm/userinfo.hbm.xml</value> 
                <value>tarena/hbm/order.hbm.xml</value> 
            </list> 
        </property> 
        <property name="hibernateProperties"> 
            <props> 
                <prop key="hibernate.dialect"> 
                    org.hibernate.dialect.MySQL5Dialect 
                </prop> 
                <prop key="hibernate.query.substitutions"> 
                    true 'Y', false 'N' 
                </prop> 
                <prop key="hibernate.show_sql">true</prop> 
            </props> 
        </property> 
    </bean> 
 
    <!-- 配置Hibernate事务管理器 --> 
    <bean id="transactionManager" 
        class="org.springframework.orm.hibernate3.HibernateTransactionManager"> 
        <property name="sessionFactory" ref="sessionFactory" /> 
    </bean> 
 
 
        1.6声明式事务 
    因为Spring中的事务是基于AOP实现的，而Spring的AOP是以方法为单位的，所以Spring的事务属性就对事务应用到方法上的策略描述，这些属性为：传播行为，隔离级别，只读和超时属性。 
    Spring的声明式事务不涉及组建依赖关系，它通过AOP实现事务管理。Spring本身就是一个容器，相对EJB容器而言，Spring显得更为轻便，在使用Spring的声明式事务时不须编写任何代码，便可通过实现基于容器的事务管理。Spring提供了一些可供选择的辅助类，这些辅助类简化了传统的数据库操作流程，在一定程度上节省了工作量，提高了编码效率，所以推荐使用声明事务。 
 
    1，优化DataSource 
        DriverManagerDataSource数据源，它在每次获得数据连接时都创建一个新的连接对象，完全没有缓冲能力。 
        Spring没有提供连接的实现，因为一些开源项目已经实现了带有连接池功能的数据源，例如Apache Commons DBCP的BasicDataSource数据源。这个数据源不仅提供了缓冲的连接池功能，而且它是一个完全轻量级的数据源。 
    在Spring中的配置方法如下： 
        <bean id="dataSource" 
    class="org.apache.commons.dbcp.BasicDataSource"> 
        <property name="driverClassName"> 
            <value>org.gjt.mm.mysql.Driver</value> 
        </property> 
        <property name="url"> 
<value>jdbc:mysql://localhost:3306/dbname</value> 
        </property> 
        <property name="username"> 
            <value>root</value> 
        </property> 
        <property name="password"> 
            <value>admin</value> 
        </property> 
    </bean> 
 
 
 
    2，使用事务代理工厂 
        事务代理工厂TransactionProxyFactoryBean包括了事务拦截器，目标代理和事务的属性设置，它配置方便，使用灵活，在声明式事务中广泛使用。 
    使用TransactionProxyFactoryBean需要注入它所依赖的事务管理器，设置代理的目标对象，代理对象的生成方式和事务属性。代理对象是在目标对象上生成的包括事物和AOP切面的新对象，这个新的对象用来替代目标对象以支持事物或AOP提供的切面功能。 
    其中对象代理的生成方式可根据CGLIB生成代理，例如： 
    <property name="proxyTargetClass" value="true"/> 
    最后再介绍一个TransactionProxyFactoryBean中如何设置事务的属性。TransactionProxyFactoryBean的transactionAttributes属性用于指定事务的属性，它是一个Properties类型的属性集合，以方法名和事务属性组成键值对，给不同的方法指定不同的事务属性。例如: 
    <prop key="query*">PROPAGATION_REQUIRED,timeout_5,readOnly</prop> 
    方法名作为声明时，可以使用*通配符，上述代码定义对所有以query作前缀的方法，并在定义的事务中完成操作，事务的不同属性之间以","分隔。 
    通过一个实例介绍如何使用TransactionProxyFactoryBean完全成Spring的声明式事务管理。 
 
 
    例子<略> 
 
************************************************************** 
<!-- 配置数据源 --> 
    <bean id="dataSource" 
class="org.apache.commons.dbcp.BasicDataSource"> 
        <property name="driverClassName"> 
            <value>org.gjt.mm.mysql.Driver</value> 
        </property> 
        <property name="url"> 
            <value>jdbc:mysql://localhost:3306/数据库Schema</value> 
        </property> 
        <property name="username"> 
            <value>root</value> 
        </property> 
        <property name="password"> 
            <value>admin</value> 
        </property> 
    </bean> 
 
    <!-- 配置JDBC事务管理器 --> 
    <bean id="transactionManager" 
class="org.springframework.jdbc.datasource.DataSourceTransactionManager"> 
        <property name="dataSource"> 
            <ref bean="dataSource" /> 
        </property> 
    </bean> 
 
    <!-- 配置事件代理工厂 --> 
    <bean id="transactionProxy" 
class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean"> 
        <!-- 要依赖事务管理器 --> 
        <property name="transactionManager"> 
            <ref bean="transactionManager"/> 
        </property> 
         
        <!-- 要依赖目标对象 --> 
        <property name="target"> 
            <bean id="userDAO" class="tarena.dao.UserDAO"> 
                <property name="dataSource"> 
                    <ref bean="dataSource"/> 
                </property> 
            </bean> 
        </property> 
         
        <!-- 要依赖代理方式 --> 
        <property name="proxyTargetClass" value="true"></property> 
         
        <!-- 要依赖事务属性 --> 
        <property name="transactionAttributes"> 
            <props> 
                <prop key="query*">PROPAGATION_REQUIRED,timeout_1,readOnly</prop> 
                <prop key="insert*">PROPAGATION_REQUIRED,timeout_2</prop> 
                <prop key="delete*">PROPAGATION_REQUIRED</prop> 
            </props> 
        </property> 
    </bean> 
如下timeout_0，就会抛出事务异常，意思是查询操作超过0秒便会抛出异常并结束事务。

 

【本文转载自网络，原文连接：http://blog.csdn.net/daoma/article/details/2302245】