spring事务管理

最新推荐文章于 2022-07-19 01:08:34 发布
最新推荐文章于 2022-07-19 01:08:34 发布
阅读量493 收藏
点赞数
分类专栏： J2EE 文章标签： 事务

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

 

这两种事务处理方式都非常地优雅，它不需要与任何特定的事务API耦合，并支持多种持久层方案。
（1）声明式事务：基于Spring AOP实现，几乎就是xml文件的配置
（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接口注入何种实现类：

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

下面该方法的配置方式：

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

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

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

 

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

Xml代码
  1. <!-- 定义所有事务代理Bean的模板 -->  
  2. <bean id="txProxyTemplate" abstract="true"  
  3.         class="org.springframework.transaction.interceptor.   
  4.         TransactionProxyFactoryBean">  
  5.     <!-- 为事务代理Bean注入生成代理所需的PlatformTransactionManager实例 -->  
  6.     <property name="transactionManager" ref="transactionManager"/>  
  7.         <!-- 定义生成事务代理通用的事务属性 -->  
  8.         <property name="transactionAttributes">  
  9.             <props>  
  10.                 <!-- 所有的方法都应用PROPAGATION_REQUIRED的事务传播规则 -->  
  11.                 <prop key="*">PROPAGATION_REQUIRED</prop>  
  12.             </props>  
  13.     </property>  
  14. </bean>   
[xml] view plain copy
  1. <!-- 定义所有事务代理Bean的模板 -->  
  2. <bean id="txProxyTemplate" abstract="true"  
  3.         class="org.springframework.transaction.interceptor.  
  4.         TransactionProxyFactoryBean">  
  5.     <!-- 为事务代理Bean注入生成代理所需的PlatformTransactionManager实例 -->  
  6.     <property name="transactionManager" ref="transactionManager"/>  
  7.         <!-- 定义生成事务代理通用的事务属性 -->  
  8.         <property name="transactionAttributes">  
  9.             <props>  
  10.                 <!-- 所有的方法都应用PROPAGATION_REQUIRED的事务传播规则 -->  
  11.                 <prop key="*">PROPAGATION_REQUIRED</prop>  
  12.             </props>  
  13.     </property>  
  14. </bean>   

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

Xml代码
  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>  
[xml] view plain copy
  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重新定义事务属性将覆盖事务代理模板里的事务属性定义：
即：

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

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

 

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

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

