spring 嵌套事务(Nested Transaction) 和新建事务测试

小鱼儿 2021-06-10 20:42 954阅读 0赞

nested提交是依赖外层requires提交后才提交的。  
requires\_new 自己就能提交。  
nested跟复杂的时候会更有用处

查询Nested Transaction细节时，经典例子 serviceA 调用 serviceB，当SeviceB事务传播属性为NESTED时，serviceA

只要catch住了Exception就能保证调用serviceB之前的操作提交而不受ServiceB异常的影响，但是如果

REQUIRES\_NEW时，serviceA和serviceB相对独立，serviceB有异常会不影响serviceA.下面测试。

我用的是(maven dependencies里主要版本号)spring3.11 + jpa2.0 + hibernate4.13.后来运行的时候发现有异常：

JpaDialect does not support savepoints - check your JPA provider's capabilities

Java代码   ![收藏代码][icon_star.png]

1.  **private** SavepointManager getSavepointManager() \{  
2.      **if** (!isSavepointAllowed()) \{  
3.           **throw** **new** NestedTransactionNotSupportedException(  
4.              "Transaction manager does not allow nested transactions");  
5.      \}  
6.      SavepointManager savepointManager = getEntityManagerHolder().getSavepointManager();  
7.      **if** (savepointManager == **null**) \{  
8.           **throw** **new** NestedTransactionNotSupportedException(  
9.              "JpaDialect does not support savepoints - check your JPA provider's capabilities");  
10.     \}  
11.     **return** savepointManager;  
12. \}

jpa transaction manager 不支持 nested transaction，但JpaTransactionManager的属性nestedTransactionAllowed默认为true，如下。

Java代码   ![收藏代码][icon_star.png]

1.  **public** JpaTransactionManager() \{  
2.      setNestedTransactionAllowed(**true**);  
3.  \}

后来才知道Hibernate也不支持Nested Transaction，测试不了，只能用jdbc事务了，使用JdbcTemplate。

换成jdbc后的主要配置：

Xml代码   ![收藏代码][icon_star.png]

