你的位置:首页 > Java教程

[Java教程]spring事务管理


我们都知道spring提供两种管理事务的方式,一种是声明式事务,一种是编程式事务。
Spring的声明式事务管理,基于Spring的AOP,不再需要不停地写commit,rollback,(但Spring仍然没有放弃编程式的事务管理策略)。
Spring的编程式事务管理,为我们提供了一个TransactionTemplate,使用回调机制,将应用代码从样板式的资源获取和释放代码中解放出来,不再有大量的try/catch/finally/try/catch代码块。

 

这两种事务处理方式都非常地优雅,它不需要与任何特定的事务API耦合,并支持多种持久层方案。
(1)声明式事务:基于Spring AOP实现,几乎就是
(2)编程式事务:统一的事务编码风格,几乎是一个模板化的。

 

以下将对这两种事务管理方式进行探讨:

首先探讨一下声明式事务:
我们知道Spring事务管理的核心接口是:
org.springframework.transaction.PlatformTransactionManager
它定义了三个待实现的方法:
(1)public TransactionStatus getTransaction(TransactionDefinition definition);
 //返回当前活动的事务或根据相应的行为创建一个新的事务(可以查阅API理解)
(2)public void commit(TransactionStatus status);//提交事务
(3)public void rollback(TransactionStatus status); //回滚事务

