spring的传播机制（场景）

淡淡的烟草味﹌ 2022-06-16 10:13 31阅读 0赞

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.  <table> 
         <tbody> 
          <tr> 
           <td style="font-size:1em"><strong>事务管理器实现(org.springframework.*)</strong></td> 
           <td style="font-size:1em"><strong>使用时机</strong></td> 
          </tr> 
          <tr> 
           <td style="font-size:1em">jdbc.datasource.DataSourceTransactionManager</td> 
           <td style="font-size:1em">使用jdbc的抽象以及ibatis支持</td> 
          </tr> 
          <tr> 
           <td style="font-size:1em">orm.hibernate.HibernateTransactionManager</td> 
           <td style="font-size:1em">使用hibernate支持(默认3.0以下版本)</td> 
          </tr> 
          <tr> 
           <td style="font-size:1em">orm.hibernate3.HibernateTransactionManager</td> 
           <td style="font-size:1em">使用hibernate3支持</td> 
          </tr> 
          <tr> 
           <td style="font-size:1em">transaction.jta.JtaTransactionManager</td> 
           <td style="font-size:1em">使用分布式事务（分布式数据库支持）<span style="white-space:pre"> </span> </td> 
          </tr> 
          <tr> 
           <td style="font-size:1em">orm.jpa.JpaTransactionManager</td> 
           <td style="font-size:1em">使用jpa做为持久化工具</td> 
          </tr> 
          <tr> 
           <td style="font-size:1em">orm.toplink.TopLinkTransactionManager</td> 
           <td style="font-size:1em">使用TopLink持久化工具</td> 
          </tr> 
          <tr> 
           <td style="font-size:1em">orm.jdo.JdoTransactionManager<span style="white-space:pre"></span></td> 
           <td style="font-size:1em">使用Jdo持久化工具</td> 
          </tr> 
          <tr> 
           <td style="font-size:1em">jms.connection.JmsTransactionManager</td> 
           <td style="font-size:1em">使用JMS 1.1+</td> 
          </tr> 
          <tr> 
           <td style="font-size:1em">jms.connection.JmsTransactionManager102<span style="white-space:pre"></span></td> 
           <td style="font-size:1em">使用JMS 1.0.2</td> 
          </tr> 
          <tr> 
           <td style="font-size:1em">transaction.jta.OC4JJtaTransactionManager<span style="white-space:pre"></span></td> 
           <td style="font-size:1em">使用oracle的OC4J JEE容器</td> 
          </tr> 
          <tr> 
           <td style="font-size:1em">transaction.jta.WebLogicJtaTransactionManager</td> 
           <td style="font-size:1em">在weblogic中使用分布式数据库</td> 
          </tr> 
          <tr> 
           <td style="font-size:1em">jca.cci.connection.CciLocalTransactionManager</td> 
           <td style="font-size:1em">使用jrping对J2EE Connector Architecture (JCA)和Common Client Interface (CCI)的支持</td> 
          </tr> 
         </tbody> 
        </table>

UML结构图如下

![df199019-1aa2-3e4c-b937-17e94d6b62e2.png][]  
 4、各种事务管理器的定义如下