[xml] view plain copy
  1. <?xml version="1.0" encoding="utf-8"?>  
  2. <!-- 指定Spring配置文件的根元素，以及相应的Schema信息 -->  
  3. <beans xmlns="http://www.springframework.org/schema/beans"  
  4.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  5.        xsi:schemaLocation="http://www.springframework.org/schema/beans          
  6. http://www.springframework.org/schema/beans/spring-beans.xsd">  
  7.     <!-- 定义数据源Bean，使用C3P0数据源实现 -->  
  8.     <bean id="dataSource" class="com.mchange.v2.c3p0.   
  9.     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.     <!-- 使用JDBC的局部事务策略 -->  
  28.     <bean id="transactionManager"  
  29.         class="org.springframework.jdbc.datasource.DataSource-  
  30.         TransactionManager">  
  31.         <!-- 为事务管理器注入所需的数据源Bean -->  
  32.         <property name="dataSource" ref="dataSource"/>  
  33.     </bean>  
  34.     <!-- 配置目标Bean，该目标Bean将由Bean后处理器自动生成代理 -->  
  35.     <bean id="userBean" class="org.hnylj.service.impl.UserServiceImpl">  
  36.         <!-- 依赖注入目标Bean所必需的数据源Bean -->  
  37.         <property name="userDAO">    
  38.             <ref bean="userDAO" />    
  39.         </property>    
  40.     </bean>  
  41.   
  42.     <!-- 配置目标Bean，该目标Bean将由Bean后处理器自动生成代理 -->  
  43.     <bean id="personBean" class="org.hnylj.service.impl.PersonServiceImpl">  
  44.         <!-- 依赖注入目标Bean所必需的数据源Bean -->  
  45.         <property name="personDAO">    
  46.             <ref bean="personDAO" />    
  47.         </property>    
  48.     </bean>  
  49.   
  50.     <!-- 配置事务拦截器Bean -->  
  51.     <bean id="transactionInterceptor"  
  52.         class="org.springframework.transaction.interceptor.   
  53.         TransactionInterceptor">  
  54.         <!-- 事务拦截器bean需要依赖注入一个事务管理器 -->  
  55.         <property name="transactionManager" ref="transactionManager"/>  
  56.         <property name="transactionAttributes">  
  57.             <!-- 下面定义事务传播属性 -->  
  58.             <props>  
  59.                 <prop key="insert*">PROPAGATION_REQUIRED</prop>  
  60.                 <prop key="find*">PROPAGATION_REQUIRED,readOnly</prop>  
  61.                 <prop key="*">PROPAGATION_REQUIRED</prop>  
  62.             </props>  
  63.         </property>  
  64.     </bean>  
  65.   
  66.     <!-- 定义BeanNameAutoProxyCreator的Bean后处理器 -->  
  67.     <bean class="org.springframework.aop.framework.autoproxy.   
  68.     BeanNameAutoProxyCreator">  
  69.     <!-- 指定对满足哪些bean name的bean自动生成业务代理 -->  
  70.         <property name="beanNames">  
  71.             <!-- 下面是所有需要自动创建事务代理的Bean -->  
  72.             <list>  
  73.                 <value>userBean</value>  
  74.                 <value>personBean</value>  
  75.             </list>  
  76.             <!-- 此处可增加其他需要自动创建事务代理的Bean -->  
  77.         </property>  
  78.         <!-- 下面定义BeanNameAutoProxyCreator所需的拦截器 -->  
  79.         <property name="interceptorNames">  
  80.             <list>  
  81.                 <value>transactionInterceptor</value>   
  82.                 <!-- 此处可增加其他新的Interceptor -->  
  83.             </list>  
  84.         </property>  
  85.     </bean>  
  86. </beans>  

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

 

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

[xml] view plain copy
  1. <?xml version="1.0" encoding="utf-8"?>  
  2. <!-- 指定Spring配置文件的根元素，以及相应的Schema信息 -->  
  3. <beans xmlns="http://www.springframework.org/schema/beans"  
  4.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  5.        xsi:schemaLocation="http://www.springframework.org/schema/beans          
  6. http://www.springframework.org/schema/beans/spring-beans.xsd">  
  7. <!-- 定义数据源Bean，使用C3P0数据源实现 -->  
  8.     <bean id="dataSource" class="com.mchange.v2.c3p0.   
  9.     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.     <!--定义一个hibernate的SessionFactory-->  
  28. <bean id="sessionFactory"  class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">  
  29.         <!--   定义SessionFactory必须注入DataSource-->  
  30.             <property name="dataSource"><ref local="dataSource"/></property>  
  31.             <property name="mappingResources">  
  32.             <list>  
  33.                 <!--列出所有的PO映射文件-->  
  34.                 <value>org/hnylj/vo/User.hbm.xml</value>  
  35.             </list>  
  36.             </property>  
  37.             <property name="hibernateProperties">  
  38.             <props>  
  39. <!--定义hibernate的SessionFactory的属性-->  
  40.             <prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>  
  41.             </props>  
  42.         </property>  
  43.     </bean>  
  44.     <!-- 定义hibernate的局部事务管理器-->  
  45. <bean id="transactionManager"  
  46.          class="org.springframework.orm.hibernate3.HibernateTransactionManager">  
  47.             <!-- 注入SessionFactory bean的引用-->  
  48.             <property name="sessionFactory"><ref local="sessionFactory"/></property>  
  49. </bean>  
  50.     <!--   配置事务拦截器-->  
  51. <bean id="transactionInterceptor"  
  52. class="org.springframework.transaction.interceptor.TransactionInterceptor">  
  53.         <!--   事务拦截器bean需要依赖注入一个事务管理器 -->  
  54.         <property name="transactionManager" ref="transactionManager"/>  
  55.         <property name="transactionAttributes">  
  56.             <!--   下面定义事务传播属性-->  
  57.             <props>  
  58.                 <prop key="insert*">PROPAGATION_REQUIRED</prop>  
  59.                 <prop key="find*">PROPAGATION_REQUIRED,readOnly</prop>  
  60.                 <prop key="*">PROPAGATION_REQUIRED</prop>  
  61.             </props>  
  62.         </property>  
  63. </bean>  
  64.     <!-- 定义事务Advisor-->  
  65. <bean  class="org.springframework.transaction.interceptor.TransactionAttributeSourceAdvisor">  
  66.         <!--   定义advisor时，必须传入Interceptor-->  
  67.             <property name="transactionInterceptor" ref="transactionInterceptor"/>  
  68.     </bean>  
  69.     <!-- DefaultAdvisorAutoProxyCreator搜索容器中的 advisor,并为每个bean创建代理 -->  
  70. <bean  class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator"/>  
  71. <!--定义DAO Bean ,由BeanNameAutoProxyCreator自动生成事务代理-->  
  72.     <bean id="userService" class="org.hnylj.service.impl.UserServiceImpl">  
  73.         <property name="userDAO"><ref local="userDAO"/></property>  
  74. </bean>  
  75. </beans>   