PlatformTransactionManager是一个与特定平台无关的事务操作接口,不同的底层事务平台应通过Spring的Ioc注入相应的事务操作实现类 (这些实现类也不需要我们去完成,Spring已经为我们提供了)。那么我们来看看针对不同的底层持久化平台,我们需要为PlatformTransactionManager接口注入何种实现类:



  1. (1)利用JDBC作为持久层的局部事务:   
  2. <? version="1.0" encoding="utf-8"?>  
  3. <beans "http://www.springframework.org/schema/beans"  
  4.        "http://www.w3.org/2001/
  5.        xsi:schemaLocation="http://www.springframework.org/schema/beans    
  6.        http://www.springframework.org/schema/beans/spring-beans.xsd">  
  7.   
  8. <!-- 定义数据源Bean,使用C3P0数据源 -->  
  9. <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" destroy- method="close">  
  10.     <!-- 指定连接数据库的驱动 -->  
  11.     <property name="driverClass" value="com.mysql.jdbc.Driver"/>  
  12.     <!-- 指定连接数据库的URL -->  
  13.     <property name="jdbcUrl" value="jdbc:mysql:3306//127.0.0.1/ssh"/>  
  14.     <!-- 指定连接数据库的用户名 -->  
  15.     <property name="user" value="root"/>  
  16.     <!-- 指定连接数据库的密码 -->  
  17.     <property name="password" value="123"/>  
  18.     <!-- 指定连接数据库连接池的最大连接数 -->  
  19.     <property name="maxPoolSize" value="40"/>  
  20.     <!-- 指定连接数据库连接池的最小连接数 -->  
  21.     <property name="minPoolSize" value="1"/>  
  22.     <!-- 指定连接数据库连接池的初始化连接数 -->  
  23.     <property name="initialPoolSize" value="1"/>  
  24.     <!-- 指定连接数据库连接池的连接最大空闲时间 -->  
  25.     <property name="maxIdleTime" value="20"/>  
  26. </bean>  
  27.   
  28. <!—定义JDBC数据源的局部事务管理器 -->  
  29. <!-- 使用DataSourceTransactionManager类,该类实现PlatformTransactionManager接口 ,是针对采用数据源连接的特定实现 -->  
  30. <bean id="transactionManager"    
  31.         font-size: 14px;">        DataSourceTransactionManager">  
  32.         <!—DataSourceTransactionManager需要注入一个DataSource的引用-->  
  33.          <property name="dataSource" ref="dataSource"/>  
  34.     </bean>  
  35. </beans>  
  36.   
  37. (2)利用Hibernate作为持久层的局部事务:   
  38. <? version="1.0" encoding="utf-8"?>  
  39. <beans "http://www.springframework.org/schema/beans"  
  40.        "http://www.w3.org/2001/
  41.        xsi:schemaLocation="http://www.springframework.org/schema/beans    
  42.        http://www.springframework.org/schema/beans/spring-beans.xsd">  
  43.     <!-- 定义数据源Bean,使用C3P0数据源 -->  
  44.     <bean id="dataSource" font-size: 14px;">    ComboPooledDataSource" destroy-method="close">  
  45.         <!-- 指定连接数据库的驱动 -->  
  46.         <property name="driverClass" value="com.mysql.jdbc.Driver"/>  
  47.         <!-- 指定连接数据库的URL -->  
  48.         <property name="jdbcUrl" value="jdbc:mysql:3306//127.0.0.1/ssh"/>  
  49.         <!-- 指定连接数据库的用户名 -->  
  50.         <property name="user" value="root"/>  
  51.         <!-- 指定连接数据库的密码 -->  
  52.         <property name="password" value="123"/>  
  53.         <!-- 指定连接数据库连接池的最大连接数 -->  
  54.         <property name="maxPoolSize" value="40"/>  
  55.         <!-- 指定连接数据库连接池的最小连接数 -->  
  56.         <property name="minPoolSize" value="1"/>  
  57.         <!-- 指定连接数据库连接池的初始化连接数 -->  
  58.         <property name="initialPoolSize" value="1"/>  
  59.         <!-- 指定连接数据库连接池的连接最大空闲时间 -->  
  60.         <property name="maxIdleTime" value="20"/>  
  61.     </bean>  
  62.   
  63.     <!-- 定义Hibernate的SessionFactory -->  
  64.     <bean id="sessionFactory" font-size: 14px;">    LocalSessionFactoryBean">  
  65.         <!-- 注入SessionFactory所需的数据源 -->  
  66.         <property name="dataSource" ref="dataSource"/>  
  67.         <!--列出全部映射文件 -->  
  68.         <property name="mappingResources">  
  69.               <list>  
  70.                   <!--列出所有的PO映射文件 -->  
  71.                 <value>org/hnylj/vo/User.hbm.</value>  
  72.               </list>  
  73.         </property>  
  74.           <!-- 定义Hibernate的SessionFactory属性 -->  
  75.         <property name="hibernateProperties">  
  76.             <props>  
  77.                 <!-- 指定Hibernate的连接方言 -->  
  78.                 <prop key="hibernate.dialect">org.hibernate.dialect.    
  79.                 MySQLDialect</prop>  
  80.         </property>  
  81.     </bean>  
  82.   
  83.     <!-- 配置Hibernate的局部事务管理器 -->  
  84.     <!-- 使用HibernateTransactionManager类,该类实现PlatformTransactionManager   
  85.     接口,是针对采用Hibernate持久化连接的特定实现 -->  
  86.     <bean id="transactionManager"    
  87.       font-size: 14px;">      HibernateTransactionManager">  
  88.             <!--注入一个SessionFactorybean的引用 -->  
  89.          <property name="sessionFactory" ref="sessionFactory"/>  
  90.      </bean>  
  91. </beans>  
  92.   
  93. (3)利用Hibernate作为持久层的全局事务:   
  94. <? version="1.0" encoding="utf-8"?>  
  95. <beans "http://www.springframework.org/schema/beans"  
  96.        "http://www.w3.org/2001/
  97.        xsi:schemaLocation="http://www.springframework.org/schema/beans    
  98.        http://www.springframework.org/schema/beans/spring-beans.xsd">  
  99.     <!—定义JNDI数据源Bean -->  
  100.     <bean id="dataSource" font-size: 14px;">    JndiObjectFactoryBean">  
  101.         <!--  容器管理数据源的JNDI -->  
  102.          <property name="jndiName" value="jdbc/jtest"/>  
  103.     </bean>  
  104.     <!--定义Hibernate的SessionFactory -->  
  105.     <bean id="sessionFactory" font-size: 14px;">    LocalSessionFactoryBean">  
  106.         <!-- 注入SessionFactory所需的数据源-->  
  107.         <property name="dataSource" ref="dataSource"/>  
  108.         <!--列出全部映射文件 -->  
  109.         <property name="mappingResources">  
  110.               <list>  
  111.                   <!-- 列出所有的PO映射文件 -->  
  112.                 <value>org/hnylj/vo/User.hbm.</value>  
  113.               </list>  
  114.         </property>  
  115.           <!-- 定义Hibernate的SessionFactory的属性 -->  
  116.         <property name="hibernateProperties">  
  117.              <props>  
  118.                 <!-- 指定Hibernate的连接方言 -->  
  119.                 <prop key="hibernate.dialect">org.hibernate.dialect.    
  120.                 MySQLDialect</prop>  
  121.          </property>  
  122.     </bean>  
  123.     <!-- 使用JtaTransactionManager类,该类实现PlatformTransactionManager接口-->  
  124.     <!-- JtaTransactionManager不需要知道数据源,或任何其他特定资源,   
  125.             因为使用容器的全局事务管理 -->  
  126.     <bean id="transactionManager"    
  127.            font-size: 14px;">           JtaTransactionManager" />  
  128. </beans>  

