spring boot 线程回滚_Spring事务传播行为_代码验证

复习一下，spring的七种事务传播行为。(祈祷自己过几天还能记住)

事务传播行为类型	说明
PROPAGATION_REQUIRED	如果当前没有事务，就新建一个事务，如果已经存在一个事务中，加入到这个事务中。这是最常见的选择。
PROPAGATION_SUPPORTS	支持当前事务，如果当前没有事务，就以非事务方式执行。
PROPAGATION_MANDATORY	使用当前的事务，如果当前没有事务，就抛出异常。
PROPAGATION_REQUIRES_NEW	新建事务，如果当前存在事务，把当前事务挂起。
PROPAGATION_NOT_SUPPORTED	以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。
PROPAGATION_NEVER	以非事务方式执行，如果当前存在事务，则抛出异常。
PROPAGATION_NESTED	如果当前存在事务，则在嵌套事务内执行。如果当前没

(按表格内容自适应为什么不行，为什么为什么为什么)

创建一个springboot项目，加入所需依赖：

<dependency>      <groupId>org.springframework.bootgroupId>      <artifactId>spring-boot-starter-data-jpaartifactId>dependency><dependency>      <groupId>mysqlgroupId>      <artifactId>mysql-connector-javaartifactId>      <scope>runtimescope> dependency> <dependency>      <groupId>org.springframework.bootgroupId>      <artifactId>spring-boot-starter-testartifactId>      <scope>testscope>dependency>

建立两张表user1和user2：

CREATE TABLE `user1` (  `id` INTEGER UNSIGNED NOT NULL AUTO_INCREMENT,  `name` VARCHAR(45) NOT NULL DEFAULT '',  PRIMARY KEY(`id`))ENGINE = InnoDB;CREATE TABLE `user2` (  `id` INTEGER UNSIGNED NOT NULL AUTO_INCREMENT,  `name` VARCHAR(45) NOT NULL DEFAULT '',  PRIMARY KEY(`id`))ENGINE = InnoDB;

实体类与dao层。省略。。。

Test方法：

1.PROPAGATION_REQUIRED

User1Service1方法：

  @Override  @Transactional(propagation = Propagation.REQUIRED)  public void addRequired(User1 user) {    use1Repository.save(user);  }

User2Service2方法：

  @Override  @Transactional(propagation = Propagation.REQUIRED)  public void addRequired(User2 user) {    use2Repository.save(user);  }  @Override  @Transactional(propagation = Propagation.REQUIRED)  public void addRequiredException(User2 user) {    use2Repository.save(user);    throw new RuntimeException();  }

1.1 场景一

外围方法没有开启事务。

Test方法1：

@Test  public void notransaction_exception_required_required() {    User1 user1 = new User1();    user1.setName("张三");    user1Service.addRequired(user1);    User2 user2 = new User2();    user2.setName("李四");    user2Service.addRequired(user2);    throw new RuntimeException();  }

Test方法2：

  @Test  public void notransaction_required_required_exception() {    User1 user1 = new User1();    user1.setName("张三");    user1Service.addRequired(user1);    User2 user2 = new User2();    user2.setName("李四");    user2Service.addRequiredException(user2);  }

分别执行验证方法，结果：

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

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

1.2 场景2

外围方法开启事务

Test方法1：

  @Test  @Transactional(propagation = Propagation.REQUIRED)  public void transaction_exception_required_required() {    User1 user1 = new User1();    user1.setName("张三");    user1Service.addRequired(user1);    User2 user2 = new User2();    user2.setName("李四");    user2Service.addRequired(user2);    throw new RuntimeException();  }

Test方法2：

  @Test  @Transactional(propagation = Propagation.REQUIRED)  public void transaction_required_required_exception() {    User1 user1 = new User1();    user1.setName("张三2");    user1Service.addRequired(user1);    User2 user2 = new User2();    user2.setName("李四2");    user2Service.addRequiredException(user2);  }

