34.Spring事务传播行为详解
前言
Spring在TransactionDefinition接口中规定了7种类型的事务传播行为。事务传播行为是Spring框架独有的事务增强特性，他不属于的事务实际提供方数据库行为。这是Spring为我们提供的强大的工具箱，使用事务传播行可以为我们的开发工作提供许多便利。但是人们对他的误解也颇多，你一定也听过“service方法事务最好不要嵌套”的传言。要想正确的使用工具首先需要了解工具。本文对七种事务传播行为做详细介绍，内容主要代码示例的方式呈现。
基础概念
1.什么是事务传播行为？
事务传播行为用来描述由某一个事务传播行为修饰的方法被嵌套进另一个方法的时事务如何传播。
用伪代码说明：
```java public void methodA(){ methodB(); //doSomething }
@Transaction(Propagation=XXX) public void methodB(){ //doSomething } ```
代码中methodA()方法嵌套调用了methodB()方法，methodB()的事务传播行为由@Transaction(Propagation=XXX)设置决定。
这里需要注意的是methodA()并没有开启事务，某一个事务传播行为修饰的方法比如methodB()并不是必须要在开启事务的外围方法中调用比如methodA()。在methodA()中调用了methodB(),即使methodA()没有开启事务,methodB()开启了事务,
2、Spring中七种事务传播行为
| 事务传播行为类型 | 说明 | | ------------------------- | ---------------------------------------------------------- | | PROPAGATIONREQUIRED | 如果当前没有事务，就新建一个事务，如果已经存在一个事务中，加入到这个事务中。这是最常见的选择也是默认的选择。 | | PROPAGATIONSUPPORTS | 支持当前事务，如果当前没有事务，就以非事务方式执行。 | | PROPAGATIONMANDATORY | 使用当前的事务，如果当前没有事务，就抛出异常。 | | PROPAGATIONREQUIRESNEW | 新建事务，如果当前存在事务，把当前事务挂起。 | | PROPAGATIONNOTSUPPORTED | 以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。 | | PROPAGATIONNEVER | 以非事务方式执行，如果当前存在事务，则抛出异常。 | | PROPAGATIONNESTED | 如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则执行与PROPAGATIONREQUIRED类似的操作。 |
定义非常简单，也很好理解，下面我们就进入代码测试部分，验证我们的理解是否正确。
代码验证
文中代码以传统三层结构中两层呈现，即Service和Dao层，由Spring负责依赖注入和注解式事务管理，DAO层由Mybatis实现，你也可以使用任何喜欢的方式，例如，Hibernate,JPA,JDBCTemplate等。数据库使用的是MySQL数据库，你也可以使用任何支持事务的数据库，并不会影响验证结果。
首先我们在数据库中创建两张表：
user1
CREATE TABLE `user1` ( `id` INTEGER UNSIGNED NOT NULL AUTO_INCREMENT, `name` VARCHAR(45) NOT NULL DEFAULT '', PRIMARY KEY(`id`) ) ENGINE = InnoDB;
user2
CREATE TABLE `user2` ( `id` INTEGER UNSIGNED NOT NULL AUTO_INCREMENT, `name` VARCHAR(45) NOT NULL DEFAULT '', PRIMARY KEY(`id`) ) ENGINE = InnoDB;
然后编写相应的Bean和DAO层代码：
User1
public class User1 { private Integer id; private String name; //get和set方法省略... }
User2
public class User2 { private Integer id; private String name; //get和set方法省略... }
User1Mapper
public interface User1Mapper { int insert(User1 record); User1 selectByPrimaryKey(Integer id); //其他方法省略... }
User2Mapper
public interface User2Mapper { int insert(User2 record); User2 selectByPrimaryKey(Integer id); //其他方法省略... }
最后也是具体验证的代码由service层实现，下面我们分情况列举。
1、PROPAGATION_REQUIRED
我们为User1Service和User2Service相应方法加上Propagation.REQUIRED属性。
User1Service方法：
@Service public class User1ServiceImpl implements User1Service { //省略其他... @Override @Transactional(propagation = Propagation.REQUIRED) public void addRequired(User1 user){ user1Mapper.insert(user); } }
User2Service方法：
``` @Service public class User2ServiceImpl implements User2Service { //省略其他... @Override @Transactional(propagation = Propagation.REQUIRED) public void addRequired(User2 user){ user2Mapper.insert(user); } @Override @Transactional(propagation = Propagation.REQUIRED) public void addRequiredException(User2 user){ user2Mapper.insert(user); throw new RuntimeException(); }
} ```
1.1 场景一
此场景外围方法没有开启事务。
验证方法1：
``` @Override public void notransactionexceptionrequired_required(){ User1 user1=new User1(); user1.setName("张三"); user1Service.addRequired(user1);
User2 user2=new User2();
user2.setName("李四");
user2Service.addRequired(user2);
throw new RuntimeException();
}```
验证方法2：
``` @Override public void notransactionrequiredrequired_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 场景二
外围方法开启事务，这个是使用率比较高的场景。
验证方法1：
``` @Override @Transactional(propagation = Propagation.REQUIRED) public void transactionexceptionrequired_required(){ User1 user1=new User1(); user1.setName("张三"); user1Service.addRequired(user1);
User2 user2=new User2();
user2.setName("李四");
user2Service.addRequired(user2);
throw new RuntimeException();
}```
验证方法2：
``` @Override @Transactional(propagation = Propagation.REQUIRED) public void transactionrequiredrequired_exception(){ User1 user1=new User1(); user1.setName("张三"); user1Service.addRequired(user1);
User2 user2=new User2();
user2.setName("李四");
user2Service.addRequiredException(user2);
}```
验证方法3：
``` @Transactional @Override public void transactionrequiredrequiredexceptiontry(){ 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、PROPAGATIONREQUIRESNEW
我们为User1Service和User2Service相应方法加上Propagation.REQUIRES_NEW属性。 *User1Service方法：*
@Service public class User1ServiceImpl implements User1Service { //省略其他... @Override @Transactional(propagation = Propagation.REQUIRES_NEW) public void addRequiresNew(User1 user){ user1Mapper.insert(user); } @Override @Transactional(propagation = Propagation.REQUIRED) public void addRequired(User1 user){ user1Mapper.insert(user); } }
User2Service方法：
``` @Service public class User2ServiceImpl implements User2Service { //省略其他... @Override @Transactional(propagation = Propagation.REQUIRES_NEW) public void addRequiresNew(User2 user){ user2Mapper.insert(user); }
@Override
@Transactional(propagation = Propagation.REQUIRES_NEW)
public void addRequiresNewException(User2 user){
user2Mapper.insert(user);
throw new RuntimeException();
}} ```
2、1 场景一
外围方法没有开启事务。
验证方法1：
``` @Override public void notransactionexceptionrequiresNew_requiresNew(){ User1 user1=new User1(); user1.setName("张三"); user1Service.addRequiresNew(user1);
User2 user2=new User2();
user2.setName("李四");
user2Service.addRequiresNew(user2);
throw new RuntimeException();
}```
验证方法2：
``` @Override public void notransactionrequiresNewrequiresNew_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 场景二
外围方法开启事务。
验证方法1：
``` @Override @Transactional(propagation = Propagation.REQUIRED) public void transactionexceptionrequiredrequiresNewrequiresNew(){ 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();
}```
验证方法2：
``` @Override @Transactional(propagation = Propagation.REQUIRED) public void transactionrequiredrequiresNewrequiresNewexception(){ 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);
}```
验证方法3：
``` @Override @Transactional(propagation = Propagation.REQUIRED) public void transactionrequiredrequiresNewrequiresNewexception_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修饰的内部方法依然会单独开启独立事务，且与外部方法事务也独立，内部方法之间、内部方法和外部方法事务均相互独立，互不干扰。