在上面的配置中,对于采用jdbc,hibernate等,我们只要提供相应的PlatformTransactionManager实现类即可。可见Spring对事务的操作仅仅修改一下配置文件,不需要修改任何实际的代码,就可以在不同的事务管理策略之间切换,非常地方便,Spring为我们提供了高度的解耦。

 

以上就是我们在spring中处理事务所需要的事务管理器的配置,那么在具体的业务处理bean中我们如何控制事务呢?
一般都推荐事务最好做在service层,底层的dao可以不考虑事务,有时设计得不好可能会出现事务的嵌套,增加程序复杂度。而且将事务的处理放在service层中进行,对于我们异常体系的设计也带来好处,service层抛出的异常可以在web捕获,并将异常信息在web页面给用户提示。所以接下来我们就将在service层开始事务,提交事务,回滚事务等。作为声明式事务管理,spring已经帮我们做好了这一切,基本上就是代理模式。

 

以下就是Spring提供的4种事务代理方式:
1.使用TransactionProxyFactoryBean为目标bean生成事务代理,此方式是最传统,也是配置文件最臃肿的一种方式。
2.使用bean继承的事务代理方式,此方式比较简洁,但依然是增量式配置,bean越多配置文件越臃肿。
3.使用BeanNameAutoProxyCreator,根据bean name自动生成事务代理的方式,这是直接利用Spring的AOP框架配置事务代理的方式,需要对Spring的AOP框架有所了解,但也不必成为AOP专家,这种方式避免了增量式配置,也是推荐的方式。
4.使用DefaultAdvisorAutoProxyCreator,这也是直接利用Spring的AOP框架配置事务代理的方式,只是这种配置方式的可读性不如第三种方式。

 

对于第一种:使用TransactionProxyFactoryBean为目标bean生成事务代理:
因为TransactionProxyFactoryBean产生的是代理Bean,所以我们在配置TransactionProxyFactoryBean时,需要指定目标Bean。每个TransactionProxyFactoryBean为一个目标Bean生成事务代理,事务代理的方法改写了目标Bean的方法,就是在目标Bean的方法执行之前加入开始事务,在目标Bean的方法正常结束之前提交事务,如果遇到特定异常则回滚事务。TransactionProxyFactoryBean创建事务代理时,需要了解当前事务所处的环境,该环境属性通过PlatformTransactionManager实例传入,而相关事务传入规则在TransactionProxyFactoryBean的定义中给出。

