其他分享
首页 > 其他分享> > Spring事务专题之四、详解Spring事务中7种传播行为

Spring事务专题之四、详解Spring事务中7种传播行为

作者:互联网

本文详解Spring事务中的7种传播行为,还是比较重要的。

环境

  1. jdk1.8
  2. Spring 5.2.3.RELEASE
  3. mysql5.7

什么是事务传播行为?

事务的传播行为用来描述:系统中的一些方法交由spring来管理事务,当这些方法之间出现嵌套调用的时候,事务所表现出来的行为是什么样的?

比如下面2个类,Service1中的m1方法和Service2中的m2方法上面都有@Transactional注解,说明这2个方法由spring来控制事务。

但是注意m1中2行代码,先执行了一个insert,然后调用service2中的m2方法,service2中的m2方法也执行了一个insert。

那么大家觉得这2个insert会在一个事务中运行么?也就是说此时事务的表现行为是什么样的呢?这个就是spring事务的传播行为来控制的事情,不同的传播行为,表现会不一样,可能他们会在一个事务中执行,也可能不会在一个事务中执行,这就需要看传播行为的配置了。

  1. @Component
  2. public class Service1 {
  3. @Autowired
  4. private Service2 service2;
  5. @Autowired
  6. private JdbcTemplate jdbcTemplate;
  7. @Transactional
  8. public void m1() {
  9. this.jdbcTemplate.update("INSERT into t1 values ('m1')");
  10. this.service2.m2();
  11. }
  12. }
  13. @Component
  14. public class Service2 {
  15. @Autowired
  16. private JdbcTemplate jdbcTemplate;
  17. @Transactional
  18. public void m2() {
  19. this.jdbcTemplate.update("INSERT into t1 values ('m2')");
  20. }
  21. }

如何配置事务传播行为?

通过@Transactional注解中的propagation属性来指定事务的传播行为:

  1. Propagation propagation() default Propagation.REQUIRED;

7种传播行为

Propagation是个枚举,有7种值,如下:

事务传播行为类型 说明
REQUIRED 如果当前事务管理器中没有事务,就新建一个事务,如果已经存在一个事务中,加入到这个事务中。这是最常见的选择,是默认的传播行为。
SUPPORTS 支持当前事务,如果当前事务管理器中没有事务,就以非事务方式执行。
MANDATORY 使用当前的事务,如果当前事务管理器中没有事务,就抛出异常。
REQUIRES_NEW 新建事务,如果当前事务管理器中存在事务,把当前事务挂起,然后会新建一个事务。
NOT_SUPPORTED 以非事务方式执行操作,如果当前事务管理器中存在事务,就把当前事务挂起。
NEVER 以非事务方式执行,如果当前事务管理器中存在事务,则抛出异常。
NESTED 如果当前事务管理器中存在事务,则在嵌套事务内执行;如果当前事务管理器中没有事务,则执行与PROPAGATION_REQUIRED类似的操作。

注意:这7种传播行为有个前提,他们的事务管理器是同一个的时候,才会有上面描述中的表现行为。

下面通过案例对7中表现行为来做说明,在看案例之前,先来回顾几个知识点

1、Spring声明式事务处理事务的过程

spring声明式事务是通过事务拦截器TransactionInterceptor拦截目标方法,来实现事务管理的功能的,事务管理器处理过程大致如下:

  1. 1、获取事务管理器
  2. 2、通过事务管理器开启事务
  3. try{
  4. 3、调用业务方法执行db操作
  5. 4、提交事务
  6. }catch(RuntimeException | Error){
  7. 5、回滚事务
  8. }

2、何时事务会回滚?

默认情况下,目标方法抛出RuntimeException或者Error的时候,事务会被回滚。

3、Spring事务管理器中的Connection和业务中操作db的Connection如何使用同一个的?

以DataSourceTransactionManager为事务管理器,操作db使用JdbcTemplate来说明一下。

创建DataSourceTransactionManager和JdbcTemplate的时候都需要指定dataSource,需要将他俩的dataSource指定为同一个对象。

当事务管理器开启事务的时候,会通过dataSource.getConnection()方法获取一个db连接connection,然后会将dataSource->connection丢到一个Map中,然后将map放到ThreadLocal中。

当JdbcTemplate执行sql的时候,以JdbcTemplate.dataSource去上面的ThreadLocal中查找,是否有可用的连接,如果有,就直接拿来用了,否则调用JdbcTemplate.dataSource.getConnection()方法获取一个连接来用。