1.  **<****context:component-scan** base-package="cn.xx.xx" **/>**  
2.  **<****bean** id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"**>**  
3.      **<****property** name="dataSource" ref="dataSource"**>****</****property****>**  
4.  **</****bean****>**  
5.  **<****tx:annotation-driven**  transaction-manager="transactionManager"**/>**   
6.  **<****bean** id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate"**>**  
7.      **<****property** name="dataSource" ref="dataSource"**>****</****property****>**  
8.  **</****bean****>**  
9.  **<****bean** id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"  destroy-method="close"**>**  
10.     **<****property** name="driverClassName" value="com.mysql.jdbc.Driver" **/>**  
11.     **<****property** name="url" value="jdbc:mysql://localhost:3306/hibernatetest" **/>**  
12.     **<****property** name="username" value="userName" **/>**  
13.     **<****property** name="password" value="password" **/>**  
14. **</****bean****>**

test case 主要相关代码：

Java代码   ![收藏代码][icon_star.png]

1.  **public** **void**  testInvoke()\{  
2.      InvokeService ins = (InvokeService) appContext.getBean("invokeServive");  
3.      //ins.invokeTest();  
4.      ins.jdbcInvokeTest();  
5.      System.out.println("test invoke end");  
6.  \}

invokeservice：

Java代码   ![收藏代码][icon_star.png]

1.  @Service("invokeServive")  
2.  **public** **class** InvokeService \{  
3.    
4.      **private** InvokeServiceA serviceA;  
5.      **private** InvokeServiceB serviceB;      
6.        
7.      **public** InvokeServiceA getServiceA() \{  
8.          **return** serviceA;  
9.      \}  
10.     @Autowired  
11.     **public** **void** setServiceA(InvokeServiceA serviceA) \{  
12.         **this**.serviceA = serviceA;  
13.     \}  
14.       
15.     **public** InvokeServiceB getServiceB() \{  
16.         **return** serviceB;  
17.     \}  
18.     @Autowired  
19.     **public** **void** setServiceB(InvokeServiceB serviceB) \{  
20.         **this**.serviceB = serviceB;  
21.     \}  
22.       
23.     @Transactional(propagation=Propagation.REQUIRED)  
24.     **public** **void** jdbcInvokeTest()\{  
25.         serviceB.jdbcValidInsert();  
26.         **try**\{  
27.             serviceA.jdbcExceptionInsert();  
28.         \}**catch** (Exception e) \{  
29.             System.out.println("excetpion hander");  
30.         \}  
31.         System.out.println("jdbc invoke method end.");  
32.     \}  
33.       
34. \}

serviceB.jdbcValidInsert():

Java代码   ![收藏代码][icon_star.png]

1.  //@Transactional(propagation=Propagation.REQUIRES\_NEW)  
2.  @Transactional(propagation=Propagation.REQUIRED)  
3.  //@Transactional(propagation=Propagation.NESTED)  
4.  **public** **void** jdbcValidInsert()\{  
5.      comDao.jdbcValidInsertTest();  
6.  \}

serviceA.jdbcExceptionInsert():

Java代码   ![收藏代码][icon_star.png]

1.  //@Transactional(propagation=Propagation.REQUIRED)  
2.  //@Transactional(propagation=Propagation.REQUIRES\_NEW)  
3.  @Transactional(propagation=Propagation.NESTED)  
4.  **public** **void** jdbcExceptionInsert()\{  
5.      comDao.jdbcExceptionInsertTest();  
6.  \}

comDao相关方法（ 表User（id,password,userName）,这里使之抛运行时异常，因为checked异常没有特殊

指定rollback处理的话，是不会理会异常而导致数据都正常提交。）：

Java代码   ![收藏代码][icon_star.png]

1.  **public** **void** jdbcExceptionInsertTest()\{  
2.      jdbcTemplate.execute("insert into User(password,userName) values ('pwd','excepNor')");  
3.      jdbcTemplate.execute("insert into User(oopassword,userName) values ('pwd','exception')");  
4.  \}  
5.        
6.  **public** **void** jdbcValidInsertTest()\{  
7.      jdbcTemplate.execute("insert into User(password,userName) values ('pwd','valid')");  
8.  \}  
9.

运行结果：

控制台

excetpion hander  
         jdbc invoke method end.  
         test invoke end

数据库，一条 (pwd，valid)的记录。

没问题，jdbcExceptionInsertTest() 执行第二条时异常，DataSourceTransactionManager使数据库回滚到第一条执行

以前的savepoint，向上throw exception，被catch住，打印出excetpion hander，接着执行打印jdbc invoke method

end. 这时候事务要提交了，因为 serviceB.jdbcValidInsert()是required，所以一起commit，事务结束。

测试二：

将try catch去掉：

Java代码   ![收藏代码][icon_star.png]

1.  @Transactional(propagation=Propagation.REQUIRED)  
2.  **public** **void** jdbcInvokeTest()\{  
3.      serviceB.jdbcValidInsert();  
4.      //try\{   
5.          serviceA.jdbcExceptionInsert();  
6.      //\}catch (Exception e) \{   
7.      //  System.out.println("excetpion hander");  
8.          //\}  
9.      System.out.println("jdbc invoke method end.");  
10. \}

运行结果：

控制台：errors：org.springframework.jdbc.BadSqlGrammarException: StatementCallback; bad SQL grammar

数据库：没有数据

jdbcExceptionInsertTest() 执行第二条时异常，回滚后没有被hold住，导致“jdbc invoke method end”没来及执行直

接退出，事务管理器回滚jdbcValidInsertTest执行的结果，然后commit。

测试三，只将jdbcExceptionInsert改为requires new，注意 try catch还是注释掉的状态：

Java代码   ![收藏代码][icon_star.png]

1.  //@Transactional(propagation=Propagation.REQUIRED)  
2.  @Transactional(propagation=Propagation.REQUIRES\_NEW)  
3.  //@Transactional(propagation=Propagation.NESTED)  
4.  **public** **void** jdbcExceptionInsert()\{  
5.      comDao.jdbcExceptionInsertTest();  
6.  \}

运行结果：

控制台：errors：org.springframework.jdbc.BadSqlGrammarException: StatementCallback; bad SQL grammar

数据库：没有数据

本来我原这么理解requires new，就是总是新启事务，很独立，跟其他人无关，也就是有异常，自己回滚自己的，不影响

他人，如jdbcExceptionInsert回滚自身做的所有操作，但是的的确确它影响到了和他平级的事务，数据库没有数据就是证

明，他在遇到异常后，回滚他的所有操作，commit，然后throw 异常，上层没hold住，jdbcInvokeTest结束执行，故没

有打印输出，事务管理器回滚serviceB.jdbcValidInsert()的操作，然后commit。这也就意味着在没有try catch时他的行

为和 nested时候是一样的。 那catch的时候会怎么样呢？

测试四，打开try catch：

Java代码   ![收藏代码][icon_star.png]

1.  @Transactional(propagation=Propagation.REQUIRED)  
2.  **public** **void** jdbcInvokeTest()\{  
3.      serviceB.jdbcValidInsert();  
4.      **try**\{  
5.          serviceA.jdbcExceptionInsert();  
6.      \}**catch** (Exception e) \{  
7.          System.out.println("excetpion hander");  
8.      \}  
9.      System.out.println("jdbc invoke method end.");  
10. \}

运行结果：

控制台：

excetpion hander  
         jdbc invoke method end.  
         test invoke end

数据库：一条数据（pwd,valid）

证明和nested相对应的情况仍然一致，按我的理解 requires new 就是一个独立王国，如果有异常，即使上层不catch应该

也不影响上层的正常操作的提交，事实却不是，是不是感觉 那要requires new 有什么用呢，这种情况requires new 和

nested确实是可以互相替换。但是如果想把InvokeServiceB的jdbcValidInsert首先提交不受后续操作影响，REQUIRES

NEW就很管用，此时 即使后续操作异常不catch,前面操作因先commit了而不受影响，（pwd,valid）会正常插入。

测试五，将jdbcExceptionInsert()改成required。

Java代码   ![收藏代码][icon_star.png]

1.  @Transactional(propagation=Propagation.REQUIRED)  
2.  //@Transactional(propagation=Propagation.REQUIRES\_NEW)  
3.  //@Transactional(propagation=Propagation.NESTED)  
4.  **public** **void** jdbcExceptionInsert()\{  
5.      comDao.jdbcExceptionInsertTest();  
6.  \}

运行结果：

控制台：errors,org.springframework.transaction.UnexpectedRollbackException: Transaction rolled back

because it has been marked as rollback-only

excetpion hander  
        jdbc invoke method end.

数据库：没有数据。

required说明jdbcExceptionInsert是上层的一部分，回滚的时候会回滚到serviceB.jdbcValidInsert()执行前的

savepoint，抛出的异常被捕获，输出"excetpion hander"，jdbcInvokeTest()接着执行，输出"jdbc invoke

method end." 事务commit，因为事务被底层标志rollback-only，应该是此时回滚(也许是异常发生时)并throw

出异常，所以testInvoke()里的"test invoke end"没机会执行。这里transaction manager貌似个过滤器，最后

根据是否是受检查异常去决定是否回滚，根据是否回滚决定是否再抛出异常。

由测试知道上述情况下nested和requires new可以互换，并且requires new 是又用的，那么又问题又回来了，nested

存在的意义呢，它能在什么情况下不可替代呢，按我现在理解是不是这个只有在某个极端情况下出现呢，虽然没做多少年