Spring事务传播特性的浅析

男娘i 2022-07-11 08:42 208阅读 0赞

Spring事务传播机制回顾   
  
  
   Spring事务一个被讹传很广说法是：一个事务方法不应该调用另一个事务方法，否则将产生两个事务。结果造成开发人员在设计事务方法时束手束脚，生怕一不小心就踩到地雷。   
其实这是不认识Spring事务传播机制而造成的误解，Spring对事务控制的支持统一在TransactionDefinition类中描述，该类有以下几个重要的接口方法：

*  int getPropagationBehavior()：事务的传播行为
 *  int getIsolationLevel()：事务的隔离级别
 *  int getTimeout()：事务的过期时间
 *  boolean isReadOnly()：事务的读写特性

很明显，除了事务的传播行为外，事务的其他特性Spring是借助底层资源的功能来完成的，Spring无非只充当个代理的角色。但是事务的传播行为却是Spring凭借自身的框架提供的功能，是Spring提供给开发者最珍贵的礼物，讹传的说法玷污了Spring事务框架最美丽的光环。   
     
   所谓事务传播行为就是多个事务方法相互调用时，事务如何在这些方法间传播。Spring支持以下7种事务传播行为。

*  PROPAGATION\_REQUIRED：如果当前没有事务，就新建一个事务，如果已经存在一个事务，就加入到这个事务中。这是最常见的选择。
 *  PROPAGATION\_SUPPORTS：支持当前事务，如果当前没有事务，就以非事务方式执行。
 *  PROPAGATION\_MANDATORY：使用当前的事务，如果当前没有事务，就抛出异常。
 *  PROPAGATION\_REQUIRES\_NEW：新建事务，如果当前存在事务，把当前事务挂起。
 *  PROPAGATION\_NOT\_SUPPORTED：以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。
 *  PROPAGATION\_NEVER：以非事务方式执行，如果当前存在事务，则抛出异常。
 *  PROPAGATION\_NESTED：如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则执行与PROPAGATION\_REQUIRED类似的操作。

Spring默认的事务传播行为是PROPAGATION\_REQUIRED，它适合绝大多数的情况，如果多个ServiveX\#methodX()均工作在事务环境下（即均被Spring事务增强），且程序中存在如下的调用链：Service1\#method1()->Service2\#method2()->Service3\#method3()，那么这3个服务类的3个方法通过Spring的事务传播机制都工作在同一个事务中。   
  
相互嵌套的服务方法

我们来看一下实例，UserService\#logon()方法内部调用了UserService\#updateLastLogon Time()和ScoreService\#addScore()方法，这两个类都继承于BaseService。它们之间的类结构如下图所示：

![Center][]

UserService\#logon()方法内部调用了ScoreService\#addScore()的方法，两者都分别通过[spring][] AOP进行了事务增强，则它们工作于同一事务中。来看具体的代码：

**\[java\]**  [view plain][]   [copy][view plain]