所以spring中可以确保事务管理器中的Connection和JdbcTemplate中操作db的Connection是同一个,这样才能确保spring可以控制事务。

代码验证

准备db

  1. DROP DATABASE IF EXISTS javacode2018;
  2. CREATE DATABASE if NOT EXISTS javacode2018;
  3. USE javacode2018;
  4. DROP TABLE IF EXISTS user1;
  5. CREATE TABLE user1(
  6. id int PRIMARY KEY AUTO_INCREMENT,
  7. name varchar(64) NOT NULL DEFAULT '' COMMENT '姓名'
  8. );
  9. DROP TABLE IF EXISTS user2;
  10. CREATE TABLE user2(
  11. id int PRIMARY KEY AUTO_INCREMENT,
  12. name varchar(64) NOT NULL DEFAULT '' COMMENT '姓名'
  13. );

spring配置类MainConfig6

准备JdbcTemplate和事务管理器。

  1. package com.javacode2018.tx.demo6;
  2. import org.springframework.context.annotation.Bean;
  3. import org.springframework.context.annotation.ComponentScan;
  4. import org.springframework.context.annotation.Configuration;
  5. import org.springframework.jdbc.core.JdbcTemplate;
  6. import org.springframework.jdbc.datasource.DataSourceTransactionManager;
  7. import org.springframework.transaction.PlatformTransactionManager;
  8. import org.springframework.transaction.annotation.EnableTransactionManagement;
  9. import javax.sql.DataSource;
  10. @EnableTransactionManagement //开启spring事务管理功能
  11. @Configuration //指定当前类是一个spring配置类
  12. @ComponentScan //开启bean扫描注册
  13. public class MainConfig6 {
  14. //定义一个数据源
  15. @Bean
  16. public DataSource dataSource() {
  17. org.apache.tomcat.jdbc.pool.DataSource dataSource = new org.apache.tomcat.jdbc.pool.DataSource();
  18. dataSource.setDriverClassName("com.mysql.jdbc.Driver");
  19. dataSource.setUrl("jdbc:mysql://localhost:3306/javacode2018?characterEncoding=UTF-8");
  20. dataSource.setUsername("root");
  21. dataSource.setPassword("root123");
  22. dataSource.setInitialSize(5);
  23. return dataSource;
  24. }
  25. //定义一个JdbcTemplate,用来执行db操作
  26. @Bean
  27. public JdbcTemplate jdbcTemplate(DataSource dataSource) {
  28. return new JdbcTemplate(dataSource);
  29. }
  30. //定义我一个事务管理器
  31. @Bean
  32. public PlatformTransactionManager transactionManager(DataSource dataSource) {
  33. return new DataSourceTransactionManager(dataSource);
  34. }
  35. }

来3个service

后面的案例中会在这3个service中使用spring的事务来演示效果。

User1Service

  1. package com.javacode2018.tx.demo6;
  2. import org.springframework.beans.factory.annotation.Autowired;
  3. import org.springframework.jdbc.core.JdbcTemplate;
  4. import org.springframework.stereotype.Component;
  5. @Component
  6. public class User1Service {
  7. @Autowired
  8. private JdbcTemplate jdbcTemplate;
  9. }

User2Service

  1. package com.javacode2018.tx.demo6;
  2. import org.springframework.beans.factory.annotation.Autowired;
  3. import org.springframework.jdbc.core.JdbcTemplate;
  4. import org.springframework.stereotype.Component;
  5. @Component
  6. public class User2Service {
  7. @Autowired
  8. private JdbcTemplate jdbcTemplate;
  9. }

TxService

  1. package com.javacode2018.tx.demo6;
  2. import org.springframework.beans.factory.annotation.Autowired;
  3. import org.springframework.stereotype.Component;
  4. @Component
  5. public class TxService {
  6. @Autowired
  7. private User1Service user1Service;
  8. @Autowired
  9. private User2Service user2Service;
  10. }

测试用例Demo6Test

