面试过很多人，大部分都能把事务的四个特性及隔离级别说得七七八八，但当问到 Spring 的传播行为时，就基本上没人能说出个一二三了。

我们都知道，一个事务要么成功，要么失败。但当若干个事务配合完成一个复杂任务时，就不能简单的这样一刀切了。我们需要根据任务之间的亲疏关系来指定哪些任务需要联动回滚，哪些任务即使失败也不会影响其他任务。要解决这个问题，就需要了解事务的传播行为了。Spring 中有七种事务的传播行为，如下表所示：

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

Spring 可以通过 @Transactional 注解的 propagation 属性来设置不同的传播行为策略。Spring 为此提供了一个枚举类 Propagation，源码如下：

package org.springframework.transaction.annotation;import org.springframework.transaction.TransactionDefinition;public enum Propagation { /** * 需要事务，它是默认传播行为，如果当前存在事务，就沿用当前事务， * 否则新建一个事务运行内部方法 */ REQUIRED(TransactionDefinition.PROPAGATION_REQUIRED), /** * 支持事务，如果当前存在事务，就沿用当前事务， * 如果不存在，则继续采用无事务的方式运行内部方法 */ SUPPORTS(TransactionDefinition.PROPAGATION_SUPPORTS), /** * 必须使用事务，如果当前没有事务，则会抛出异常， * 如果存在当前事务，则沿用当前事务 */ MANDATORY(TransactionDefinition.PROPAGATION_MANDATORY), /** * 无论当前事务是否存在，都会创建新事务运行方法， * 这样新事务就可以拥有新的锁和隔离级别等特性，与当前事务相互独立 */ REQUIRES_NEW(TransactionDefinition.PROPAGATION_REQUIRES_NEW), /** * 不支持事务，当前存在事务时，将挂起事务，运行方法 */ NOT_SUPPORTED(TransactionDefinition.PROPAGATION_NOT_SUPPORTED), /** * 不支持事务，如果当前方法存在事务，则抛出异常，否则继续使用无事务机制运行 */ NEVER(TransactionDefinition.PROPAGATION_NEVER), /** * 在当前方法调用内部方法时，如果内部方法发生异常， * 只回滚内部方法执行过的 SQL ，而不回滚当前方法的事务 */ NESTED(TransactionDefinition.PROPAGATION_NESTED); ……}

接下来我们通过对其中三种最常用的（REQUIRED、REQUIRES_NEW、NESTED）策略进行对比来更深入的理解。以下测试均在外部方法开启事务的情况下进行，因为在外部没有事务的情况下，三者都会新建事务，效果一样。

REQUIRED

当内部方法的事务传播行为设置为 REQUIRED 时，内部方法会加入外部方法的事务。我们在 UserServiceImpl 中添加如下方法：

@Servicepublic class UserServiceImpl extends ServiceImpl implements UserService { @Autowired private UserMapper mapper; @Override @Transactional(propagation = Propagation.REQUIRED) public void addWithRequired(User user) { mapper.insert(user); } @Override @Transactional(propagation = Propagation.REQUIRED) public void addWithRequiredAndException(User user) { mapper.insert(user); throw new RuntimeException(); }}

创建 TransactionServiceImpl 类，并添加如下方法：

@Slf4j@Servicepublic class TransactionServiceImpl implements TransactionService { @Autowired private UserService userService; @Override public void noTransaction_required_required_externalException() { User xiaoShui = new User().setName(“小水”); User xiaoJing = new User().setName(“小镜”); userService.addWithRequired(xiaoShui); userService.addWithRequired(xiaoJing); throw new RuntimeException(); } @Override public void noTransaction_required_requiredException() { User xiaoShui = new User().setName(“小水”); User xiaoJing = new User().setName(“小镜”); userService.addWithRequired(xiaoShui); userService.addWithRequiredAndException(xiaoJing); } @Override @Transactional public void transaction_required_required_externalException() { User xiaoShui = new User().setName(“小水”); User xiaoJing = new User().setName(“小镜”); userService.addWithRequired(xiaoShui); userService.addWithRequired(xiaoJing); throw new RuntimeException(); } @Override @Transactional public void transaction_required_requiredException() { User xiaoShui = new User().setName(“小水”); User xiaoJing = new User().setName(“小镜”); userService.addWithRequired(xiaoShui); userService.addWithRequiredAndException(xiaoJing); } @Override @Transactional public void transaction_required_requiredException_try() { User xiaoShui = new User().setName(“小水”); User xiaoJing = new User().setName(“小镜”); userService.addWithRequired(xiaoShui); try { userService.addWithRequiredAndException(xiaoJing); } catch (Exception e) { log.error(“发生异常，事务回滚！”); } }}