皓月微风
关注
专栏目录
Spring事务管理的那些事儿（上）
JavaKeeper
12-04 246
写在前面的话：本人开发过一个系统，系统对数据的正确性要求比较高，有个小模块中一次性会向数据库插入1万条左右的数据，在插入这一万条左右的数据的同时还要更新数据库中与此1万条数据相同的数据的某个状态值，更新出错或插入出错，都要回滚并终止执行。这就是一个典型的事务处理问题。   很早就接触到了Spring，通过时间的推移和实际项目的运用，对Spring的认识也渐渐增多，有了一些体会和感悟。 下面...
【web】Spring中使用DataSourceTransactionManager手动提交或回滚事务
三言两语
01-08 1万+
在使用spring进行web开发时，虽然spring提供的注解方式可以方便的处理很多原来需要手动提交或回滚的事务，但是注解方式有自己使用的局限，比如在类的内部调用方法时，注解方式处理的事务就无法被触发，此时可能需要手动处理相关数据库的事务。本文记录在spring开发时使用Spring提供的DataSourceTransactionManager进行事务提交或回滚处理。主要步骤如下： 1、注入Da
Spring事务
weixin_42196338的博客
07-19 263
某些异常默认不会参与回滚，因此当出现这样的异常时，也会出现不同步的问题（即使开启了事务），因此对于特定的一些异常需要在注解中增加roolback=异常.class，才能实现事务正常。可以看出，现在我们需要LogService中的方法，不在事务T之中，它在独立的一个事务中。在注解@Transactional(roolback=xxx.class)但此时，这三个数据层的方法处于同一个事务，同成功同失败，不符合需求。增加了一个LogService。...
Spring中使用DataSourceTransactionManager手动提交或回滚事务
yxhxj2006的专栏
03-21 1万+
      在使用spring进行web开发时，虽然spring提供的注解方式可以方便的处理很多原来需要手动提交或回滚的事务，但是注解方式有自己使用的局限，比如在类的内部调用方法时，注解方式处理的事务就无法被触发，此时可能需要手动处理相关数据库的事务。本文记录在spring开发时使用Spring提供的DataSourceTransactionManager进行事务提交或回滚处理。主要步骤如下：1、...