before方法会在每个@Test标注的方法之前执行一次,这个方法主要用来做一些准备工作:启动spring容器、清理2个表中的数据;after方法会在每个@Test标注的方法执行完毕之后执行一次,我们在这个里面输出2个表的数据;方便查看的测试用例效果。

  1. package com.javacode2018.tx.demo6;
  2. import org.junit.Before;
  3. import org.springframework.context.annotation.AnnotationConfigApplicationContext;
  4. public class Demo6Test {
  5. private TxService txService;
  6. private JdbcTemplate jdbcTemplate;
  7. //每个@Test用例执行之前先启动一下spring容器,并清理一下user1、user2中的数据
  8. @Before
  9. public void before() {
  10. AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MainConfig6.class);
  11. txService = context.getBean(TxService.class);
  12. jdbcTemplate = context.getBean(JdbcTemplate.class);
  13. jdbcTemplate.update("truncate table user1");
  14. jdbcTemplate.update("truncate table user2");
  15. }
  16. @After
  17. public void after() {
  18. System.out.println("user1表数据:" + jdbcTemplate.queryForList("SELECT * from user1"));
  19. System.out.println("user2表数据:" + jdbcTemplate.queryForList("SELECT * from user2"));
  20. }
  21. }

1、REQUIRED

User1Service

添加1个方法,事务传播行为:REQUIRED

  1. @Transactional(propagation = Propagation.REQUIRED)
  2. public void required(String name) {
  3. this.jdbcTemplate.update("insert into user1(name) VALUES (?)", name);
  4. }

User2Service

添加2个方法,事务传播行为:REQUIRED,注意第2个方法内部最后一行会抛出一个异常。

  1. @Transactional(propagation = Propagation.REQUIRED)
  2. public void required(String name) {
  3. this.jdbcTemplate.update("insert into user1(name) VALUES (?)", name);
  4. }
  5. @Transactional(propagation = Propagation.REQUIRED)
  6. public void required_exception(String name) {
  7. this.jdbcTemplate.update("insert into user1(name) VALUES (?)", name);
  8. throw new RuntimeException();
  9. }

场景1(1-1)

外围方法没有事务,外围方法内部调用2个REQUIRED级别的事务方法。

案例中都是在TxService的方法中去调用另外2个service,所以TxService中的方法统称外围方法,另外2个service中的方法称内部方法。

验证方法1

TxService添加
  1. public void notransaction_exception_required_required() {
  2. this.user1Service.required("张三");
  3. this.user2Service.required("李四");
  4. throw new RuntimeException();
  5. }
测试用例,Demo6Test中添加
  1. @Test
  2. public void notransaction_exception_required_required() {
  3. txService.notransaction_exception_required_required();
  4. }
运行输出
  1. user1表数据:[{id=1, name=张三}]
  2. user2表数据:[{id=1, name=李四}]

验证方法2

TxService添加
  1. public void notransaction_required_required_exception() {
  2. this.user1Service.required("张三");
  3. this.user2Service.required_exception("李四");
  4. }
测试用例,Demo6Test中添加
  1. @Test
  2. public void notransaction_required_required_exception() {
  3. txService.notransaction_required_required_exception();
  4. }
运行输出
  1. user1表数据:[{id=1, name=张三}]
  2. user2表数据:[]

结果分析

验证方法序号 数据库结果 结果分析
1 “张三”、“李四”均插入。 外围方法未开启事务,插入“张三”、“李四”方法在自己的事务中独立运行,外围方法异常不影响内部插入“张三”、“李四”方法独立的事务。
2 “张三”插入,“李四”未插入。 外围方法没有事务,插入“张三”、“李四”方法都在自己的事务中独立运行,所以插入“李四”方法抛出异常只会回滚插入“李四”方法,插入“张三”方法不受影响。

结论

通过这两个方法我们证明了在外围方法未开启事务的情况下Propagation.REQUIRED修饰的内部方法会新开启自己的事务,且开启的事务相互独立,互不干扰。

场景2(1-2)

外围方法开启事务(Propagation.REQUIRED),这个使用频率特别高。

验证方法1

TxService添加
  1. @Transactional(propagation = Propagation.REQUIRED)
  2. public void transaction_exception_required_required() {
  3. user1Service.required("张三");
  4. user2Service.required("李四");
  5. throw new RuntimeException();
  6. }
测试用例,Demo6Test中添加
  1. @Test
  2. public void transaction_exception_required_required() {
  3. txService.transaction_exception_required_required();
  4. }
运行输出
  1. user1表数据:[]
  2. user2表数据:[]

验证方法2