Test方法3：

  @Test  @Transactional  public void transaction_required_required_exception_try() {    User1 user1 = new User1();    user1.setName("张三");    user1Service.addRequired(user1);    User2 user2 = new User2();    user2.setName("李四");    try {      user2Service.addRequiredException(user2);    } catch (Exception e) {      System.out.println("方法回滚");    }  }

分别执行验证方法，结果：

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

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

2.PROPAGATION_REQUIRES_NEW

User1Service方法:

  @Override  @Transactional(propagation = Propagation.REQUIRES_NEW)  public void addRequiresNew(User1 user) {    // TODO Auto-generated method stub    use1Repository.save(user);  }

User2Service方法：

  @Override  @Transactional(propagation = Propagation.REQUIRES_NEW)  public void addRequiresNew(User2 user) {    use2Repository.save(user);  }  @Override  @Transactional(propagation = Propagation.REQUIRES_NEW)  public void addRequiresNewException(User2 user) {    use2Repository.save(user);    throw new RuntimeException();  }

2.1 场景一

Test方法1：

  @Test  public void notransaction_exception_requiresNew_requiresNew() {    User1 user1 = new User1();    user1.setName("张三");    user1Service.addRequiresNew(user1);    User2 user2 = new User2();    user2.setName("李四");    user2Service.addRequiresNew(user2);    throw new RuntimeException();  }

Test方法2：

  @Test  public void notransaction_requiresNew_requiresNew_exception() {    User1 user1 = new User1();    user1.setName("张三");    user1Service.addRequiresNew(user1);    User2 user2 = new User2();    user2.setName("李四");    user2Service.addRequiresNewException(user2);  }

分别执行验证方法，结果：

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

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

2.2 场景2

外围方法开启事务。

Test方法1：

  @Test  @Transactional(propagation = Propagation.REQUIRED)  public void transaction_exception_required_requiresNew_requiresNew() {    User1 user1 = new User1();    user1.setName("张三");    user1Service.addRequired(user1);    User2 user2 = new User2();    user2.setName("李四");    user2Service.addRequiresNew(user2);    User2 user3 = new User2();    user3.setName("王五");    user2Service.addRequiresNew(user3);    throw new RuntimeException();  }

Test方法2：

  @Test  @Transactional(propagation = Propagation.REQUIRED)  public void transaction_required_requiresNew_requiresNew_exception() {    User1 user1 = new User1();    user1.setName("张三");    user1Service.addRequired(user1);    User2 user2 = new User2();    user2.setName("李四");    user2Service.addRequiresNew(user2);    User2 user3 = new User2();    user3.setName("王五");    user2Service.addRequiresNewException(user3);  }

Test方法3：

  @Test  @Transactional(propagation = Propagation.REQUIRED)  public void transaction_required_requiresNew_requiresNew_exception_try() {    User1 user1 = new User1();    user1.setName("张三");    user1Service.addRequired(user1);    User2 user2 = new User2();    user2.setName("李四");    user2Service.addRequiresNew(user2);    User2 user3 = new User2();    user3.setName("王五");    try {      user2Service.addRequiresNewException(user3);    } catch (Exception e) {      System.out.println("回滚");    }  }

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

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

后面几种情况，，不想写了。

代码地址：https://github.com/wsj-jsw/SpringBootTransactionCommunication

模拟用例

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

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

   @Service
public class UserServiceImpl implements UserService {

@Transactional
public void register(User user){

try {
                membershipPointService.addPoint(Point point);
            } catch (Exception e) {
//省略...
            }
//省略...
        }
//省略...
   }

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

   @Service
public class MembershipPointServiceImpl implements MembershipPointService{

@Transactional(propagation = Propagation.NESTED)
public void addPoint(Point point){

try {
                recordService.addRecord(Record record);
            } catch (Exception e) {
//省略...
            }
//省略...
        }
//省略...
   }

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

   @Service
public class RecordServiceImpl implements RecordService{

@Transactional(propagation = Propagation.NOT_SUPPORTED)
public void addRecord(Record record){


//省略...
        }
//省略...
   }

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