结果分析如下表所示：

方法	结果	分析
noTransaction_required_required_externalException	小水和小镜均成功入库	外部方法未开启事务，所以所有插入操作均未受到外部异常影响
noTransaction_required_requiredException	小水入库，小镜未入库	外部方法未开启事务，内部方法事务各自独立，互不影响，「小镜」的插入方法发生异常回滚，但「小水」的插入方法不受影响
transaction_required_required_externalException	小水和小镜均未入库	外部方法开启事务，所有内部方法均加入外部方法的事务中。而外部方法发生异常，所以导致所有操作都发生回滚
transaction_required_requiredException	小水和小镜均未入库	外部方法开启事务，所有内部方法均加入外部方法的事务中。由于「小镜」的插入方法发生异常，此时所有方法都处于同一个事务中，所以导致所有操作都发生回滚
transaction_required_requiredException_try	小水和小镜均未入库	外部方法开启事务，所有内部方法均加入外部方法的事务中。由于「小镜」的插入方法发生异常，此时所有方法都处于同一个事务中，即使发生异常的部分被 try-catch 住，所有操作仍然会回滚

前面四种情况都比较好理解，很多人不能理解最后一种情况：我都 try-catch 了你还想怎样？这里的关键点在于所有方法都处于同一个事务中，此时「小镜」的插入方法发生异常，那么这个方法所在的事务就会被 Spring 设置为 rollback 状态。因为异常被 catch 了，所以外部方法执行完要进行 commit 操作，这时却发现当前事务已经处于 rollback 状态了，虽然它不知道哪里出了问题，但也只能听从指挥，回滚所有操作了。

PS：由于外部方法不开启事务的情况，在每种传播行为下结果都是类似的，所以后面不再给出示例。

REQUIRES_NEW

当内部方法的传播行为设置为 REQUIRES_NEW 时，内部方法会先将外部方法的事务挂起，然后开启一个新的事务。在 UserServiceImpl 中添加如下方法：

@Servicepublic class UserServiceImpl extends ServiceImpl implements UserService { … @Override @Transactional(propagation = Propagation.REQUIRES_NEW) public void addWithRequiredNew(User user) { mapper.insert(user); } @Override @Transactional(propagation = Propagation.REQUIRES_NEW) public void addWithRequiredNewAndException(User user) { mapper.insert(user); throw new RuntimeException(); }}

在 TransactionServiceImpl 中添加如下方法：

@Slf4j@Servicepublic class TransactionServiceImpl implements TransactionService { … @Override @Transactional public void transaction_required_requiredNew_externalException() { User xiaoShui = new User().setName(“小水”); User xiaoJing = new User().setName(“小镜”); userService.addWithRequired(xiaoShui); userService.addWithRequiredNew(xiaoJing); throw new RuntimeException(); } @Override @Transactional public void transaction_required_requiredNew_requiredNewException() { User xiaoShui = new User().setName(“小水”); User xiaoJing = new User().setName(“小镜”); User shuiJing = new User().setName(“水镜”); userService.addWithRequired(xiaoShui); userService.addWithRequiredNew(xiaoJing); userService.addWithRequiredNewAndException(shuiJing); } @Override @Transactional public void transaction_required_requiredNewException_try() { User xiaoShui = new User().setName(“小水”); User xiaoJing = new User().setName(“小镜”); User shuiJing = new User().setName(“水镜”); userService.addWithRequired(xiaoShui); userService.addWithRequiredNew(xiaoJing); try { userService.addWithRequiredNewAndException(shuiJing); } catch (Exception e) { log.error(“发生异常，事务回滚！”); } }}