TxService添加
  1. @Transactional(propagation = Propagation.REQUIRED)
  2. public void transaction_required_required_exception() {
  3. user1Service.required("张三");
  4. user2Service.required_exception("李四");
  5. }
测试用例,Demo6Test中添加
  1. @Test
  2. public void transaction_required_required_exception() {
  3. txService.transaction_required_required_exception();
  4. }
运行输出
  1. user1表数据:[]
  2. user2表数据:[]

验证方法3

TxService添加
  1. @Transactional(propagation = Propagation.REQUIRED)
  2. public void transaction_required_required_exception_try() {
  3. user1Service.required("张三");
  4. try {
  5. user2Service.required_exception("李四");
  6. } catch (Exception e) {
  7. System.out.println("方法回滚");
  8. }
  9. }
测试用例,Demo6Test中添加
  1. @Test
  2. public void transaction_required_required_exception_try() {
  3. txService.transaction_required_required_exception_try();
  4. }
运行输出
  1. 方法回滚
  2. user1表数据:[]
  3. user2表数据:[]

结果分析

验证方法序号 数据库结果 结果分析
1 “张三”、“李四”均未插入。 外围方法开启事务,内部方法加入外围方法事务,外围方法回滚,内部方法也要回滚。
2 “张三”、“李四”均未插入。 外围方法开启事务,内部方法加入外围方法事务,内部方法抛出异常回滚,外围方法感知异常致使整体事务回滚。
3 “张三”、“李四”均未插入。 外围方法开启事务,内部方法加入外围方法事务,内部方法抛出异常回滚,即使方法被catch不被外围方法感知,整个事务依然回滚。

结论

以上试验结果我们证明在外围方法开启事务的情况下Propagation.REQUIRED修饰的内部方法会加入到外围方法的事务中,所有Propagation.REQUIRED修饰的内部方法和外围方法均属于同一事务,只要一个方法回滚,整个事务均回滚。

2、PROPAGATION_REQUIRES_NEW

User1Service

添加1个方法,事务传播行为:REQUIRES_NEW

  1. @Transactional(propagation = Propagation.REQUIRES_NEW)
  2. public void requires_new(String name) {
  3. this.jdbcTemplate.update("insert into user1(name) VALUES (?)", name);
  4. }

User2Service

添加2个方法,事务传播行为:REQUIRES_NEW,注意第2个方法内部最后一行会抛出一个异常。

  1. @Transactional(propagation = Propagation.REQUIRES_NEW)
  2. public void requires_new(String name) {
  3. this.jdbcTemplate.update("insert into user2(name) VALUES (?)", name);
  4. }
  5. @Transactional(propagation = Propagation.REQUIRES_NEW)
  6. public void requires_new_exception(String name) {
  7. this.jdbcTemplate.update("insert into user2(name) VALUES (?)", name);
  8. throw new RuntimeException();
  9. }

场景1(2-1)

外围方法没有事务。

验证方法1

TxService添加
  1. public void notransaction_exception_requiresNew_requiresNew(){
  2. user1Service.requires_new("张三");
  3. user2Service.requires_new("李四");
  4. throw new RuntimeException();
  5. }
Demo6Test中添加
  1. @Test
  2. public void notransaction_exception_requiresNew_requiresNew() {
  3. txService.notransaction_exception_requiresNew_requiresNew();
  4. }
运行输出
  1. user1表数据:[{id=1, name=张三}]
  2. user2表数据:[{id=1, name=李四}]

验证方法2

TxService添加
  1. public void notransaction_requiresNew_requiresNew_exception(){
  2. user1Service.requires_new("张三");
  3. user2Service.requires_new_exception("李四");
  4. }
测试用例,Demo6Test中添加
  1. @Test
  2. public void notransaction_requiresNew_requiresNew_exception() {
  3. txService.notransaction_requiresNew_requiresNew_exception();
  4. }
运行输出
  1. user1表数据:[{id=1, name=张三}]
  2. user2表数据:[]

结果分析

验证方法序号 数据库结果 结果分析
1 “张三”插入,“李四”插入。 外围方法没有事务,插入“张三”、“李四”方法都在自己的事务中独立运行,外围方法抛出异常回滚不会影响内部方法。
2 “张三”插入,“李四”未插入 外围方法没有开启事务,插入“张三”方法和插入“李四”方法分别开启自己的事务,插入“李四”方法抛出异常回滚,其他事务不受影响。

结论