[print][view plain] [?][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  **package** com.baobaotao.nestcall;  
2.  …  
3.  @Service("userService")  
4.  **public** **class** UserService **extends** BaseService \{  
5.      @Autowired  
6.      **private** JdbcTemplate jdbcTemplate;  
7.    
8.      @Autowired  
9.      **private** ScoreService scoreService;  
10.       
11.     //①该方法嵌套调用了本类的其他方法及其他服务类的方法  
12.     **public** **void** logon(String userName) \{  
13.         System.out.println("before userService.updateLastLogonTime...");  
14.         updateLastLogonTime(userName);//①-1本服务类的其他方法  
15.         System.out.println("after userService.updateLastLogonTime...");  
16.           
17.         System.out.println("before scoreService.addScore...");  
18.         scoreService.addScore(userName, 20); //①-2其他服务类的其他方法  
19.         System.out.println("after scoreService.addScore...");  
20.   
21.     \}  
22.     **public** **void** updateLastLogonTime(String userName) \{  
23.         String sql = "UPDATE t\_user u SET u.last\_logon\_time = ? WHERE user\_name =?";  
24.         jdbcTemplate.update(sql, System.currentTimeMillis(), userName);  
25.     \}

UserService中注入了ScoreService的Bean，而ScoreService的代码如下所示：

**\[java\]**  [view plain][]   [copy][view plain]

[print][view plain] [?][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  **package** com.baobaotao.nestcall;  
2.  …  
3.  @Service("scoreUserService")  
4.  **public** **class** ScoreService **extends** BaseService\{  
5.    
6.      @Autowired  
7.      **private** JdbcTemplate jdbcTemplate;  
8.        
9.      **public** **void** addScore(String userName, **int** toAdd) \{  
10.         String sql = "UPDATE t\_user u SET u.score = u.score + ? WHERE user\_name =?";  
11.         jdbcTemplate.update(sql, toAdd, userName);  
12.     \}  
13. \}

通过Spring配置为ScoreService及UserService中所有公有方法都添加Spring AOP的事务增强，让UserService的logon()和updateLastLogonTime()及ScoreService的addScore()方法都工作于事务环境下。下面是关键的配置代码：

**\[java\]**  [view plain][]   [copy][view plain]

[print][view plain] [?][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  <?xml version="1.0" encoding="UTF-8" ?>  
2.  <beans xmlns="http://www.springframework.org/schema/beans"  
3.         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
4.         xmlns:context="http://www.springframework.org/schema/context"  
5.         xmlns:p="http://www.springframework.org/schema/p" xmlns:aop="http://www.springframework.org/schema/aop"  
6.         xmlns:tx="http://www.springframework.org/schema/tx"  
7.         xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd  
8.      http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd">  
9.      <context:component-scan base-**package**="com.baobaotao.nestcall"/>  
10.      …  
11.     <bean id="jdbcManager"  
12.           **class**="org.springframework.jdbc.datasource.DataSourceTransactionManager"  
13.           p:dataSource-ref="dataSource"/>  
14.   
15.       
16.     <aop:config proxy-target-**class**="true">  
17.         <aop:pointcut id="serviceJdbcMethod"  
18.                       expression="within(com.baobaotao.nestcall.BaseService+)"/>  
19.         <aop:advisor pointcut-ref="serviceJdbcMethod" advice-ref="jdbcAdvice" order="0"/>  
20.     </aop:config>  
21.     <tx:advice id="jdbcAdvice" transaction-manager="jdbcManager">  
22.         <tx:attributes>  
23.             <tx:method name="\*"/>  
24.         </tx:attributes>  
25.     </tx:advice>  
26. </beans>

将日志级别设置为DEBUG，启动Spring容器并执行UserService\#logon()的方法，仔细观察如下输出日志：

**\[plain\]**  [view plain][]   [copy][view plain]

[print][view plain] [?][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  before userService.logon method...   
2.    
3.       //①创建了一个事务   
4.  Creating new transaction with name \[com.baobaotao.nestcall.UserService.logon\]: PROPAGATION\_REQUIRED,ISOLATION\_DEFAULT   
5.  Acquired Connection \[jdbc:mysql://localhost:3306/sampledb, UserName=root@localhost, MySQL-AB JDBC Driver\] for JDBC transaction   
6.  Switching JDBC Connection \[jdbc:mysql://localhost:3306/sampledb, UserName=root@localhost, MySQL-AB JDBC Driver\] to manual commit   
7.  before userService.updateLastLogonTime...   
8.    
9.         
11. Executing prepared SQL update   
12. Executing prepared SQL statement \[UPDATE t\_user u SET u.last\_logon\_time = ? WHERE user\_name =?\]   
13. SQL update affected 1 rows   
14. after userService.updateLastLogonTime...   
15. before scoreService.addScore...   
16.   
17. //③ScoreService\#addScore方法加入到①处启动的事务上下文中   
18. Participating in existing transaction   
19. Executing prepared SQL update   
20. Executing prepared SQL statement \[UPDATE t\_user u SET u.score = u.score + ? WHERE user\_name =?\]   
21. SQL update affected 1 rows   
22. after scoreService.addScore...   
23. Initiating transaction commit   
24. Committing JDBC transaction on Connection \[jdbc:mysql://localhost:3306/sampledb, UserName=root@localhost, MySQL-AB JDBC Driver\]   
25. …   
26. after userService.logon method...

从上面的输出日志中，可以清楚地看到Spring为UserService\#logon()方法启动了一个新的事务，而UserSerive\#updateLastLogonTime()和UserService\#logon()是在相同的类中，没有观察到有事务传播行为的发生，其代码块好像“直接合并”到UserService\#logon()中。   
    然而在执行到ScoreService\#addScore()方法时，我们就观察到发生一个事务传播的行为：" Participating in existing transaction "，这说明ScoreService\#addScore()添加到UserService\#logon()的事务上下文中，两者共享同一个事务。所以最终的结果是UserService的logon()、updateLastLogonTime()以及ScoreService的addScore都工作于同一事务中。

[Center]: /images/20220711/85109a5c3d154830a130cbe53f74b300.png
[spring]: http://lib.csdn.net/base/javaee
[view plain]: http://blog.csdn.net/hy6688_/article/details/44763869#
[CODE]: https://code.csdn.net/assets/CODE_ico.png
[CODE_CODE]: https://code.csdn.net/snippets/632005
[ico_fork.svg]: https://code.csdn.net/assets/ico_fork.svg
[ico_fork.svg 1]: https://code.csdn.net/snippets/632005/fork