*   
    
     *  JdbcTransactionManager定义如下
     *  Xml代码   ![收藏代码][icon_star.png]
        
        1.  **<****bean** id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"**>**  
        2.            **<****property** name="dataSource" ref="dataSource"**/>**  
        3.  **</****bean****>**  
        
          
     *  hibernate事务管理器配置如下
     *  Xml代码   ![收藏代码][icon_star.png]
        
        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代码   ![收藏代码][icon_star.png]
        
        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钟事务传播机制
     *  <table> 
         <tbody> 
          <tr> 
           <td style="font-size:1em"><strong>传播行为</strong></td> 
           <td style="font-size:1em"><strong>含义</strong></td> 
          </tr> 
          <tr> 
           <td style="font-size:1em">PROPAGATION_REQUIRED（XML文件中为REQUIRED)</td> 
           <td style="font-size:1em">表示当前方法必须在一个具有事务的上下文中运行，如有客户端有事务在进行，那么被调用端将在该事务中运行，否则的话重新开启一个事务。（<span style="color:rgb(255,0,0)">如果被调用端发生异常，那么调用端和被调用端事务都将回滚</span>）<span style="white-space:pre"></span></td> 
          </tr> 
          <tr> 
           <td style="font-size:1em">PROPAGATION_SUPPORTS(XML文件中为SUPPORTS）</td> 
           <td style="font-size:1em">表示当前方法不必需要具有一个事务上下文，但是如果有一个事务的话，它也可以在这个事务中运行</td> 
          </tr> 
          <tr> 
           <td style="font-size:1em">PROPAGATION_MANDATORY(XML文件中为MANDATORY）</td> 
           <td style="font-size:1em">表示当前方法必须在一个事务中运行，如果没有事务，将抛出异常</td> 
          </tr> 
          <tr> 
           <td style="font-size:1em">PROPAGATION_NESTED(XML文件中为NESTED)</td> 
           <td style="font-size:1em">表示如果当前方法正有一个事务在运行中，则该方法应该运行在一个嵌套事务中，被嵌套的事务可以独立于被封装的事务中进行提交或者回滚。<span style="color:rgb(255,0,0)">如果封装事务存在，并且外层事务抛出异常回滚，那么内层事务必须回滚，反之，内层事务并不影响外层事务。如果封装事务不存在，则同PROPAGATION_REQUIRED的一样</span></td> 
          </tr> 
          <tr> 
           <td style="font-size:1em">PROPAGATION_NEVER（XML文件中为NEVER)<span style="white-space:pre"></span></td> 
           <td style="font-size:1em">表示当方法务不应该在一个事务中运行，如果存在一个事务，则抛出异常</td> 
          </tr> 
          <tr> 
           <td style="font-size:1em">PROPAGATION_REQUIRES_NEW(XML文件中为REQUIRES_NEW）</td> 
           <td style="font-size:1em">表示当前方法必须运行在它自己的事务中。<span style="color:rgb(255,0,0)">一个新的事务将启动，而且如果有一个现有的事务在运行的话，则这个方法将在运行期被挂起，直到新的事务提交或者回滚才恢复执行</span>。</td> 
          </tr> 
          <tr> 
           <td style="font-size:1em">PROPAGATION_NOT_SUPPORTED（XML文件中为NOT_SUPPORTED）<span style="white-space:pre"></span></td> 
           <td style="font-size:1em">表示该方法不应该在一个事务中运行。<span style="color:rgb(255,0,0)">如果有一个事务正在运行，他将在运行期被挂起，直到这个事务提交或者回滚才恢复执行</span></td> 
          </tr> 
         </tbody> 
        </table>
        
          
        
 *  **6、spring中的事务隔离级别**
    
     *  spring的事务隔离级别其实本质上是对SQL92标准的4种事务隔离级别的一种封装，具体参加我的博文：http://kingj.iteye.com/admin/blogs/1675011
     *  spring的事务隔离级别如下表所示
     *  <table> 
         <tbody> 
          <tr> 
           <td style="font-size:1em"><strong>隔离级别<span style="white-space:pre"> </span></strong></td> 
           <td style="font-size:1em"><strong>含义</strong></td> 
          </tr> 
          <tr> 
           <td style="font-size:1em">ISOLATION_DEFAULT</td> 
           <td style="font-size:1em">使用数据库默认的事务隔离级别</td> 
          </tr> 
          <tr> 
           <td style="font-size:1em">ISOLATION_READ_UNCOMMITTED</td> 
           <td style="font-size:1em">允许读取尚未提交的修改，可能导致脏读、幻读和不可重复读</td> 
          </tr> 
          <tr> 
           <td style="font-size:1em">ISOLATION_READ_COMMITTED<span style="white-space:pre"> </span> </td> 
           <td style="font-size:1em">允许从已经提交的事务读取，可防止脏读、但幻读，不可重复读仍然有可能发生</td> 
          </tr> 
          <tr> 
           <td style="font-size:1em">ISOLATION_REPEATABLE_READ<span style="white-space:pre"></span></td> 
           <td style="font-size:1em">对相同字段的多次读取的结果是一致的，除非数据被当前事务自生修改。可防止脏读和不可重复读，但幻读仍有可能发生</td> 
          </tr> 
          <tr> 
           <td style="font-size:1em">ISOLATION_SERIALIZABLE<span style="white-space:pre"> </span> </td> 
           <td style="font-size:1em">完全服从ACID隔离原则，确保不发生脏读、不可重复读、和幻读，但执行效率最低。<span style="white-space:pre"></span></td> 
          </tr> 
         </tbody> 
        </table>
        
          
        
 *  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代码   ![收藏代码][icon_star.png]
        
        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代码   ![收藏代码][icon_star.png]
        
        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代码   ![收藏代码][icon_star.png]
        
        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.  );  
        
         
     *  搭建好的结构如下
     *    
        ![095e5d5a-7f16-3c78-8119-60ddb351d5e7.png][]  
         
     *  Xml代码   ![收藏代码][icon_star.png]
        
        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.    
        16. **<****bean** id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate"**>**  
        17.         **<****property** name="dataSource" ref="ams"**/>**  
        18.     **</****bean****>**  
        
         
 *  在spring包下面建立3个service
 *  BookService
 *  Java代码   ![收藏代码][icon_star.png]
    
    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代码   ![收藏代码][icon_star.png]
    
    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代码   ![收藏代码][icon_star.png]
    
    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代码   ![收藏代码][icon_star.png]
        
        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代码   ![收藏代码][icon_star.png]
            
            1.  @Test  
            2.     **public** **void** testAddBook()**throws** Exception\{  
            3.         BookService bs=(BookService)**this**.getBean("bookService");  
            4.         bs.addBook();  
            5.     \}  
            
             
        3.  addBook()代码
        4.  Java代码   ![收藏代码][icon_star.png]
            
            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代码   ![收藏代码][icon_star.png]
            
            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代码   ![收藏代码][icon_star.png]
            
            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代码   ![收藏代码][icon_star.png]
            
            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代码   ![收藏代码][icon_star.png]
            
            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代码   ![收藏代码][icon_star.png]
            
            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代码   ![收藏代码][icon_star.png]
            
            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，因此找不到事务进行回滚，数据库只添加了一条记录。
        4.    
            ![84f982c6-51a7-3bf2-a673-b29d6464b905.png][]
        5.    
             
    5.  **SUPPORTS**
        
        1.  单个方法 调用时supports行为同NEVER一样，不会创建事务，只是如果有事务，则会加入到当前事务中去，具体的行为下面有分析。
    6.  **NOT\_SUPPORTED**
        
        1.  单个方法被执行时，不会创建事务。如果当前有事务，将封装事务挂起，知道该方法执行完成再恢复封装事务，继续执行。

**二：在了解了单个方法的事务传播机制后，我们来配置多个方法调用之间的传播机制的行为**

*  1、**我们将UserService和BookService中的addUser(),addBook()方法分别配置为REQUIRED，并在addBook()方法中抛出运行时异常。**

*  Xml代码   ![收藏代码][icon_star.png]
    
    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代码   ![收藏代码][icon_star.png]
    
    1.    
    
     *  Java代码   ![收藏代码][icon_star.png]
        
        1.  1、**public** **void** addUser()**throws** Exception \{  
        2.  2、   **this**.bs.addBook();  
        3.  3、   **this**.jdbcTemplate.execute(ADD\_USER);  
        4.      \}  
        
         
     *  Java代码   ![收藏代码][icon_star.png]
        
        1.  4、**public** **void** addBook() **throws** Exception\{  
        2.  5、        **this**.jdbcTemplate.execute(ADD\_BOOK);  
        3.  6、        **throw** **new** RuntimeException("跳出执行");  
        4.      \}  
 *  测试用例如下
 *  Java代码   ![收藏代码][icon_star.png]
    
    1.  @Test  
    2.   **public** **void** testAddUser()**throws** Exception\{  
    3.       UserService us=(UserService)**this**.getBean("userService");  
    4.       us.addUser();  
    5.   \}  
 *  执行前数据库如下
 *    
    ![b21eb004-7752-3534-baf0-b3223ba01db5.png][]  
     
 *  执行后，console控制台输出如下：
 *  Java代码   ![收藏代码][icon_star.png]
    
    1.  \[DEBUG,DataSourceTransactionManager,main\]  
    2.    
    3.  Creating **new** transaction with name \[com.zx.spring.UserService.addUser\]:   
    
    Java代码   ![收藏代码][icon_star.png]
    
    1.  PROPAGATION\_REQUIRED,ISOLATION\_DEFAULT  
    
     上面输出可以知道，spring自动给addUser()方法切入了事务，事务隔离级别为数据库默认级别。
 *  我们再观察控制台输出
 *  Java代码   ![收藏代码][icon_star.png]
    
    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()方法中又抛出了运行时异常，因此事务必须回滚，这由数据库查询可知。
 *    
    ![7ebc1a96-009e-3622-a9b2-d3b5cef0e457.png][]  
     
 *  **如果我们将addBook()方法中抛出的运行时异常改为checked异常的话，会是什么结果呢？**
 *  Java代码   ![收藏代码][icon_star.png]
    
    1.  7、**public** **void** addBook() **throws** Exception\{  
    2.  8、        **this**.jdbcTemplate.execute(ADD\_BOOK);  
    3.  9、        **throw** **new** Exception("跳出执行");  
    4.     \}  
    
     
 *  Java代码   ![收藏代码][icon_star.png]
    
    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()方法被抛出的检查异常终止调用。**
 *    
    ![fce51860-d19d-370b-98ee-529c8a33c220.png][]  
       
      
    ![d304b2b7-b3c2-33fc-b49d-04c1ab3c7ac3.png][]

*  **如果我们给addUser()方法指定rollback-for属性，那么addBook()方法的事务回回滚吗？**
 *  Java代码   ![收藏代码][icon_star.png]
    
    1.  **public** **void** addBook() **throws** Exception\{  
    2.          **this**.jdbcTemplate.execute(ADD\_BOOK);  
    3.          **throw** **new** Exception("跳出执行");  
    4.      \}  
    
     
 *  Java代码   ![收藏代码][icon_star.png]
    
    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代码   ![收藏代码][icon_star.png]
    
    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代码   ![收藏代码][icon_star.png]
        
        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代码   ![收藏代码][icon_star.png]
        
        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代码   ![收藏代码][icon_star.png]
        
        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代码   ![收藏代码][icon_star.png]
        
        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代码   ![收藏代码][icon_star.png]
        
        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代码   ![收藏代码][icon_star.png]
        
        1.  addBook()方法如下，依然抛出(checked-exception)检查异常。  
        
        Java代码   ![收藏代码][icon_star.png]
        
        1.  **public** **void** addBook() **throws** Exception\{  
        2.         **this**.jdbcTemplate.execute(ADD\_BOOK);  
        3.         **throw** **new** RuntimeException("跳出执行");  
        4.     \}  
        
        Java代码   ![收藏代码][icon_star.png]
        
        1.  addUser()方法如下，在方法体中捕获addBook()抛出的异常。如果不捕获异常，addUser()方法将会被终止。  
        
        Java代码   ![收藏代码][icon_star.png]
        
        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代码   ![收藏代码][icon_star.png]
        
        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代码   ![收藏代码][icon_star.png]
            
            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代码   ![收藏代码][icon_star.png]
        
        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代码   ![收藏代码][icon_star.png]
        
        1.  **public** **void** addBook() **throws** Exception\{  
        2.          **this**.jdbcTemplate.execute(ADD\_BOOK);  
        3.      \}  
        
        ** **
     *  执行junit后，控制台输入如下
     *  Java代码   ![收藏代码][icon_star.png]
        
        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表数据为空，事务回滚了  
        ![ed4e5cb8-e173-3d1b-8e06-45b7f99c1534.png][]  
         t\_book表数据也为空，证明内层事务回滚了
     *    
        ![0c80c940-11f5-3bd0-b681-5348d38a7d47.png][]  
         
     *  **由上述结果可知，如果对于一个内嵌事务来说，外层事务的回滚必将导致内层事务回滚。**

*  **5、我们再将addBook()方法的事务传播机制该为REQUIRES\_NEW，来看看会有什么有趣的事情发生？**
    
     *  Xml代码   ![收藏代码][icon_star.png]
        
        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代码   ![收藏代码][icon_star.png]
        
        1.  **public** **void** addUser()**throws** Exception \{  
        2.      **this**.bs.addBook();  
        3.      **this**.jdbcTemplate.execute(ADD\_USER);  
        4.  \}  
        
         
     *  Java代码   ![收藏代码][icon_star.png]
        
        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代码   ![收藏代码][icon_star.png]
        
        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代码   ![收藏代码][icon_star.png]
        
        1.    **public** **void** addUser()**throws** Exception \{  
        2.  1、        **this**.bs.addBook();  
        3.  2、       **this**.jdbcTemplate.execute(ADD\_USER);  
        4.      \}  
        
         
     *  兑换后的代码
     *  Java代码   ![收藏代码][icon_star.png]
        
        1.  **public** **void** addUser()**throws** Exception \{  
        2.        **this**.jdbcTemplate.execute(ADD\_USER);  
        3.        **this**.bs.addBook();  
        4.    \}  
        
         
     *  在来看控制台输出
     *  Java代码   ![收藏代码][icon_star.png]
        
        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代码   ![收藏代码][icon_star.png]
        
        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代码   ![收藏代码][icon_star.png]
        
        1.  **public** **void** addUser()**throws** Exception \{  
        2.      **this**.jdbcTemplate.execute(ADD\_USER);  
        3.      **this**.bs.addBook();  
        4.  \}  
        
         
     *  执行junit后，控制台输出如下
     *  Java代码   ![收藏代码][icon_star.png]
        
        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表数据均为空
     *    
        ![1efe4a00-0024-3a05-895a-8cdfe3937c6b.png][]  
         
     *    
        ![3a6f69dc-f92e-3927-b322-289cf7cd540d.png][]  
         
     *  **由此我们可以知道，对于REQUIRES\_NEW事务传播机制，如果被调用端抛出运行时异常，则被调用端事务回滚，那么调用端的事务到底是回滚还是提交呢？**
        
         *  **如果调用段代码捕获了被调用端抛出的运行时异常，那么调用端事务提交，不回滚**
            
             *  我们将addUser()调用端代码该成如下（捕获addBook()抛出的运行时异常）
             *  Java代码   ![收藏代码][icon_star.png]
                
                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代码   ![收藏代码][icon_star.png]
                
                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代码   ![收藏代码][icon_star.png]
                
                1.  **public** **void** addUser()**throws** Exception \{  
                2.      **this**.jdbcTemplate.execute(ADD\_USER);  
                3.      **this**.bs.addBook();  
                4.  \}  
                
                 
             *  执行junit后，控制台输出如下:
             *  Java代码   ![收藏代码][icon_star.png]
                
                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代码   ![收藏代码][icon_star.png]
        
        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代码   ![收藏代码][icon_star.png]
        
        1.  **public** **void** addUser()**throws** Exception \{  
        2.        **this**.bs.addBook();  
        3.        **this**.jdbcTemplate.execute(ADD\_USER);  
        4.    \}  
        
         
     *  addBook()方法
     *  Java代码   ![收藏代码][icon_star.png]
        
        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代码   ![收藏代码][icon_star.png]
        
        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代码   ![收藏代码][icon_star.png]
        
        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代码   ![收藏代码][icon_star.png]
        
        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代码   ![收藏代码][icon_star.png]
        
        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代码   ![收藏代码][icon_star.png]
        
        1.  **public** **void** addUser()**throws** Exception \{  
        2.       **this**.bs.addBook();  
        3.       **this**.jdbcTemplate.execute(ADD\_USER);  
        4.   \}  
        
         
     *  执行junit后，控制台输出如下
     *  Java代码   ![收藏代码][icon_star.png]
        
        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代码   ![收藏代码][icon_star.png]
        
        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事务管理器的特性，可能会有各种疏忽，希望各位读者拍砖。

[df199019-1aa2-3e4c-b937-17e94d6b62e2.png]: /images/20220616/5f7048410d51479381ba8b7a5a9d5c39.png
[icon_star.png]: /images/20220616/3d08b7eeaf464796ab923ce66b57598c.png
[095e5d5a-7f16-3c78-8119-60ddb351d5e7.png]: /images/20220616/aee66b6b829440c0b3de1d520d4c72c6.png
[84f982c6-51a7-3bf2-a673-b29d6464b905.png]: /images/20220616/9a9bd84937234ee5a9566d89d052f3e8.png
[b21eb004-7752-3534-baf0-b3223ba01db5.png]: /images/20220616/56be22dac280451784fc84d8d6d0d21a.png
[7ebc1a96-009e-3622-a9b2-d3b5cef0e457.png]: /images/20220616/a7f002b2aa2d4c5c8b4aadbc812405d1.png
[fce51860-d19d-370b-98ee-529c8a33c220.png]: /images/20220616/e82b8f14fabf4f46bb44759f413c6ee2.png
[d304b2b7-b3c2-33fc-b49d-04c1ab3c7ac3.png]: /images/20220616/c2676e5ce8c44625a566b694cdefb114.png
[ed4e5cb8-e173-3d1b-8e06-45b7f99c1534.png]: /images/20220616/72b780e28e374440b7d648c06e5ad2ff.png
[0c80c940-11f5-3bd0-b681-5348d38a7d47.png]: /images/20220616/83dcb5754a77429a89557d2451f4a836.png
[1efe4a00-0024-3a05-895a-8cdfe3937c6b.png]: /images/20220616/a8f203b680284e6092f4dd0936c88bc3.png
[3a6f69dc-f92e-3927-b322-289cf7cd540d.png]: /images/20220616/f37b4a2d6c894390a60549640a5caf20.png
[spring]: http://lib.csdn.net/base/javaee