通过这两个方法我们证明了在外围方法未开启事务的情况下Propagation.REQUIRES_NEW修饰的内部方法会新开启自己的事务,且开启的事务相互独立,互不干扰。

场景2(2-2)

外围方法开启事务。

验证方法1

TxService添加
  1. @Transactional(propagation = Propagation.REQUIRED)
  2. public void transaction_exception_required_requiresNew_requiresNew() {
  3. user1Service.required("张三");
  4. user2Service.requires_new("李四");
  5. user2Service.requires_new("王五");
  6. throw new RuntimeException();
  7. }
测试用例,Demo6Test中添加
  1. @Test
  2. public void transaction_exception_required_requiresNew_requiresNew() {
  3. txService.transaction_exception_required_requiresNew_requiresNew();
  4. }
运行输出
  1. user1表数据:[]
  2. user2表数据:[{id=1, name=李四}, {id=2, name=王五}]

验证方法2

TxService添加
  1. @Transactional(propagation = Propagation.REQUIRED)
  2. public void transaction_required_requiresNew_requiresNew_exception() {
  3. user1Service.required("张三");
  4. user2Service.requires_new("李四");
  5. user2Service.requires_new_exception("王五");
  6. }
Demo6Test中添加
  1. @Test
  2. public void transaction_required_requiresNew_requiresNew_exception() {
  3. txService.transaction_required_requiresNew_requiresNew_exception();
  4. }
运行输出
  1. user1表数据:[]
  2. user2表数据:[{id=1, name=李四}]

验证方法3

TxService添加
  1. @Transactional(propagation = Propagation.REQUIRED)
  2. public void transaction_required_requiresNew_requiresNew_exception_try(){
  3. user1Service.required("张三");
  4. user2Service.requires_new("李四");
  5. try {
  6. user2Service.requires_new_exception("王五");
  7. } catch (Exception e) {
  8. System.out.println("回滚");
  9. }
  10. }
Demo6Test中添加
  1. @Test
  2. public void transaction_required_requiresNew_requiresNew_exception_try() {
  3. txService.transaction_required_requiresNew_requiresNew_exception_try();
  4. }
运行输出
  1. 回滚
  2. user1表数据:[{id=1, name=张三}]
  3. user2表数据:[{id=1, name=李四}]

结果分析

验证方法序号 数据库结果 结果分析
1 “张三”未插入,“李四”插入,“王五”插入。 外围方法开启事务,插入“张三”方法和外围方法一个事务,插入“李四”方法、插入“王五”方法分别在独立的新建事务中,外围方法抛出异常只回滚和外围方法同一事务的方法,故插入“张三”的方法回滚。
2 “张三”未插入,“李四”插入,“王五”未插入。 外围方法开启事务,插入“张三”方法和外围方法一个事务,插入“李四”方法、插入“王五”方法分别在独立的新建事务中。插入“王五”方法抛出异常,首先插入 “王五”方法的事务被回滚,异常继续抛出被外围方法感知,外围方法事务亦被回滚,故插入“张三”方法也被回滚。
3 “张三”插入,“李四”插入,“王五”未插入。 外围方法开启事务,插入“张三”方法和外围方法一个事务,插入“李四”方法、插入“王五”方法分别在独立的新建事务中。插入“王五”方法抛出异常,首先插入“王五”方法的事务被回滚,异常被catch不会被外围方法感知,外围方法事务不回滚,故插入“张三”方法插入成功。

结论

在外围方法开启事务的情况下Propagation.REQUIRES_NEW修饰的内部方法依然会单独开启独立事务,且与外部方法事务也独立,内部方法之间、内部方法和外部方法事务均相互独立,互不干扰。

3、PROPAGATION_NESTED

User1Service

添加1个方法,事务传播行为:NESTED

  1. @Transactional(propagation = Propagation.NESTED)
  2. public void nested(String name) {
  3. this.jdbcTemplate.update("insert into user1(name) VALUES (?)", name);
  4. }

User2Service

添加2个方法,事务传播行为:NESTED,注意第2个方法内部最后一行会抛出一个异常。

  1. @Transactional(propagation = Propagation.NESTED)
  2. public void nested(String name) {
  3. this.jdbcTemplate.update("insert into user2(name) VALUES (?)", name);
  4. }
  5. @Transactional(propagation = Propagation.NESTED)
  6. public void nested_exception(String name) {
  7. this.jdbcTemplate.update("insert into user2(name) VALUES (?)", name);
  8. throw new RuntimeException();
  9. }

