Spring系列第45篇：详解Spring事务中7种传播行为

star2017 1年前 ⋅ 232 阅读

本文详解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;
  6.     @Autowired
  7.     private JdbcTemplate jdbcTemplate;
  9.     @Transactional
  10.     public void m1() {
  11.         this.jdbcTemplate.update("INSERT into t1 values ('m1')");
  12.         this.service2.m2();
  13.     }
  14. }
  16. @Component
  17. public class Service2 {
  18.     @Autowired
  19.     private JdbcTemplate jdbcTemplate;
  21.     @Transactional
  22.     public void m2() {
  23.         this.jdbcTemplate.update("INSERT into t1 values ('m2')");
  24.     }
  25. }

如何配置事务传播行为？

通过@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;
  4. USE javacode2018;
  5. DROP TABLE IF EXISTS user1;
  6. CREATE TABLE user1(
  7.   id int PRIMARY KEY AUTO_INCREMENT,
  8.   name varchar(64) NOT NULL DEFAULT '' COMMENT '姓名'
  9. );
  11. DROP TABLE IF EXISTS user2;
  12. CREATE TABLE user2(
  13.   id int PRIMARY KEY AUTO_INCREMENT,
  14.   name varchar(64) NOT NULL DEFAULT '' COMMENT '姓名'
  15. );

spring配置类MainConfig6

准备JdbcTemplate和事务管理器。

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

来3个service

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

User1Service

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

User2Service

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

TxService

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

测试用例Demo6Test

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

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

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. }
  6. @Transactional(propagation = Propagation.REQUIRED)
  7. public void required_exception(String name) {
  8.     this.jdbcTemplate.update("insert into user1(name) VALUES (?)", name);
  9.     throw new RuntimeException();
  10. }

场景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. }
  6. @Transactional(propagation = Propagation.REQUIRES_NEW)
  7. public void requires_new_exception(String name) {
  8.     this.jdbcTemplate.update("insert into user2(name) VALUES (?)", name);
  9.     throw new RuntimeException();
  10. }

场景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. }
  6. @Transactional(propagation = Propagation.NESTED)
  7. public void nested_exception(String name) {
  8.     this.jdbcTemplate.update("insert into user2(name) VALUES (?)", name);
  9.     throw new RuntimeException();
  10. }

场景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.NESTED和Propagation.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中有个，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 {
  4.     @Transactional
  5.     public void register(User user){
  7.         try {
  8.             membershipPointService.addPoint(Point point);
  9.         } catch (Exception e) {
  10.             //省略...
  11.         }
  12.         //省略...
  13.     }
  14.     //省略...
  15. }

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

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

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

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

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

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

总结

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

案例源码

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

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

最新资料

更多内容请访问：IT源点

注意：本文归作者所有，未经作者允许，不得转载

#Spring教程  |  Spring事务专题
阅读全部
相关文章推荐
  • 1

全部评论: 0 条

    我有话说: