spring事务传播机制实例讲解

article/2025/9/21 1:07:18
  1. 对于SQL事务的概念以及ACID性质，可以参见我的另一篇博文 http://kingj.iteye.com/admin/blogs/1675011
  2. spring的管理的事务可以分为如下2类：
    1. 逻辑事务   在spring中定义的事务通常指逻辑事务，提供比物理事务更抽象，方便的事务配置管理，但也基于物理事务
    2. 物理事务  特定于数据库的事务
  3. spring中支持一下2中事务声明方式
    1. 编程式事务  当系统需要明确的，细粒度的控制各个事务的边界，应选择编程式事务
    2. 声明式事务  当系统对于事务的控制粒度较粗时，应该选择申明式事务
    3. 无论你选择上述何种事务方式去实现事务控制，spring都提供基于门面设计模式的事务管理器供选择，如下是spring事务中支持的事务管理器
    4. 事务管理器实现(org.springframework.*)使用时机
      jdbc.datasource.DataSourceTransactionManager使用jdbc的抽象以及ibatis支持
      orm.hibernate.HibernateTransactionManager使用hibernate支持(默认3.0以下版本)
      orm.hibernate3.HibernateTransactionManager使用hibernate3支持
      transaction.jta.JtaTransactionManager使用分布式事务（分布式数据库支持）
      orm.jpa.JpaTransactionManager使用jpa做为持久化工具
      orm.toplink.TopLinkTransactionManager使用TopLink持久化工具
      orm.jdo.JdoTransactionManager 使用Jdo持久化工具
      jms.connection.JmsTransactionManager使用JMS 1.1+
      jms.connection.JmsTransactionManager102 使用JMS 1.0.2
      transaction.jta.OC4JJtaTransactionManager 使用oracle的OC4J JEE容器
      transaction.jta.WebLogicJtaTransactionManager在weblogic中使用分布式数据库
      jca.cci.connection.CciLocalTransactionManager使用jrping对J2EE Connector Architecture (JCA)和Common Client Interface (CCI)的支持

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

UML结构图如下



  4、各种事务管理器的定义如下

  •  
    • JdbcTransactionManager定义如下
    • Xml代码   收藏代码
      1. <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">  
      2.           <property name="dataSource" ref="dataSource"/>  
      3. </bean>  
        
    • hibernate事务管理器配置如下
    • Xml代码   收藏代码
      1. <bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">  
      2.     <property name="sessionFactory" ref="sessionFactory"/><span style="white-space: pre;">                                </span>  
      3. </bean>  
    • hibernate的事务管理器会注入session会话工厂，然后将事务处理委托给当前的transaction对象，事务提交时，调用commit()方法，回滚时调用rollback()方法
    • jpa事务管理器配置如下
    • Xml代码   收藏代码
      1. <bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">  
      2. <span style="white-space: pre;">    </span><property name="entityManagerFactory" ref="entityManagerFactory"/>  
      3. </bean>  
       
    • 其余事务管理器可参见spring in action中说明

  • 5、申明式事务配置
    • spring特有的事务传播行为，spring支持7种事务传播行为，确定客户端和被调用端的事务边界（说得通俗一点就是多个具有事务控制的service的相互调用时所形成的复杂的事务边界控制）下图所示为7钟事务传播机制
    • 传播行为含义
      PROPAGATION_REQUIRED（XML文件中为REQUIRED)表示当前方法必须在一个具有事务的上下文中运行，如有客户端有事务在进行，那么被调用端将在该事务中运行，否则的话重新开启一个事务。（如果被调用端发生异常，那么调用端和被调用端事务都将回滚）
      PROPAGATION_SUPPORTS(XML文件中为SUPPORTS）表示当前方法不必需要具有一个事务上下文，但是如果有一个事务的话，它也可以在这个事务中运行
      PROPAGATION_MANDATORY(XML文件中为MANDATORY）表示当前方法必须在一个事务中运行，如果没有事务，将抛出异常
      PROPAGATION_NESTED(XML文件中为NESTED)表示如果当前方法正有一个事务在运行中，则该方法应该运行在一个嵌套事务中，被嵌套的事务可以独立于被封装的事务中进行提交或者回滚。如果封装事务存在，并且外层事务抛出异常回滚，那么内层事务必须回滚，反之，内层事务并不影响外层事务。如果封装事务不存在，则同PROPAGATION_REQUIRED的一样
      PROPAGATION_NEVER（XML文件中为NEVER) 表示当方法务不应该在一个事务中运行，如果存在一个事务，则抛出异常
      PROPAGATION_REQUIRES_NEW(XML文件中为REQUIRES_NEW）表示当前方法必须运行在它自己的事务中。一个新的事务将启动，而且如果有一个现有的事务在运行的话，则这个方法将在运行期被挂起，直到新的事务提交或者回滚才恢复执行。
      PROPAGATION_NOT_SUPPORTED（XML文件中为NOT_SUPPORTED） 表示该方法不应该在一个事务中运行。如果有一个事务正在运行，他将在运行期被挂起，直到这个事务提交或者回滚才恢复执行

  • 6、spring中的事务隔离级别
    • spring的事务隔离级别其实本质上是对SQL92标准的4种事务隔离级别的一种封装，具体参加我的博文：http://kingj.iteye.com/admin/blogs/1675011
    • spring的事务隔离级别如下表所示
    • 隔离级别 含义
      ISOLATION_DEFAULT使用数据库默认的事务隔离级别
      ISOLATION_READ_UNCOMMITTED允许读取尚未提交的修改，可能导致脏读、幻读和不可重复读
      ISOLATION_READ_COMMITTED 允许从已经提交的事务读取，可防止脏读、但幻读，不可重复读仍然有可能发生
      ISOLATION_REPEATABLE_READ 对相同字段的多次读取的结果是一致的，除非数据被当前事务自生修改。可防止脏读和不可重复读，但幻读仍有可能发生
      ISOLATION_SERIALIZABLE 完全服从ACID隔离原则，确保不发生脏读、不可重复读、和幻读，但执行效率最低。

  • 7、spring事务只读属性
    • spring事务只读的含义是指，如果后端数据库发现当前事务为只读事务，那么就会进行一系列的优化措施。它是在后端数据库进行实施的，因此，只有对于那些有可能启动一个新事务的传播行为（REQUIRED,REQUIRES_NEW,NESTED）的方法来说，才有意义。（测试表明，当使用JDBC事务管理器并设置当前事务为只读时，并不能发生预期的效果，即能执行删除，更新，插入操作）
  • 8、spring的事务超时
    • 有的时候为了系统中关键部分的性能问题，它的事务执行时间应该尽可能的短。因此可以给这些事务设置超时时间，以秒为单位。我们知道事务的开始往往都会发生数据库的表锁或者被数据库优化为行锁，如果允许时间过长，那么这些数据会一直被锁定，影响系统的并发性。
    • 因为超时时钟是在事务开始的时候启动，因此只有对于那些有可能启动新事物的传播行为（REQUIRED,REQUIRES_NEW,NESTED）的方法来说，事务超时才有意义。
  • 9、事务回滚规则
    • spring中可以指定当方法执行并抛出异常的时候，哪些异常回滚事务，哪些异常不回滚事务。
    • 默认情况下，只在方法抛出运行时异常的时候才回滚(runtime exception)。而在出现受阻异常(checked exception)时不回滚事务，这个ejb的回滚行为一致。

    • 当然可以采用申明的方式指定哪些受阻异常像运行时异常那样指定事务回滚。
  • 10、spring申明式事务配置
    • 将aop，tx命名空间添加到当前的spring配置文件头中
    • 定义一个事务AOP通知
    • Xml代码   收藏代码
      1. <tx:advice id="txAdvice" transactionManager="transactionManager">  
      2.      <tx:attributes>  
      3.          <tx:method name="add*" propagation="REQUIRED"/>  
      4.      </tx:attributes>  
      5. </tx:advice><span style="white-space: pre;">  </span>  
    • 定义一个事务切面，即应该在哪些类的哪些方法上面进行事务切入
    • Xml代码   收藏代码
      1. <aop:config>  
      2.     <aop:advisor pointcut="execution(* *..zx.spring.UserService*.*(..))||execution(* *..spring.ServiceFacade.*(..))||execution(* *..spring.BookService.*(..))" advice-ref="txAdvice"/>  
      3. </aop:config>  
       
  • 11、结合具体的代码实现讲解spring的7种事务传播机制效果
    • 准备环境
    • 我们采用JDBC+ORACLE实现具体操作，首先搭建好spring的开发环境，配置好数据源，建立好Test
    • 创建数据库结构,创建一个用户表和Book表
    • Sql代码   收藏代码
      1. CREATE TABLE T_USER(  
      2.     ID INT,  
      3.     NAME VARCHAR2(200)  
      4. );  
      5.   
      6. CREATE TABLE T_BOOK(  
      7.     ID INT ,  
      8.     NAME VARCHAR2(200)  
      9. );  
       
    • 搭建好的结构如下


    •  
    • Xml代码   收藏代码
      1. <!-- 定义数据源 -->  
      2. <bean id="ams" class="com.mchange.v2.c3p0.ComboPooledDataSource"  
      3.         destroy-method="close">  
      4.         <property name="driverClass" value="${jdbc.ams.driver}" />  
      5.         <property name="jdbcUrl" value="${jdbc.ams.url}" />  
      6.         <property name="user" value="${jdbc.ams.username}" />  
      7.         <property name="password" value="${jdbc.ams.password}" />  
      8.         <property name="initialPoolSize" value="${initialSize}" />  
      9.         <property name="minPoolSize" value="${minPoolSize}" />  
      10.         <property name="maxPoolSize" value="${maxActive}" />  
      11.         <property name="acquireIncrement" value="${acquireIncrement}" />  
      12.         <property name="maxIdleTime" value="${maxIdleTime}" />  
      13.     </bean>  
      14.   
      15. <!-- 定义jdbc模板类-->   
      16. <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">  
      17.         <property name="dataSource" ref="ams"/>  
      18.     </bean>  
       
  • 在spring包下面建立3个service
  • BookService
  • Java代码   收藏代码
    1. package com.zx.spring;  
    2.   
    3. import org.springframework.jdbc.core.JdbcTemplate;  
    4.   
    5. public class BookService {  
    6.     public static final String ADD_BOOK="insert into t_book(id,name) values(1,'duck-j2ee')";  
    7.     private JdbcTemplate jdbcTemplate;  
    8.       
    9.     public void addBook() throws Exception{  
    10.         this.jdbcTemplate.execute(ADD_BOOK);  
    11.         throw new RollbackException("跳出执行");  
    12.     }  
    13.   
    14.     public JdbcTemplate getJdbcTemplate() {  
    15.         return jdbcTemplate;  
    16.     }  
    17.   
    18.     public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {  
    19.         this.jdbcTemplate = jdbcTemplate;  
    20.     }  
    21. }  
     
  • UserService
  • Java代码   收藏代码
    1. package com.zx.spring;  
    2.   
    3. import org.springframework.jdbc.core.JdbcTemplate;  
    4.   
    5. public class UserService {  
    6.     public static final String ADD_USER="insert into t_user(id,name) values(1,'duck')";  
    7.       
    8.     private BookService bs;  
    9.     private JdbcTemplate jdbcTemplate;  
    10.       
    11.     public void addUser()throws Exception {  
    12.         this.bs.addBook();  
    13.         this.jdbcTemplate.execute(ADD_USER);  
    14.     }  
    15.   
    16.     public JdbcTemplate getJdbcTemplate() {  
    17.         return jdbcTemplate;  
    18.     }  
    19.   
    20.     public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {  
    21.         this.jdbcTemplate = jdbcTemplate;  
    22.     }  
    23.   
    24.     public BookService getBs() {  
    25.         return bs;  
    26.     }  
    27.   
    28.     public void setBs(BookService bs) {  
    29.         this.bs = bs;  
    30.     }  
    31. }  
     
  • 创建一个ServiceFacade门面，将UserService和BookService包装起来
  • Java代码   收藏代码
    1. package com.zx.spring;  
    2.   
    3. public class ServiceFacade {  
    4.     private BookService bs;  
    5.     private UserService us;  
    6.     public BookService getBs() {  
    7.         return bs;  
    8.     }  
    9.     public void setBs(BookService bs) {  
    10.         this.bs = bs;  
    11.     }  
    12.     public UserService getUs() {  
    13.         return us;  
    14.     }  
    15.     public void setUs(UserService us) {  
    16.         this.us = us;  
    17.     }  
    18.       
    19.     public void addUserBook()throws Exception{  
    20.         bs.addBook();  
    21.         us.addUser();  
    22.     }  
    23. }  
     
    • 上面我们配置了3个service接口，并在spring中配置了申明式事务。
    • Xml代码   收藏代码
      1. <aop:config>  
      2.     <aop:advisor pointcut="execution(* *..zx.spring.UserService*.*(..))||execution(* *..spring.ServiceFacade.*(..))||execution(* *..spring.BookService.*(..))" advice-ref="txAdvice"/>  
      3. </aop:config>  
       
    • 我们在一个pointcut中定义了3个aspectj方式的切入点，即对这3个类的所有方法进行事务切入。
    接下来我们开始配置不同的事务传播机制，来看看效果。

  • 到此，准备工作大功告成，接下来我们来对7中传播机制做一个详细解释。

  • 一 ：我们来对单个方法的事务传播机制进行一个了解
    1. REQUIRED， REQUIRES_NEW
      1. junit代码
      2. Java代码   收藏代码
        1. @Test  
        2.    public void testAddBook()throws Exception{  
        3.        BookService bs=(BookService)this.getBean("bookService");  
        4.        bs.addBook();  
        5.    }  
         
      3. addBook()代码
      4. Java代码   收藏代码
        1. public void addBook() throws Exception{  
        2.       this.jdbcTemplate.execute(ADD_BOOK);  
        3.       throw new RuntimeException("throw runtime exception in outter transaction");  
        4.   }  
         
      5. 执行junit后，控制台如下
      6. Java代码   收藏代码
        1. 1、[DEBUG,JdbcTemplate,main] Executing SQL statement [insert into t_book(id,name) values(1,'duck-j2ee')]  
        2. 2、[DEBUG,DataSourceTransactionManager,main] Initiating transaction rollback  
        3. 3、[DEBUG,DataSourceTransactionManager,main] Rolling back JDBC transaction on Connection [com.mchange.v2.c3p0.impl.NewProxyConnection@a2b392]  
         
      7. 可以知道，当addBook()方法的事务传播机制为REQUIRED， REQUIRES_NEW ，并且抛出运行时异常时，将会回滚事务。
      8. 当addBook()方法抛出受检查的异常时，将不会回滚事务。
      9. addBook()方法如下：
      10. Java代码   收藏代码
        1. public void addBook() throws Exception{  
        2.        this.jdbcTemplate.execute(ADD_BOOK);  
        3.        throw new Exception("throw runtime exception in outter transaction");  
        4.    }  
         
      11. Java代码   收藏代码
        1. 1、[DEBUG,DataSourceTransactionManager,main] Creating new transaction with name [com.zx.spring.BookService.addBook]: PROPAGATION_REQUIRED,ISOLATION_DEFAULT  
        2. 2、[DEBUG,JdbcTemplate,main] Executing SQL statement [insert into t_book(id,name) values(1,'duck-j2ee')]  
        3. 3、[DEBUG,DataSourceTransactionManager,main] Initiating transaction commit  
        4. 4、[DEBUG,DataSourceTransactionManager,main] Committing JDBC transaction on Connection [com.mchange.v2.c3p0.impl.NewProxyConnection@4310d0]  
         
      12. 第3行可知，事务提交，不回滚
    2. MANDATORY
      1. 代码同上所示，只是事务传播机制改为 MANDATORY 
      2. Xml代码   收藏代码
        1. <tx:advice id="txAdvice" transaction-manager="txManager">  
        2.     <tx:attributes>  
        3.         <tx:method name="addUser" propagation="REQUIRED" />  
        4.         <tx:method name="addBook" propagation="MANDATORY"/>  
        5.     </tx:attributes>  
        6. </tx:advice>  
         
      3. 运行junit后，由于单个方法执行没有指定任何事务传播机制，因此抛出异常。
      4. Java代码   收藏代码
        1. org.springframework.transaction.IllegalTransactionStateException: No existing transaction found for transaction marked with propagation 'mandatory'  
        2.     at org.springframework.transaction.support.AbstractPlatformTransactionManager.getTransaction(AbstractPlatformTransactionManager.java:357)  
         
    3. NESTED
      1. NESTED内嵌事务，如果没有外层事务，则新建一个事务，行为同REQUIRED一样
    4. NEVER
      1. NEVER不会以事务方式运行，执行junit代码后，控制台如下
      2. Java代码   收藏代码
        1. 1、[DEBUG,JdbcTemplate,main] Executing SQL statement [insert into t_book(id,name) values(1,'duck-j2ee')]  
        2. 2、[DEBUG,DataSourceUtils,main] Registering transaction synchronization for JDBC Connection  
        3. 3、[DEBUG,DataSourceTransactionManager,main] Should roll back transaction but cannot - no transaction available  
         
      3. 由于发生运行时异常，事务本应该回滚，但是在第三行可以知道，由于事务传播机制为NEVER，因此找不到事务进行回滚，数据库只添加了一条记录。


      5.  
    5. SUPPORTS
      1. 单个方法 调用时supports行为同NEVER一样，不会创建事务，只是如果有事务，则会加入到当前事务中去，具体的行为下面有分析。
    6. NOT_SUPPORTED
      1. 单个方法被执行时，不会创建事务。如果当前有事务，将封装事务挂起，知道该方法执行完成再恢复封装事务，继续执行。


二：在了解了单个方法的事务传播机制后，我们来配置多个方法调用之间的传播机制的行为
  • 1、我们将UserService和BookService中的addUser(),addBook()方法分别配置为REQUIRED，并在addBook()方法中抛出运行时异常。
  • Xml代码   收藏代码
    1. <tx:advice id="txAdvice" transaction-manager="txManager">  
    2.     <tx:attributes>  
    3.         <tx:method name="addUser" propagation="REQUIRED"/>  
    4.         <tx:method name="addBook" propagation="REQUIRED"/>  
    5.     </tx:attributes>  
    6. </tx:advice>   
    Xml代码   收藏代码
    1.   
    • Java代码   收藏代码
      1. 1、public void addUser()throws Exception {  
      2. 2、   this.bs.addBook();  
      3. 3、   this.jdbcTemplate.execute(ADD_USER);  
      4.     }  
       
    • Java代码   收藏代码
      1. 4、public void addBook() throws Exception{  
      2. 5、        this.jdbcTemplate.execute(ADD_BOOK);  
      3. 6、        throw new RuntimeException("跳出执行");  
      4.     }  
  • 测试用例如下
  • Java代码   收藏代码
    1. @Test  
    2.  public void testAddUser()throws Exception{  
    3.      UserService us=(UserService)this.getBean("userService");  
    4.      us.addUser();  
    5.  }  
  • 执行前数据库如下


  •  
  • 执行后，console控制台输出如下：
  • Java代码   收藏代码
    1. [DEBUG,DataSourceTransactionManager,main]  
    2.   
    3. Creating new transaction with name [com.zx.spring.UserService.addUser]:   
    Java代码   收藏代码
    1. PROPAGATION_REQUIRED,ISOLATION_DEFAULT  
     上面输出可以知道，spring自动给addUser()方法切入了事务，事务隔离级别为数据库默认级别。
  • 我们再观察控制台输出
  • Java代码   收藏代码
    1. 1、[DEBUG,DataSourceTransactionManager,main] Acquired Connection [com.mchange.v2.c3p0.impl.NewProxyConnection@1973fc5] for JDBC transaction  
    2. 2、[DEBUG,DataSourceTransactionManager,main] Switching JDBC Connection [com.mchange.v2.c3p0.impl.NewProxyConnection@1973fc5] to manual commit  
    3. 3、[DEBUG,DataSourceTransactionManager,main] Participating in existing transaction  
    4. 4、[DEBUG,JdbcTemplate,main] Executing SQL statement [insert into t_book(id,name) values(1,'duck-j2ee')]  
    5. 5、[DEBUG,DataSourceTransactionManager,main] Participating transaction failed - marking existing transaction as rollback-only  
    6. 6、[DEBUG,DataSourceTransactionManager,main] Setting JDBC transaction [com.mchange.v2.c3p0.impl.NewProxyConnection@1973fc5] rollback-only  
    7. 7、[DEBUG,DataSourceTransactionManager,main] Initiating transaction rollback  
    8. 8、[DEBUG,DataSourceTransactionManager,main] Rolling back JDBC transaction on Connection [com.mchange.v2.c3p0.impl.NewProxyConnection@1973fc5]  
     
  • 第一行jdbc事务管理器从c3p0连接池中获取一个链接
  • 第二行设置jdbc事务提交方式为手动提交
  • 代码执行到方法addUser()中第一行时，由于addUser()方法的事务级别为REQUIRED的因此，事务管理器开始了一个事务。执行到第二行addBook()时，由于addBook()方法的事务传播行为为REQUIRED的，我们知道REQUIRED方式是如果有一个事务，则加入事务中，如果没有，则新建一个事务。由控制台输出的第3行可以知道，addBook方法加入到了addUser方法的事务当中去，接着第4行执行了插入t_book语句，由于addBook()方法在第6行时，抛出了运行时异常，因此当前事务失败，可从控制台输出第5行得知。
  • 由于addUser()和addBook()方法共享了一个事务，在addBook()方法中又抛出了运行时异常，因此事务必须回滚，这由数据库查询可知。


  •  
  • 如果我们将addBook()方法中抛出的运行时异常改为checked异常的话，会是什么结果呢？
  • Java代码   收藏代码
    1. 7、public void addBook() throws Exception{  
    2. 8、        this.jdbcTemplate.execute(ADD_BOOK);  
    3. 9、        throw new Exception("跳出执行");  
    4.    }  
     
  • Java代码   收藏代码
    1. 9、[DEBUG,DataSourceTransactionManager,main] Acquired Connection [com.mchange.v2.c3p0.impl.NewProxyConnection@1973fc5] for JDBC transaction  
    2. 10、[DEBUG,DataSourceTransactionManager,main] Switching JDBC Connection [com.mchange.v2.c3p0.impl.NewProxyConnection@1973fc5] to manual commit  
    3. 11、[DEBUG,DataSourceTransactionManager,main] Participating in existing transaction  
    4. 12、[DEBUG,JdbcTemplate,main] Executing SQL statement [insert into t_book(id,name) values(1,'duck-j2ee')]  
    5. 13、[DEBUG,DataSourceTransactionManager,main] Initiating transaction commit  
    6. 14、[DEBUG,DataSourceTransactionManager,main] Releasing JDBC Connection [com.mchange.v2.c3p0.impl.NewProxyConnection@457d21] after transaction  
     
  • 由控制台输出第13行可以知道，除了addBook()方法中抛出的检查异常被忽略之外，其它的同上面的一致。再看数据库可以知道，addBook()方法和被执行了，addUser()方法被抛出的检查异常终止调用。


  •  

  • 如果我们给addUser()方法指定rollback-for属性，那么addBook()方法的事务回回滚吗？
  • Java代码   收藏代码
    1. public void addBook() throws Exception{  
    2.         this.jdbcTemplate.execute(ADD_BOOK);  
    3.         throw new Exception("跳出执行");  
    4.     }  
     
  • Java代码   收藏代码
    1. <tx:advice id="txAdvice" transaction-manager="txManager">  
    2.    <tx:attributes>  
    3.     <tx:method name="addUser" propagation="REQUIRED" <span style="color: #ff0000;"><span style="color: #888888;">rollback-for="Exception"</span></span>/>  
    4.     <tx:method name="addBook" propagation="REQUIRED"/>  
    5.    </tx:attributes>  
    6. </tx:advice>  
     
  • 控制台输出如下
  • Java代码   收藏代码
    1. 15、[DEBUG,DataSourceTransactionManager,main] Participating in existing transaction  
    2. 16、[DEBUG,JdbcTemplate,main] Executing SQL statement [insert into t_book(id,name) values(1,'duck-j2ee')]  
    3. 17、[DEBUG,DataSourceTransactionManager,main] Initiating transaction rollback  
    4. 18、[DEBUG,DataSourceTransactionManager,main] Rolling back JDBC transaction on Connection [com.mchange.v2.c3p0.impl.NewProxyConnection@121d383]  
     可见，当指定了rollback-for属性时，只要抛出了指定的异常，事务就会回滚。


  • 2、上面我们讨论了两个方法都指定为事务传播机制为REQUIRED，那么我们来改变以下addBook()方的事务传播机制改为NEVER ，来看看它们的效果

    • Xml代码   收藏代码
      1. <tx:advice id="txAdvice" transaction-manager="txManager">  
      2.     <tx:attributes>  
      3.         <tx:method name="addUser" propagation="REQUIRED" />  
      4.         <tx:method name="addBook" propagation="NEVER"/>  
      5.     </tx:attributes>  
      6. </tx:advice>  
       执行Junit测试后发现，控制台输出如下：
    • Java代码   收藏代码
      1. org.springframework.transaction.IllegalTransactionStateException: Existing transaction found for transaction marked with propagation 'never'  
      2.     at org.springframework.transaction.support.AbstractPlatformTransactionManager.handleExistingTransaction(AbstractPlatformTransactionManager.java:399)  
      3.     at org.springframework.transaction.support.AbstractPlatformTransactionManager.getTransaction(AbstractPlatformTransactionManager.java:347)  
      4.     at org.springframework.transaction.interceptor.TransactionAspectSupport.createTransactionIfNecessary(TransactionAspectSupport.java:335)  
       Existing transaction found for transaction marked with propagation 'never',也就是说addBook不应该在事务中运行，但是addUser这个客户端调用者却有一个事务，因此报错。

  • 3、我们接着将addBook()方法的事务传播机制改为MANDATORY
    • Xml代码   收藏代码
      1. <tx:advice id="txAdvice" transaction-manager="txManager">  
      2.     <tx:attributes>  
      3.         <tx:method name="addUser" propagation="REQUIRED" />  
      4.         <tx:method name="addBook" propagation="MANDATORY"/>  
      5.     </tx:attributes>  
      6. </tx:advice>  
      执行junit后，控制台输出如下
    • Java代码   收藏代码
      1. [DEBUG,DataSourceTransactionManager,main] Participating in existing transaction  
      2. [DEBUG,JdbcTemplate,main] Executing SQL statement [insert into t_book(id,name) values(1,'duck-j2ee')]  
      3. [DEBUG,JdbcTemplate,main] Executing SQL statement [insert into t_user(id,name) values(1,'duck')]  
      4. [DEBUG,DataSourceTransactionManager,main] Initiating transaction commit  
      可以知道当前和REQUIRED一样的传播行为。
  • 4、我们将addBook()方法的事务传播机制改为NESTED－内嵌事务，那么传播机制之间会怎么互相影响呢？
    • Xml代码   收藏代码
      1. <tx:advice id="txAdvice" transaction-manager="txManager">  
      2.     <tx:attributes>  
      3.         <tx:method name="addUser" propagation="REQUIRED" />  
      4.         <tx:method name="addBook" propagation="NESTED"/>  
      5.     </tx:attributes>  
      6. </tx:advice>  
      Xml代码   收藏代码
      1. addBook()方法如下，依然抛出(checked-exception)检查异常。  
      Java代码   收藏代码
      1. public void addBook() throws Exception{  
      2.        this.jdbcTemplate.execute(ADD_BOOK);  
      3.        throw new RuntimeException("跳出执行");  
      4.    }  
      Java代码   收藏代码
      1. addUser()方法如下，在方法体中捕获addBook()抛出的异常。如果不捕获异常，addUser()方法将会被终止。  
      Java代码   收藏代码
      1. public void addUser()throws Exception {  
      2.       try {  
      3.           this.bs.addBook();  
      4.       }catch(Exception e) {  
      5.           e.printStackTrace();  
      6.       }  
      7.        this.jdbcTemplate.execute(ADD_USER);  
      8.    }  
      执行junit后，控制台输出如下
    • Java代码   收藏代码
      1. 1、[DEBUG,DataSourceTransactionManager,main] Creating new transaction with name [com.zx.spring.UserService.addUser]: PROPAGATION_REQUIRED,ISOLATION_DEFAULT  
      2. 2、[DEBUG,DataSourceTransactionManager,main] Creating nested transaction with name [com.zx.spring.BookService.addBook]  
      3. 3、[DEBUG,JdbcTemplate,main] Executing SQL statement [insert into t_book(id,name) values(1,'duck-j2ee')]  
      4. 4、[DEBUG,DataSourceTransactionManager,main] Rolling back transaction to savepoint  
      5. 5、[DEBUG,JdbcTemplate,main] Executing SQL statement [insert into t_user(id,name) values(1,'duck')]  
      6. 6、[DEBUG,DataSourceTransactionManager,main] Initiating transaction commit  
      7. 7、[DEBUG,DataSourceTransactionManager,main] Committing JDBC transaction on Connection [com.mchange.v2.c3p0.impl.NewProxyConnection@10e164e]  
         
    • 由上面的输出可以，第一行为执行addUser()方法，事务管理器开始了一个事务，
    • 第二行执行到addBook()方法，由于addBook()方法的事务传播机制为NESTED内嵌事务，因此，开始一个新的事务。
    • 第三行可以知道插入语句，由于addBook()方法内部抛出RuntimeException,因此内部嵌套事务回滚到外层事务创建的保存点。
    • 注意这个地方，我们抛出的是运行时异常，如果我们抛出受检查的异常，那么spring会默认的忽略此异常。下面我会详细阐述。
      • 如果内层事务抛出检查异常，那么外层事务将忽略此异常，但是会产生一个问题。那就是：外层事务使用jdbc的保存点API来实现嵌套事务，
      • 但是数据库不一定支持。我做测试的是oracle数据库，jdbc事务管理器在内层事务抛出检查异常后，将会在内层事务结束后，释放外层事务
      • 创建的保存点，这是时候数据库不一定支持。因此可能会抛出如下异常：
      • Java代码   收藏代码
        1. java.sql.SQLException: 不支持的特性  
        2.     at oracle.jdbc.driver.DatabaseError.throwSqlException(DatabaseError.java:112)  
        3.     at oracle.jdbc.driver.DatabaseError.throwSqlException(DatabaseError.java:146)  
        4.     at oracle.jdbc.driver.DatabaseError.throwSqlException(DatabaseError.java:208)  
         
    • 第五行可以知道，外层事务开始执行，第六行可知外层事务提交。
    • 总结可知：对于NESTED内层事务而言，内层事务独立于外层事务，可以独立递交或者回滚。


    • 如果我们在addUser方法内部抛出一个运行时异常，那么会怎么样呢？
    • Java代码   收藏代码
      1. public void addUser()throws Exception {  
      2.        this.bs.addBook();  
      3.        this.jdbcTemplate.execute(ADD_USER);  
      4.        throw new RuntimeException("throw runtime exception in outter transaction");  
      5.    }  
       
    • Java代码   收藏代码
      1. public void addBook() throws Exception{  
      2.         this.jdbcTemplate.execute(ADD_BOOK);  
      3.     }  
       
    • 执行junit后，控制台输入如下
    • Java代码   收藏代码
      1. 1、[DEBUG,DataSourceTransactionManager,main] Creating new transaction with name [com.zx.spring.UserService.addUser]: PROPAGATION_REQUIRED,ISOLATION_DEFAULT  
      2. 2、[DEBUG,DataSourceTransactionManager,main] Creating nested transaction with name [com.zx.spring.BookService.addBook]  
      3. 3、[DEBUG,JdbcTemplate,main] Executing SQL statement [insert into t_book(id,name) values(1,'duck-j2ee')]  
      4. 4、[DEBUG,DataSourceTransactionManager,main] Releasing transaction savepoint  
      5. 5、[DEBUG,JdbcTemplate,main] Executing SQL statement [insert into t_user(id,name) values(1,'duck')]  
      6. 6、[DEBUG,DataSourceTransactionManager,main] Initiating transaction rollback  
      7. 7、[DEBUG,DataSourceTransactionManager,main] Rolling back JDBC transaction on Connection [com.mchange.v2.c3p0.impl.NewProxyConnection@1622a94]  
       
    • 第一行在addUser()方法执行后，事务管理器创建一个新的事务。
    • 第二上和上面一样，由于addBook()方法是NETSTED的内嵌传播机制，因此新建一个事务。
    • 执行插入，释放保存点。
    • 执行插入t_user插入，但是此时抛出了一个运行时异常，外层事务回滚，那么内层事务是否回滚呢？我们看以下数据库记录。
    • t_user表数据为空，事务回滚了

       t_book表数据也为空，证明内层事务回滚了


    •  
    • 由上述结果可知，如果对于一个内嵌事务来说，外层事务的回滚必将导致内层事务回滚。


  • 5、我们再将addBook()方法的事务传播机制该为REQUIRES_NEW，来看看会有什么有趣的事情发生？
    • Xml代码   收藏代码
      1. <tx:advice id="txAdvice" transaction-manager="txManager">  
      2.     <tx:attributes>  
      3.     <tx:method name="addUser" propagation="REQUIRED" />  
      4.     <tx:method name="addBook" propagation="REQUIRES_NEW"/>  
      5.     </tx:attributes>  
      6. </tx:advice>  
       
    • Java代码   收藏代码
      1. public void addUser()throws Exception {  
      2.     this.bs.addBook();  
      3.     this.jdbcTemplate.execute(ADD_USER);  
      4. }  
       
    • Java代码   收藏代码
      1. public void addBook() throws Exception{  
      2.     this.jdbcTemplate.execute(ADD_BOOK);  
      3.     //throw new RuntimeException("throw runtime exception in outter transaction");  
      4. }  
       
    • 执行junit后，控制台输出如下
    • Java代码   收藏代码
      1. 1、[DEBUG,DataSourceTransactionManager,main] Creating new transaction with name [com.zx.spring.UserService.addUser]: PROPAGATION_REQUIRED,ISOLATION_DEFAULT  
      2. 2、[DEBUG,DataSourceTransactionManager,main] Suspending current transaction, creating new transaction with name [com.zx.spring.BookService.addBook]  
      3. 3、[DEBUG,JdbcTemplate,main] Executing SQL statement [insert into t_book(id,name) values(1,'duck-j2ee')]  
      4. 4、[DEBUG,DataSourceTransactionManager,main] Initiating transaction commit  
      5. 5、[DEBUG,DataSourceTransactionManager,main] Committing JDBC transaction on Connection [com.mchange.v2.c3p0.impl.NewProxyConnection@5b96c2]  
       
    • 由上可知，第一行执行addUser()方法创建一个事务，
    • 第二行阻塞addUser()方法，并创建一个新的事务，执行插入t_book表，提交内层事务和外层事务。
    • 或许有的读者会问，在下面addUser()方法中由于第一行和第二行是顺序执行，因此不能说明说明问题，那么我们将addUser()方法中的1、2行代码调换，在看效果：
    • Java代码   收藏代码
      1.   public void addUser()throws Exception {  
      2. 1、        this.bs.addBook();  
      3. 2、       this.jdbcTemplate.execute(ADD_USER);  
      4.     }  
       
    • 兑换后的代码
    • Java代码   收藏代码
      1. public void addUser()throws Exception {  
      2.       this.jdbcTemplate.execute(ADD_USER);  
      3.       this.bs.addBook();  
      4.   }  
       
    • 在来看控制台输出
    • Java代码   收藏代码
      1. 1、[DEBUG,DataSourceTransactionManager,main] Creating new transaction with name [com.zx.spring.UserService.addUser]: PROPAGATION_REQUIRED,ISOLATION_DEFAULT  
      2. 2、[DEBUG,JdbcTemplate,main] Executing SQL statement [insert into t_user(id,name) values(1,'duck')]  
      3.   
      4. 3、[DEBUG,DataSourceTransactionManager,main] Suspending current transaction, creating new transaction with name [com.zx.spring.BookService.addBook]  
      5. 4、[DEBUG,JdbcTemplate,main] Executing SQL statement [insert into t_book(id,name) values(1,'duck-j2ee')]  
      6. 5、[DEBUG,DataSourceTransactionManager,main] Initiating transaction commit  
      7. 6、[DEBUG,DataSourceTransactionManager,main] Committing JDBC transaction on Connection [com.mchange.v2.c3p0.impl.NewProxyConnection@1b7ae22]  
      8.   
      9. 7、[DEBUG,DataSourceTransactionManager,main] Resuming suspended transaction after completion of inner transaction  
      10. 8、[DEBUG,DataSourceTransactionManager,main] Initiating transaction commit  
      11. 9、[DEBUG,DataSourceTransactionManager,main] Committing JDBC transaction on Connection [com.mchange.v2.c3p0.impl.NewProxyConnection@1fa681c]  
       
    • 由第一、二行可知道正在执行插入t_user表操作，而到第3行中我们可以知道，插入t_user表的事务被挂起，并且新建了一个事务来插入t_book表
    • t_book表插入事务提交后，到第7行可知，前一个事务t_user插入操作被恢复，并提交前一个操作。
  • 如果我们在addBook()方法中抛出运行时异常，来看看会有什么有趣的事情发生？
    • addBook()方法代码如下
    • Java代码   收藏代码
      1. public void addBook() throws Exception{  
      2.      this.jdbcTemplate.execute(ADD_BOOK);  
      3.      throw new RuntimeException("throw runtime exception in outter transaction");  
      4.  }  
       
    • addUser()方法代码如下
    • Java代码   收藏代码
      1. public void addUser()throws Exception {  
      2.     this.jdbcTemplate.execute(ADD_USER);  
      3.     this.bs.addBook();  
      4. }  
       
    • 执行junit后，控制台输出如下
    • Java代码   收藏代码
      1. 1、[DEBUG,DataSourceTransactionManager,main] Creating new transaction with name [com.zx.spring.UserService.addUser]: PROPAGATION_REQUIRED,ISOLATION_DEFAULT  
      2. 2、[DEBUG,JdbcTemplate,main] Executing SQL statement [insert into t_user(id,name) values(1,'duck')]  
      3. 3、[DEBUG,DataSourceTransactionManager,main] Suspending current transaction, creating new transaction with name [com.zx.spring.BookService.addBook]  
      4. 4、[DEBUG,JdbcTemplate,main] Executing SQL statement [insert into t_book(id,name) values(1,'duck-j2ee')]  
      5. 5、[DEBUG,DataSourceTransactionManager,main] Initiating transaction rollback  
      6. 6、[DEBUG,DataSourceTransactionManager,main] Rolling back JDBC transaction on Connection [com.mchange.v2.c3p0.impl.NewProxyConnection@10d0b72]  
      7. 7、[DEBUG,DataSourceTransactionManager,main] Releasing JDBC Connection [com.mchange.v2.c3p0.impl.NewProxyConnection@10d0b72] after transaction  
      8.   
      9. 8、[DEBUG,DataSourceTransactionManager,main] Resuming suspended transaction after completion of inner transaction8、  
      10. 9、[DEBUG,DataSourceTransactionManager,main] Initiating transaction rollback  
      11. 10、[DEBUG,DataSourceTransactionManager,main] Rolling back JDBC transaction on Connection [com.mchange.v2.c3p0.impl.NewProxyConnection@44b361]  
      12. 11、[DEBUG,DataSourceTransactionManager,main] Releasing JDBC Connection [com.mchange.v2.c3p0.impl.NewProxyConnection@44b361] after transaction  
       
    • 第一行可知，执行addUser()方法时，从链接池获取一个新链接，创建一个封装事务，执行t_user表插入。
    • 第三行可知，t_user插入事务被挂起，一直到第7行，插入t_book表事务被回滚
    • 第8行可知，t_user事务恢复，但是此时该封装事务被回滚。我们再看数据库.
    • t_user表数据和t_book表数据均为空


    •  


    •  
    • 由此我们可以知道，对于REQUIRES_NEW事务传播机制，如果被调用端抛出运行时异常，则被调用端事务回滚，那么调用端的事务到底是回滚还是提交呢？
      • 如果调用段代码捕获了被调用端抛出的运行时异常，那么调用端事务提交，不回滚
        • 我们将addUser()调用端代码该成如下（捕获addBook()抛出的运行时异常）
        • Java代码   收藏代码
          1. public void addUser()throws Exception {  
          2.     this.jdbcTemplate.execute(ADD_USER);  
          3.     try {  
          4.         this.bs.addBook();  
          5.     }catch(Exception e) {  
          6.         e.printStackTrace();  
          7.     }  
          8. }  
           
        • 执行junit后，控制台信息如下
        • Java代码   收藏代码
          1. 1、[DEBUG,DataSourceTransactionManager,main] Creating new transaction with name [com.zx.spring.UserService.addUser]: PROPAGATION_REQUIRED,ISOLATION_DEFAULT  
          2. 2、[DEBUG,DataSourceTransactionManager,main] Acquired Connection [com.mchange.v2.c3p0.impl.NewProxyConnection@1bcec19] for JDBC transaction  
          3. 3、[DEBUG,JdbcTemplate,main] Executing SQL statement [insert into t_user(id,name) values(1,'duck')]  
          4.   
          5.   
          6. 4、[DEBUG,DataSourceTransactionManager,main] Suspending current transaction, creating new transaction with name [com.zx.spring.BookService.addBook]  
          7. 5、[DEBUG,DataSourceTransactionManager,main] Acquired Connection [com.mchange.v2.c3p0.impl.NewProxyConnection@ba507b] for JDBC transaction  
          8. 6、[DEBUG,JdbcTemplate,main] Executing SQL statement [insert into t_book(id,name) values(1,'duck-j2ee')]  
          9. 7、[DEBUG,DataSourceTransactionManager,main] Initiating transaction rollback  
          10. 8、[DEBUG,DataSourceTransactionManager,main] Rolling back JDBC transaction on Connection [com.mchange.v2.c3p0.impl.NewProxyConnection@ba507b]  
          11.   
          12.   
          13. 9、[DEBUG,DataSourceTransactionManager,main] Resuming suspended transaction after completion of inner transaction  
          14. 10、java.lang.RuntimeException: throw runtime exception in outter transaction  
          15.     at com.zx.spring.BookService.addBook(BookService.java:11)  
          16. 11、[DEBUG,DataSourceTransactionManager,main] Initiating transaction commit  
          17. 12、[DEBUG,DataSourceTransactionManager,main] Committing JDBC transaction on Connection [com.mchange.v2.c3p0.impl.NewProxyConnection@1bcec19]  
           
        • 由上面的输出可以知道，1－3行从连接池获取一个链接，开始执行插入事务
        • 执行addBook()方法时，因其事务传播属性为REQUIRES_NEW，则将上一个事务阻塞
        • 第6－8行可知，addBook()方法抛出运行时异常，新事务被回滚
        • 第9行恢复执行上一个插入t_user表事务，并捕获到addBook()抛出的异常，自此addUser()方法未抛出任何运行时异常，提交事务。
      • 如果调用端未捕获被调用端抛出的运行时异常，那么调用端事务回滚，不提交
        • 我们将addUser()方法调用端改成如下（不捕获addBook()抛出的运行时异常，直接抛出）
        • Java代码   收藏代码
          1. public void addUser()throws Exception {  
          2.     this.jdbcTemplate.execute(ADD_USER);  
          3.     this.bs.addBook();  
          4. }  
           
        • 执行junit后，控制台输出如下:
        • Java代码   收藏代码
          1. 1、[DEBUG,DataSourceTransactionManager,main] Creating new transaction with name [com.zx.spring.UserService.addUser]: PROPAGATION_REQUIRED,ISOLATION_DEFAULT  
          2. 2、[DEBUG,JdbcTemplate,main] Executing SQL statement [insert into t_user(id,name) values(1,'duck')]  
          3. 3、[DEBUG,JdbcTemplate,main] Executing SQL statement [insert into t_book(id,name) values(1,'duck-j2ee')]  
          4. 4、[DEBUG,DataSourceTransactionManager,main] Initiating transaction rollback  
          5. 5、[DEBUG,DataSourceTransactionManager,main] Rolling back JDBC transaction on Connection [com.mchange.v2.c3p0.impl.NewProxyConnection@63a721]  
          6.   
          7.   
          8. 6、[DEBUG,DataSourceTransactionManager,main] Resuming suspended transaction after completion of inner transaction  
          9. 7、[DEBUG,DataSourceTransactionManager,main] Initiating transaction rollback  
          10. 8、[DEBUG,DataSourceTransactionManager,main] Rolling back JDBC transaction on Connection [com.mchange.v2.c3p0.impl.NewProxyConnection@1706da8]  
           
        • 由上述第1－5行可知，插入t_user表事务被挂起，同时插入t_book事务被回滚，因为抛出了运行时异常。
        • 6－8行插入t_user事务被回滚，因为addUser()方法的事务传播界别为REQUIRED，因此在抛出了运行时异常的情况下，会回滚事务。
      • 那么，为什么会造成上面两种截然不同的结果呢？因为addUser()方法被声明为REQUIRED传播机制，只要它抛出运行时异常，均会回滚事务。


  • 6、  我们再将addBook()方法的事务传播机制该为SUPPORTS，来看看会有什么有趣的事情发生？
    • 将addBook()方法的事务机制改为SUPPORTS
    • Xml代码   收藏代码
      1. <tx:advice id="txAdvice" transaction-manager="txManager">  
      2.     <tx:attributes>  
      3.         <tx:method name="addUser" propagation="REQUIRED" />  
      4.         <tx:method name="addBook" propagation="SUPPORTS"/>  
      5.     </tx:attributes>  
      6. </tx:advice>  
       
    • addUser()方法
    • Java代码   收藏代码
      1. public void addUser()throws Exception {  
      2.       this.bs.addBook();  
      3.       this.jdbcTemplate.execute(ADD_USER);  
      4.   }  
       
    • addBook()方法
    • Java代码   收藏代码
      1. public void addBook() throws Exception{  
      2.        this.jdbcTemplate.execute(ADD_BOOK);  
      3.        throw new RuntimeException("throw runtime exception in outter transaction");  
      4.    }  
       
    • 执行junit后，控制台输出如下
    • Java代码   收藏代码
      1. 1、[DEBUG,DataSourceTransactionManager,main] Creating new transaction with name [com.zx.spring.UserService.addUser]: PROPAGATION_REQUIRED,ISOLATION_DEFAULT  
      2. 2、[DEBUG,DataSourceTransactionManager,main] Participating in existing transaction  
      3. 3、[DEBUG,JdbcTemplate,main] Executing SQL statement [insert into t_book(id,name) values(1,'duck-j2ee')]  
      Java代码   收藏代码
      1. 4、[DEBUG,DataSourceTransactionManager,main] Participating transaction failed - marking existing transaction as rollback-only  
      2. 5、[DEBUG,DataSourceTransactionManager,main] Setting JDBC transaction [com.mchange.v2.c3p0.impl.NewProxyConnection@19e09a4] rollback-only  
      3. 6、[DEBUG,DataSourceTransactionManager,main] Initiating transaction rollback  
      4. 7、[DEBUG,DataSourceTransactionManager,main] Rolling back JDBC transaction on Connection [com.mchange.v2.c3p0.impl.NewProxyConnection@19e09a4]  
       
    • 由第二行可知，addBook()方法的加入到了当前addUser()方法的事务中，第4行可知，addBook()方法抛出运行时异常，此时addUser()方法的事务被标记为rollback，整个事务都
    • 将回滚。如果addUser()方法没有任何事务，那么addBook()方法也不会在事务环境中执行。不管是否抛出异常，sql都将执行。

    • 如果addBook()方法抛出受检查的异常，那么此异常将忽略，整个addUser()方法的事务将提交。addBook()方法也不会尝试去回滚事务
  • 7、  我们再将addBook()方法的事务传播机制该为NOT_SUPPORTED，会怎么样呢？   
    • 将addBook()方法的事务机制该为NOT_SUPPORTED
    • Xml代码   收藏代码
      1. <tx:advice id="txAdvice" transaction-manager="txManager">  
      2.     <tx:attributes>  
      3.     <tx:method name="addUser" propagation="REQUIRED" />  
      4.     <tx:method name="addBook" propagation="NOT_SUPPORTED"/>  
      5.     </tx:attributes>  
      6. </tx:advice>  
       
    • addBook()方法
    • Java代码   收藏代码
      1. public void addBook() throws Exception{  
      2.       this.jdbcTemplate.execute(ADD_BOOK);  
      3.       throw new RuntimeException("throw runtime exception in outter transaction");  
      4.   }  
       
    • addUser()方法
    • Java代码   收藏代码
      1. public void addUser()throws Exception {  
      2.      this.bs.addBook();  
      3.      this.jdbcTemplate.execute(ADD_USER);  
      4.  }  
       
    • 执行junit后，控制台输出如下
    • Java代码   收藏代码
      1. 1、[DEBUG,DataSourceTransactionManager,main] Creating new transaction with name [com.zx.spring.UserService.addUser]: PROPAGATION_REQUIRED,ISOLATION_DEFAULT  
      2. 2、[DEBUG,DataSourceTransactionManager,main] Suspending current transaction  
      3. 3、[DEBUG,JdbcTemplate,main] Executing SQL statement [insert into t_book(id,name) values(1,'duck-j2ee')]  
      4. 4、[DEBUG,DataSourceUtils,main] Fetching JDBC Connection from DataSource  
      5. 5、[DEBUG,DataSourceTransactionManager,main] Should roll back transaction but cannot - no transaction available  
      6.   
      7.   
      8. 6、[DEBUG,DataSourceTransactionManager,main] Resuming suspended transaction after completion of inner transaction  
      9. 7、[DEBUG,DataSourceTransactionManager,main] Initiating transaction rollback  
      10. 8、[DEBUG,DataSourceTransactionManager,main] Rolling back JDBC transaction on Connection [com.mchange.v2.c3p0.impl.NewProxyConnection@137d4a4]  
       
    • 由上可知，第二行是将addUser()方法的事务挂起，开始执行addBook()代码，
    • 第5行可知，addBook()方法抛出运行时异常，需要回滚事务，但是又没有事务来回滚，因此t_book表数据被插入
    • 由于addBook()抛出异常，在addUser()方法中未捕获该异常，因此对addUser()方法的事务传播机制REQUIRED来说，抛出了运行时异常，addUser()方法回滚

    • 如果将addUser()方法该为如下：
    • Java代码   收藏代码
      1. public void addUser()throws Exception {  
      2.     try {  
      3.         this.bs.addBook();  
      4.     }catch(Exception e) {  
      5.         e.printStackTrace();  
      6.     }  
      7.     this.jdbcTemplate.execute(ADD_USER);  
      8. }  
       
    • 那么addUser()方法将会提交，addBook()方法将插入一条数据到t_book表中，

    • 如果addBook()方法抛出了受检查异常，addBook()方法将忽略此异常，不尝试任何事务回滚，同样即使在addUser()方法中不捕获addBook()方法抛出的受检查异常，addUser()方法也会提交事务，而忽略此异常。

今天对spring事务7中传播机制之间的作用进行了一个回顾，这里只涉及了jdbc事务管理器的特性，可能会有各种疏忽，希望各位读者拍砖。


http://chatgpt.dhexx.cn/article/1tdEuxVg.shtml

相关文章

Spring事务及事务传播机制

Spring事务及事务传播机制

一.事务的含义:多个操作封装在一起&#xff0c;要么同时执行成功&#xff0c;一旦有一个操作执行失败&#xff0c;那么全部执行失败。这里给大家举个例子:比如A给B转账50元&#xff0c;而B没有收到这50元&#xff0c;此时A转账B这个操作也需要进行回滚&#xff0c;恢复到A给B没…
阅读更多...
【 Spring 事务传播机制 】

【 Spring 事务传播机制 】

文章目录 一、概念二、为什么需要事务传播机制&#xff1f;三、事务传播机制有哪些&#xff1f;四、Spring 事务传播机制使⽤和各种场景演示4.1 ⽀持当前事务&#xff08;REQUIRED&#xff09;4.2 不⽀持当前事务&#xff08;REQUIRES_NEW&#xff09;4.3 NESTED 嵌套事务4.4 嵌…
阅读更多...
Spring事务与事务传播机制

Spring事务与事务传播机制

目录 1.事务的基本概念 2.Spring事务的实现 3.事务隔离级别 4.事务传播机制 1.事务的基本概念 关于事务的一些基础概念我已经在MYSQL中讲解过了&#xff0c;有不了解的可以移步至此篇文章&#xff1a;MySQL基础——数据库索引与事务_invictusQAQ的博客-CSDN博客 2.Spring…
阅读更多...
Spring事务、事务隔离级别、事务传播机制

Spring事务、事务隔离级别、事务传播机制

Spring事务、事务隔离级别、事务传播机制 一、为什么需要事务&#xff1f;(回顾)二、Spring中事务的实现2.1 MySQL中的事务使用 (回顾)2.2 Spring编程式事务2.3 Spring 声明式事务2.3.1 Transactional 使用2.3.2 Transactional 作用范围2.3.3 Transactional 参数说明2.3.4 注意…
阅读更多...
Spring 事务和事务的传播机制

Spring 事务和事务的传播机制

1.Spring 中事务的实现方式 Spring 中的操作主要分为两类: 编程式事务 (了解) 声明式事务 编程式事务就是手写代码操作事务, 而声明式事务是利用注解来自动开启和提交事务. 并且编程式事务用几乎不怎么用. 这就好比汽车的手动挡和自动挡, 如果有足够的的钱, 大部分人应该都会选…
阅读更多...
【Spring Boot】事务和事务传播机制

【Spring Boot】事务和事务传播机制

文章目录 1. 事务简单介绍2. Spring 中事务的实现2.1 Spring 手动操作事务2.2 Spring 声明式事务 3. Transactional 注解介绍3.1 Transactional 作用范围3.2 Transactional 参数说明3.3 Transactional 出现异常注意事项3.4 Transactional 工作原理 4. 事务隔离级别4.1 事务特性…
阅读更多...
SpringBoot事务传播机制

SpringBoot事务传播机制

Spring的事务传播机制:是指规定当程序中出现了多个方法出现了嵌套调用的时候&#xff0c;事务是如何进行传递的 支持当前事务:要有房子的 不支持当前事务:不许要有房子的 嵌套事务 1)定义:咱们之前所说的事务&#xff0c;都是针对一个方法的&#xff0c;咱们的Spring事务传播机…
阅读更多...
Spring的事务传播机制(通俗易懂)

Spring的事务传播机制(通俗易懂)

概述 Spring的事务传播机制有7种&#xff0c;在枚举Propagation中有定义。 1.REQUIRED PROPAGATION_REQUIRED&#xff1a;如果当前没有事务&#xff0c;就创建一个新事务&#xff0c;如果当前存在事务&#xff0c;就加入该事务&#xff0c;该设置是最常用的默认设置。 Tra…
阅读更多...
Spring中的事务传播机制

Spring中的事务传播机制

目录 前言 1、Spring&#xff08;Spring Boot&#xff09;实现事务 1.1、通过代码的方式手动实现事务 1.2、通过注解Transactional的方式实现声明式事务 1.2.1、实现: 1.2.2、程序中有try-catch时&#xff0c;程序发生异常事务不会回滚 解决方案一&#xff1a;将异常抛出去 …
阅读更多...
事务的7种传播机制和演示

事务的7种传播机制和演示

文章目录 一、事务的传播机制1.1、nested 事务的几点说明&#xff1a; 二、示例2.1、前言&#xff1a;2.2、准备测试方法1&#xff09;创建beans.xml&#xff0c;开启事务2&#xff09;创建实体类和表&#xff08;表创建读者可自定义创建&#xff09;3&#xff09;创建service接…
阅读更多...
事务传播行为

事务传播行为

原文作者&#xff1a;https://blog.csdn.net/soonfly/article/details/70305683 事务传播行为 什么叫事务传播行为&#xff1f;听起来挺高端的&#xff0c;其实很简单。 即然是传播&#xff0c;那么至少有两个东西&#xff0c;才可以发生传播。单体不存在传播这个行为。 事务传…
阅读更多...
[事务] 事务的传播机制

[事务] 事务的传播机制

前言&#xff1a; Spring的事务&#xff0c;也就是数据库的事务操作&#xff0c;符合ACID标准&#xff0c;也具有标准的事务隔离级别。 但是Spring事务有自己的特点&#xff0c;也就是事务传播机制。 所谓事务传播机制&#xff0c;也就是在事务在多个方法的调用中是如何传递的&…
阅读更多...
事物的传播机制

事物的传播机制

目录 1、事务的传播机制 2、测试 2.1、准备测试方法 2.2、事务传播机制的测试 2.2.1、REQUIRED 2.2.2、NOT_SUPPORTED 2.2.3、REQUIRES_NEW 2.2.4、MANDATORY 2.2.5、NEVER 2.2.6、SUPPORTS 2.2.7、NESTED 事务传播机制&#xff1a;就是事务在多个方法的调用中是如何…
阅读更多...
Spring事务传播机制

Spring事务传播机制

目录 一、事务在Spring中是如何运作的 1.1 开启事务(DataSourceTransactionManager.doBegin) 二、Spring的事务传播机制 2.1 子事务的传播机制为REQUIRED 2.2 子事务的传播机制为REQUIRES_NEW 2.3 子事务的传播机制为NESTED 当我们在使用Spring所提供的事务功能时&#x…
阅读更多...
Spring事务传播的7种机制

Spring事务传播的7种机制

Spring 事务传播机制包含以下 7 种&#xff1a; 1. Propagation.REQUIRED&#xff1a;默认的事务传播级别&#xff0c;它表示如果当前存在事务&#xff0c;则加入该事务&#xff1b;如果 当前没有事务&#xff0c;则创建一个新的事务。 2. Propagation.SUPPORTS&#xff1a;如果…
阅读更多...
事务的传播机制

事务的传播机制

目录 1.形象说明&#xff1a; 2.代码演示&#xff1a; 2.1 REQUIRED 2.1.1 验证共用一个事务 2.1.2 验证当前没有事务&#xff0c;就新建一个事务 2.2 SUPPORTS 2.2.1 支持使用当前事务 2.2.2 如果当前事务不存在&#xff0c;则不使用事务 2.3 MANDATORY 2.3.1 支持…
阅读更多...
Spring事务传播机制详解

Spring事务传播机制详解

前言&#xff1a; Spring的事务&#xff0c;也就是数据库的事务操作&#xff0c;符合ACID标准&#xff0c;也具有标准的事务隔离级别。 但是Spring事务有自己的特点&#xff0c;也就是事务传播机制。 所谓事务传播机制&#xff0c;也就是在事务在多个方法的调用中是如何传递的&…
阅读更多...
反射原理详谈

反射原理详谈

什么是反射&#xff1f; 反射是在运行状态中&#xff0c;对于任意一个类&#xff0c;都能够知道这个类的所有属性和方法&#xff1b;对于任意一个对象&#xff0c;都能够调用它的任意一个方法和属性&#xff1b;这种动态获取的信息以及动态调用对象的方法的功能称为 Java 语言…
阅读更多...
Java反射的作用与原理

Java反射的作用与原理

Java反射的作用与原理 定义 反射机制是指在程序的运行状态中&#xff0c;可以构造任意一个类的对象&#xff0c;可以了解任意一个对象所属的类&#xff0c;可以了解任意一个类的成员变量和方法&#xff0c;可以调用任意一个对象的属性和方法。在Java中&#xff0c;只要给定类…
阅读更多...
彻底搞懂java反射技术及其原理

彻底搞懂java反射技术及其原理

概述:反射是java中最强大的技术之一,很多高级框架都用到了反射技术,面试中也是经常问的点,所以搞懂反射非常重要&#xff01; 文章目录 1.反射是什么?2.反射的底层原理3.三种方式获取Class对象4.反射的优缺点5.反射的应用场景6.反射的常用API 1.反射是什么? java反射机制指…
阅读更多...
推荐文章

Copyright @ 2022~2023