场景1(3-1)

外围方法没有事务。

验证方法1

TxService添加
  1. public void notransaction_exception_nested_nested(){
  2. user1Service.nested("张三");
  3. user2Service.nested("李四");
  4. throw new RuntimeException();
  5. }
Demo6Test中添加
  1. @Test
  2. public void notransaction_exception_nested_nested() {
  3. txService.notransaction_exception_nested_nested();
  4. }
运行输出
  1. user1表数据:[{id=1, name=张三}]
  2. user2表数据:[{id=1, name=李四}]

验证方法2

TxService添加
  1. public void notransaction_nested_nested_exception(){
  2. user1Service.nested("张三");
  3. user2Service.nested_exception("李四");
  4. }
测试用例,Demo6Test中添加
  1. @Test
  2. public void notransaction_nested_nested_exception() {
  3. txService.notransaction_nested_nested_exception();
  4. }
运行输出
  1. user1表数据:[{id=1, name=张三}]
  2. user2表数据:[]

结果分析

验证方法序号 数据库结果 结果分析
1 “张三”、“李四”均插入。 外围方法未开启事务,插入“张三”、“李四”方法在自己的事务中独立运行,外围方法异常不影响内部插入“张三”、“李四”方法独立的事务。
2 “张三”插入,“李四”未插入。 外围方法没有事务,插入“张三”、“李四”方法都在自己的事务中独立运行,所以插入“李四”方法抛出异常只会回滚插入“李四”方法,插入“张三”方法不受影响。

结论

通过这两个方法我们证明了在外围方法未开启事务的情况下Propagation.NESTEDPropagation.REQUIRED作用相同,修饰的内部方法都会新开启自己的事务,且开启的事务相互独立,互不干扰。

场景2(3-1)

外围方法开启事务。

验证方法1

TxService添加
  1. @Transactional
  2. public void transaction_exception_nested_nested(){
  3. user1Service.nested("张三");
  4. user2Service.nested("李四");
  5. throw new RuntimeException();
  6. }
测试用例,Demo6Test中添加
  1. @Test
  2. public void transaction_exception_nested_nested() {
  3. txService.transaction_exception_nested_nested();
  4. }
运行输出
  1. user1表数据:[]
  2. user2表数据:[]

验证方法2

TxService添加
  1. @Transactional
  2. public void transaction_nested_nested_exception(){
  3. user1Service.nested("张三");
  4. user2Service.nested_exception("李四");
  5. }
Demo6Test中添加
  1. @Test
  2. public void transaction_nested_nested_exception() {
  3. txService.transaction_nested_nested_exception();
  4. }
运行输出
  1. user1表数据:[]
  2. user2表数据:[]

验证方法3

TxService添加
  1. @Transactional
  2. public void transaction_nested_nested_exception_try(){
  3. user1Service.nested("张三");
  4. try {
  5. user2Service.nested_exception("李四");
  6. } catch (Exception e) {
  7. System.out.println("方法回滚");
  8. }
  9. }
Demo6Test中添加
  1. @Test
  2. public void transaction_nested_nested_exception_try() {
  3. txService.transaction_nested_nested_exception_try();
  4. }
运行输出
  1. 方法回滚
  2. user1表数据:[{id=1, name=张三}]
  3. user2表数据:[]

结果分析

验证方法序号 数据库结果 结果分析
1 “张三”、“李四”均未插入。 外围方法开启事务,内部事务为外围事务的子事务,外围方法回滚,内部方法也要回滚。
2 “张三”、“李四”均未插入。 外围方法开启事务,内部事务为外围事务的子事务,内部方法抛出异常回滚,且外围方法感知异常致使整体事务回滚。
3 “张三”插入、“李四”未插入。 外围方法开启事务,内部事务为外围事务的子事务,插入“李四”内部方法抛出异常,可以单独对子事务回滚。

结论

以上试验结果我们证明在外围方法开启事务的情况下Propagation.NESTED修饰的内部方法属于外部事务的子事务,外围主事务回滚,子事务一定回滚,而内部子事务可以单独回滚而不影响外围主事务和其他子事务。

内部事务原理

以mysql为例,mysql中有个savepoint的功能,NESTED内部事务就是通过这个实现的。