下面该方法的配置方式:



  1. <? version="1.0" encoding="utf-8"?>  
  2. <beans "http://www.springframework.org/schema/beans"  
  3.        "http://www.w3.org/2001/
  4.        xsi:schemaLocation="http://www.springframework.org/schema/beans    
  5.        http://www.springframework.org/schema/beans/spring-beans.xsd">  
  6.     <!-- 定义数据源Bean,使用C3P0数据源 -->  
  7.     <bean id="dataSource" font-size: 14px;">    ComboPooledDataSource" destroy-method="close">  
  8.         <!-- 指定连接数据库的驱动 -->  
  9.         <property name="driverClass" value="com.mysql.jdbc.Driver"/>  
  10.         <!-- 指定连接数据库的URL -->  
  11.         <property name="jdbcUrl" value="jdbc:mysql:3306//127.0.0.1/ssh"/>  
  12.         <!-- 指定连接数据库的用户名 -->  
  13.         <property name="user" value="root"/>  
  14.         <!-- 指定连接数据库的密码 -->  
  15.         <property name="password" value="123"/>  
  16.         <!-- 指定连接数据库连接池的最大连接数 -->  
  17.         <property name="maxPoolSize" value="40"/>  
  18.         <!-- 指定连接数据库连接池的最小连接数 -->  
  19.         <property name="minPoolSize" value="1"/>  
  20.         <!-- 指定连接数据库连接池的初始化连接数 -->  
  21.         <property name="initialPoolSize" value="1"/>  
  22.         <!-- 指定连接数据库连接池的连接最大空闲时间 -->  
  23.         <property name="maxIdleTime" value="20"/>  
  24.     </bean>  
  25.   
  26.     <!-- 定义Hibernate的SessionFactory -->  
  27.     <bean id="sessionFactory" font-size: 14px;">    LocalSessionFactoryBean">  
  28.         <!-- 注入SessionFactory所需的数据源-->  
  29.         <property name="dataSource" <refref="dataSource"/>  
  30.         <!--列出全部映射文件 -->  
  31.         <property name="mappingResources">  
  32.               <list>  
  33.                   <!--列出所有的PO映射文件 -->  
  34.                 <value>org/hnylj/vo/User.hbm.</value>  
  35.               </list>  
  36.         </property>  
  37.           <!-- 定义Hibernate的SessionFactory属性 -->  
  38.         <property name="hibernateProperties">  
  39.              <props>  
  40.                 <!-- 指定Hibernate的连接方言 -->  
  41.                 <prop key="hibernate.dialect">org.hibernate.dialect.    
  42.                 MySQLDialect</prop>  
  43.              </props>  
  44.         </property>  
  45. </bean>  
  46. <!-- 配置DAO Bean -->  
  47.     <bean id="userDAO" class="org.hnylj.dao.impl.UserDaoImpl">     
  48.         <property name="sessionFactory">     
  49.             <ref bean="sessionFactory" />     
  50.         </property>     
  51.     </bean>     
  52.   
  53.     <!-- 配置Service Bean,该Bean将作为目标Bean使用 -->  
  54.     <bean id="userServiceTarget" class="org.hnylj.service.impl.UserServiceImpl">  
  55.         <!-- 依赖注入userDAO的引用 -->  
  56.         <property name="userDAO" ref="userDAO"/>  
  57.     </bean>  
  58.   
  59.     <!-- 配置Hibernate的事务管理器 -->  
  60.     <!-- 使用HibernateTransactionManager类,该类实现PlatformTransactionManager   
  61.     接口,针对采用Hibernate持久化连接的特定实现 -->  
  62.     <bean id="transactionManager"    
  63.         class="org.springframework.orm.hibernate3.HibernateTransactionManager">  
  64.         <!-- HibernateTransactionManager Bean,它需要依赖注入一个SessionFactory   
  65.         Bean的引用 -->  
  66.         <property name="sessionFactory" ref="sessionFactory"/>  
  67.     </bean>  
  68.   
  69.     <!--  配置userServiceTarget Bean的事务代理 -->  
  70.     <bean id="userService"    
  71.         font-size: 14px;">        TransactionProxyFactoryBean">  
  72.           <!-- 依赖注入PlatformTransactionManager的bean引用,此处使用   
  73.           Hibernate的bean -->  
  74.           <!-- 局部事务器,传入Hibernate事务管理器的引用 -->  
  75.           <property name="transactionManager" ref="transactionManager"/>  
  76.           <!-- 需要生成代理的目标bean -->  
  77.           <property name="target" ref="userServiceTarget"/>  
  78.           <!-- 指定事务属性 -->  
  79.           <property name="transactionAttributes">  
  80.               <props>  
  81.                   <!-- 以下部分为定义事务回滚规则 -->  
  82.                   <prop key="insert*">PROPAGATION_REQUIRED,-MyCheckedException</prop>  
  83.                   <prop key="update*">PROPAGATION_REQUIRED</prop>  
  84.                   <prop key="*">PROPAGATION_REQUIRED,readOnly</prop>  
  85.               </props>  
  86.         </property>  
  87.     </bean>  
  88. </beans>  

关于以上配置文件的几个事务传播规则可以查阅相应的API