结果分析如下表所示：

方法	结果	分析
transaction_required_requiredNew_externalException	小水未入库，小镜入库	外部方法开启事务，「小水」的插入方法和外部方法在同一个事务中，跟随外部方法发生回滚；「小镜」的插入方法开启一个独立的新事务，不受外部方法异常的影响
transaction_required_requiredNew_requiredNewException	小水未入库，小镜入库，水镜未入库	外部方法开启事务，「水镜」的插入方法开启一个独立的新事务，因为发生异常，所以自己回滚了；「水镜」的异常没有做处理，因此会被外部方法感知到，「小水」的插入方法和外部方法在同一个事务中，跟随外部方法发生回滚；「小镜」的插入方法也会开启一个独立的新事务，因此不会受到任何方法的影响，成功入库
transaction_required_requiredNewException_try	小水和小镜入库，水镜未入库	外部方法开启事务，「水镜」的插入方法开启一个独立的新事务，因为发生异常，所以自己回滚了；「水镜」的异常被 try-catch 处理了，其他方法正常提交「小水」和「小镜」成功入库

NESTED

当内部方法的传播行为设置为 NESTED 时，内部方法会开启一个新的嵌套事务（子事务）。在 UserServiceImpl 中添加如下方法：

@Servicepublic class UserServiceImpl extends ServiceImpl implements UserService { … @Override @Transactional(propagation = Propagation.NESTED) public void addWithNested(User user) { mapper.insert(user); } @Override @Transactional(propagation = Propagation.NESTED) public void addWithNestedAndException(User user) { mapper.insert(user); throw new RuntimeException(); }}

在 TransactionServiceImpl 中添加如下方法：

@Slf4j@Servicepublic class TransactionServiceImpl implements TransactionService { … @Override @Transactional public void transaction_nested_nested_externalException() { User xiaoShui = new User().setName(“小水”); User xiaoJing = new User().setName(“小镜”); userService.addWithNested(xiaoShui); userService.addWithNested(xiaoJing); throw new RuntimeException(); } @Override @Transactional public void transaction_nested_nestedException() { User xiaoShui = new User().setName(“小水”); User xiaoJing = new User().setName(“小镜”); userService.addWithNested(xiaoShui); userService.addWithNestedAndException(xiaoJing); } @Override @Transactional public void transaction_nested_nestedException_try() { User xiaoShui = new User().setName(“小水”); User xiaoJing = new User().setName(“小镜”); User shuiJing = new User().setName(“水镜”); userService.addWithRequired(xiaoShui); userService.addWithNested(xiaoJing); try { userService.addWithNestedAndException(shuiJing); } catch (Exception e) { log.error(“发生异常，事务回滚！”,e); } }}

结果分析如下表所示：

方法	结果	分析
transaction_nested_nested_externalException	小水和小镜均未入库	外部方法开启事务，内部方法开启各自的子事务，外部方法发生异常，主事务回滚，子事务跟随主事务回滚
transaction_nested_nestedException	小水和小镜均未入库	外部方法开启事务，内部方法开启各自的子事务，「小镜」的插入方法发生异常回滚自己的子事务；「小镜」的异常没有做处理，因此会被外部方法感知到，「小水」的插入方法在外部方法的子事务中，所以跟随主事务回滚
transaction_nested_nestedException_try	小水和小镜入库，水镜未入库	外部方法开启事务，「小镜」和「水镜」开启各自的子事务，「小水」加入外部方法的事务。「水镜」的插入方法发生异常回滚自己的子事务；「水镜」的异常被 try-catch 处理了，其他方法正常提交「小水」和「小镜」成功入库