REQUIRED,REQUIRES_NEW,NESTED比较

由“场景2(1-2)”和“场景2(3-2)”对比,我们可知:

REQUIRED和NESTED修饰的内部方法都属于外围方法事务,如果外围方法抛出异常,这两种方法的事务都会被回滚。但是REQUIRED是加入外围方法事务,所以和外围事务同属于一个事务,一旦REQUIRED事务抛出异常被回滚,外围方法事务也将被回滚。而NESTED是外围方法的子事务,有单独的保存点,所以NESTED方法抛出异常被回滚,不会影响到外围方法的事务。

由“场景2(2-2)”和“场景2(3-2)”对比,我们可知:

REQUIRES_NEW和NESTED都可以做到内部方法事务回滚而不影响外围方法事务。但是因为NESTED是嵌套事务,所以外围方法回滚之后,作为外围方法事务的子事务也会被回滚。而REQUIRES_NEW是通过开启新的事务实现的,内部事务和外围事务是两个事务,外围事务回滚不会影响内部事务。

其他几个传播行为

REQUIRED,REQUIRES_NEW,NESTED这几个算是比较特殊的,比较常用的,剩下的5个传播行为,大家可以自己练练。

模拟用例

介绍了这么多事务传播行为,我们在实际工作中如何应用呢?下面我来举一个示例:

假设我们有一个注册的方法,方法中调用添加积分的方法,如果我们希望添加积分不会影响注册流程(即添加积分执行失败回滚不能使注册方法也回滚),我们会这样写:

  1. @Service
  2. public class UserServiceImpl implements UserService {
  3. @Transactional
  4. public void register(User user){
  5. try {
  6. membershipPointService.addPoint(Point point);
  7. } catch (Exception e) {
  8. //省略...
  9. }
  10. //省略...
  11. }
  12. //省略...
  13. }

我们还规定注册失败要影响addPoint()方法(注册方法回滚添加积分方法也需要回滚),那么addPoint()方法就需要这样实现:

  1. @Service
  2. public class MembershipPointServiceImpl implements MembershipPointService{
  3. @Transactional(propagation = Propagation.NESTED)
  4. public void addPoint(Point point){
  5. try {
  6. recordService.addRecord(Record record);
  7. } catch (Exception e) {
  8. //省略...
  9. }
  10. //省略...
  11. }
  12. //省略...
  13. }

我们注意到了在addPoint()中还调用了addRecord()方法,这个方法用来记录日志。他的实现如下:

  1. @Service
  2. public class RecordServiceImpl implements RecordService{
  3. @Transactional(propagation = Propagation.NOT_SUPPORTED)
  4. public void addRecord(Record record){
  5. //省略...
  6. }
  7. //省略...
  8. }

我们注意到addRecord()方法中propagation = Propagation.NOT_SUPPORTED,因为对于日志无所谓精确,可以多一条也可以少一条,所以addRecord()方法本身和外围addPoint()方法抛出异常都不会使addRecord()方法回滚,并且addRecord()方法抛出异常也不会影响外围addPoint()方法的执行。

通过这个例子相信大家对事务传播行为的使用有了更加直观的认识,通过各种属性的组合确实能让我们的业务实现更加灵活多样。

总结

通过本文,相信大家对spring事务7种传播行为都有了深入的了解,希望对大家有所帮助,也欢迎大家留言交流!!!

案例源码

  1. git地址:
  2. https://gitee.com/javacode2018/spring-series
  3. 本文案例对应源码:spring-series\lesson-002-tx\src\main\java\com\javacode2018\tx\demo6

本博客所有系列案例代码以后都会放到这个上面,大家watch一下,可以持续关注动态。

继续收门徒,月薪 4W 以下的可以来找我,4W 以上的靠你们自己的天赋了

最新资料

  1. 尚硅谷 Java 学科全套教程(总 207.77GB)
  2. 2021 最新版 Java 微服务学习线路图 + 视频
  3. 阿里技术大佬整理的《Spring 学习笔记.pdf》
  4. 阿里大佬的《MySQL 学习笔记高清.pdf》
  5. 2021 版 java 高并发常见面试题汇总.pdf
  6. Idea 快捷键大全.pdf

来源:http://www.itsoku.com/course/12/127

标签:事务,Spring,required,exception,回滚,李四,之四,方法
来源: https://www.cnblogs.com/konglxblog/p/16193562.html