程序面向UserServiceImpl类所实现的接口编程,事务处理由Spring为UserServiceImpl类所实现的接口IUserService生成的代理bean来完成。(Spring不仅支持对接口的代理,Spring结合CGLIB还可以为具体类生成代理,在此不做讨论)

 

对于第二种:采用bean继承的事务代理
仔细观察第一种配置方式,我们可以发现,如果配置文件中有多个这样的事务代理Bean,配置文件将变得非常臃肿。所以可以使用Bean继承来简化事务代理的配置。考虑到所有事务代理Bean中,事务代理Bean所使用的事务管理器和事务传播规则大致是相同的,所以我们可以定义一个事务代理bean的模板。
即:



  1. <!-- 定义所有事务代理Bean的模板 -->  
  2. <bean id="txProxyTemplate" abstract="true"  
  3.         font-size: 14px;">        TransactionProxyFactoryBean">  
  4.     <!-- 为事务代理Bean注入生成代理所需的PlatformTransactionManager实例 -->  
  5.     <property name="transactionManager" ref="transactionManager"/>  
  6.         <!-- 定义生成事务代理通用的事务属性 -->  
  7.         <property name="transactionAttributes">  
  8.             <props>  
  9.                 <!-- 所有的方法都应用PROPAGATION_REQUIRED的事务传播规则 -->  
  10.                 <prop key="*">PROPAGATION_REQUIRED</prop>  
  11.             </props>  
  12.     </property>  
  13. </bean>   

接下来让真正的事务代理Bean继承上面的事务模板Bean



  1. <!-- 让事务代理Bean继承模板Bean -->  
  2. <bean id="userService" parent="txProxyTemplate">  
  3.     <!-- 这里是嵌套Bean的配置方式 -->  
  4.     <property name="target">  
  5.         <bean class="org.hnylj.service.impl.userServiceImpl"/>  
  6.     </property>  
  7. </bean>  

我们知道,继承中子类可以复写父类的方法,这里也一样,子Bean重新定义事务属性将覆盖事务代理模板里的事务属性定义:
即:

<!-- 让事务代理bean继承模板Bean -->  

  1. <bean id="userService" parent="txProxyTemplate">  
  2.     <!-- 这里引用已存在的bean的方式来定义目标Bean -->  
  3.     <property name="target" ref ="userServiceTarget"/>  
  4.     <!-- 覆盖事务代理模板bean中的事务属性定义 -->  
  5.     <property name="transactionAttributes">  
  6.         <props>  
  7.             <prop key="get*">PROPAGATION_REQUIRED,readOnly</prop>  
  8.             <prop key="find*">PROPAGATION_REQUIRED,readOnly</prop>  
  9.             <prop key="load*">PROPAGATION_REQUIRED,readOnly</prop>  
  10.          </props>  
  11.     </property>  
  12. </bean>  

可见,采用Bean继承方式定义事务代理的方式,可以很好地简化事务代理的配置,可以避免配置事务代理Bean时的冗余配置。

 

对于第三种:使用BeanNameAutoProxyCreator
使用BeanNameAutoProxyCreator来创建代理时,并不一定是创建事务代理,关键在于传入的拦截器,如果传入事务拦截器,将可自动生成事务代理。

下面是使用BeanNameAutoProxyCreator自动生成事务代理的配置方式:

如果配置文件中仅有两个目标Bean,可能不能很清楚地看出这种自动创建代理配置方式的优势,但如果有更多目标Bean需要自动创建事务代理,则可以很好地体会到这种配置方式的优势:配置文件只需要简单地配置目标Bean,然后在BeanNameAutoProxyCreator配置中增加一行即可。

 

对于第四种:DefaultAdvisorAutoProxyCreator:
这种配置方式与BeanNameAutoProxyCreator自动创建代理的方式非常相似,都是使用bean后处理器为目标bean生成事务代理,区别是前者使用事务拦截器创建代理,后者需要使用Advisor创建事务代理。事实上,采用DefaultAdvisorAutoProxyCreator的事务代理配置方式更加简洁,这个代理生成器自动搜索Spring容器中的Advisor,并为容器中所有的bean创建代理。相对前一种方式,这种方式的可读性不如前一种直观。
使用DefaultAdvisorAutoProxyCreator的配置方式:

<?