【Spring笔记-7】-spring完全注解开发实现事务管理
m0_64337991的博客
01-12 1035
spring完全注解开发实现事务管理以及@Transactional中的参数
Spring事务管理Demo
05-01
Spring事务管理的目的是确保数据的一致性和完整性，尤其是在多操作、多资源的环境中。本Demo将深入探讨Spring如何实现事务的管理。 首先，Spring提供了两种主要的事务管理方式：编程式事务管理和声明式事务管理。 ...
Spring 事务管理
03-24
Spring 事务管理，Spring 事务管理，Spring 事务管理，Spring 事务管理
spring事务管理1
08-08
Spring事务管理确保每个事务都是独立的，防止了脏读、不可重复读和幻读等问题。脏读是指事务T1读取了事务T2未提交的修改；不可重复读是指事务T1在不同时间读取同一数据时得到不同结果，因为T2在这期间做了修改；幻读...
Spring事务管理（详解+实例）
热门推荐
Trigl的博客
03-25 8万+
写这篇博客之前我首先读了《Spring in action》，之后在网上看了很多关于Spring事务管理的文章，具体参考文章如下： 1、将相应的接口依赖图理清出 2、将每个类的具体配置弄明白 3、将具体的配置给出来 4、给出具体的例子（一个声明式的一个编程式的）
Spring技术内幕——DataSourceTransactionManager
qqqqq1993qqqqq的博客
09-17 1万+
Spring的事务处理中，通用的事务处理流程框架是由抽象事务管理器AbstractPlatformTransactionManager来提供的，而具体的底层事务处理实现，由PlatformTransactionManager的具体实现类来实现，如 DataSourceTransactionManager 、JtaTransactionManager和 HibernateTransactionMan
Spring事务Transaction配置的五种注入方式详解
云淡风轻、仅此一抹
06-04 6万+
Spring事务Transaction配置的五种注入方式详解 http://www.zuidaima.com/share/1828220435860480.htm
spring数据源的注入、JdbcTemplate管理、编程式的事务管理DataSourceTransactionManager
dlgdlg_2008的专栏
01-18 1万+
spring数据源的注入、JdbcTemplate管理、编程式的事务管理DataSourceTransactionManager 2010-06-14 22:00 对于不同的数据库连接来源需求，spring提供了javax.sql.DataSource注入，更换数据来源只要在Bean定义中修改配置，而不用修 改任何一行代码。 应不同的系统，可能使用不同的数据来源，例如：jdb
DataSourceTransactionManager进行事务管理
weixin_30693183的博客
03-21 1311
　　最近在做报表excel导入插入数据的时候，插入数据之前要清除当前用户和报告期下的数据，删除后执行错误导致删除运行，接口报错， redis中获取的数据没有刷新，导致再次执行其他操作时报错。 　　在这里用到DataSourceTransactionManager进行事务管理，可能需要多条sql完成对数据库的操作，比如账户登录，需要匹配用户名和密码，然后要增加积分，还要记录登录的ip和时间，这可...
DataSourceTransactionManager手动提交事务和回滚事务
weixin_33725126的博客
06-24 1378
注入 @Autowiredprivate DataSourceTransactionManager transactionManager; TransactionStatus transactionStatus = transactionManager.getTransaction(new DefaultTransactionDefinition());try{　　//dosomething ...
深入MyBatis-配置文件-dataSource&Transaction
ifendou123456的专栏
05-16 557
mybatis数据源dataSource创建 在使用mybatis时，配置数据源是不可缺少的配置项，如下的配置： <environments default="development"> <environment id="development"> <transactionManager type="JDBC" /> <dataSource type="UNPOOLED"> <!-- <proper
Spring 03
xhyxxx的博客
06-15 357
1 spring day02回顾  AOP ：切面编程 切面：切入点 和 通知 结合  spring aop 编程<aop:config> 方法1： <aop:pointcut expression="切入点表达式" id=""> <aop:advisor advice-ref="通知引用" pointcut-ref="切入点的引用">方法2： <aop:advi
详解spring中的事务管理（编程式的事务管理，声明式的事务管理）
qq_41942241的博客
11-15 241
spring提供的事务管理API 1. PlatformTransactionManager:平台事务管理器. commit(TransactionStatus status) getTransaction(TransactionDefinition definition) rollback(TransactionStatus status) 2. TransactionDefini...
Spring系列之 (十三)：Spring事务管理方式综述
changhenshui1990的博客
03-22 196
Spring配置文件中关于事务配置总是由三个组成部分，分别是DataSource、TransactionManager和代理机制这三部分，无论哪种配置方式，一般变化的只是代理机制这部分。DataSource、TransactionManager这两部分只是会根据数据访问方式有所变化，比如使用Hibernate进行数据访问 时，DataSource实际为SessionFactory，Transact...
Spring事务管理详解与实例
"这篇博客详细介绍了Spring事务管理的相关知识，包括初步理解、事务的ACID特性、传播行为和事务配置等内容，并提供了实例分析。作者在撰写前参考了《spring in action》和其他网络资源，旨在全面解析Spring事务管理...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值