什么是事务传播机制 事务的传播机制，顾名思义就是多个事务方法之间调用，事务如何在这些方法之间传播。

举个例子，方法 A 是一个事务的方法，方法 A 执行的时候调用了方法 B,此时方法 B 有无事务以及是否需要事务都会对方法 A 和方法 B 产生不同的影响，而这个影响是由两个方法的事务传播机制决定的。

传播属性 Propagation 枚举 Spring 对事务的传播机制在 Propagation 枚举中定义了7个分类：

• REQUIRED 默认
• SUPPORTS 支持
• MANDATORY 强制
• REQUIRES_NEW 新建
• NOT_SUPPORTED 不支持
• NEVER 从不
• NESTED 嵌套

事务的传播机制，是 spring 规定的。因为在开发中，最简单的事务是，业务代码都处于同一个事务下，这也是默认的传播机制，如果出现的报错，所有的数据回滚。
但是在处理复杂的业务逻辑时，方法之间的调用，有以下的需求：

• 调用的方法需要新增一个事务，新事务和原来的事务各自独立。
• 调用的方法不支持事务
• 调用的方法是一个嵌套的事务

7种传播机制详解 首先创建两个方法 A 和 B 实现数据的插入，插入数据A:

public class AService { public void A(String name) { userService.insertName("A-" + name); }}

插入数据B:

public class BService { public void B(String name) { userService.insertName("B-" + name); }}

使用伪代码创建 mainTest 方法和 childTest 方法

public void mainTest(String name){ // 存入a1 A(a1); childTest(name); }

main 调用 test 方法，其中

public void childTest(String name){ // 存入b1 B(b1); throw new RuntimeException(); // 存入 b2 B2(b2); }

以上伪代码，调用 mainTest 方法，如果mainTest 和childTest 都不使用事务的话，数据存储的结果是如何呢？
因为都没使用事务，所以 a1 和 b1 都存到成功了，而之后抛出异常之后，b2是不会执行的。所以 a1 和 b1 都插入的数据，而 b2 没有插入数据。
REQUIRED（默认事务）

/** * Support a current transaction, create a new one if none exists. * Analogous to EJB transaction attribute of the same name. * This is the default setting of a transaction annotation. */ REQUIRED(TransactionDefinition.PROPAGATION_REQUIRED),

如果当前不存在事务，就新建一个事务。如果存在事务，就加入到当前事务。这是一个默认的事务。
示例1：根据场景举个例子，在 childTest 添加事务，设置传播属性为 REQUIRED，伪代码如下：

public void mainTest(String name){ // 存入a1 A(a1); childTest(name); } @Transactional(propagation = Propagation.REQUIRED) public void childTest(String name){ // 存入b1 B(b1); throw new RuntimeException(); }

因为 mainTest 没有事务，而 childTest 又是新建一个事务，所以 a1 添加成功。在 childTest 因为抛出了异常，不会执行 b2 添加，而 b1 添加回滚。最终 a1 添加成功，b1没添加成功。
示例2：在 mainTest 和 childTest 都添加事务，传播属性都为 REQUIRED，伪代码如下：

@Transactional(propagation = Propagation.REQUIRED) public void mainTest(String name) { // 存入a1 A(a1); childTest(name); } @Transactional(propagation = Propagation.REQUIRED) public void childTest(String name) { // 存入b1 B(b1); throw new RuntimeException(); }

根据 REQUIRED 传播属性，如果存在事务，就加入到当前事务。两个方法都属于同一个事务，同一个事务的话，如果有发生异常，则全部都回滚。所以 a1 和 b1 都没添加成功。
SUPPORTS

/** * Support a current transaction, execute non-transactionally if none exists. * Analogous to EJB transaction attribute of the same name. * Note: For transaction managers with transaction synchronization, */

如果当前没有事务，则以非事务的方式运行。如果存在事务，就加入到当前事务。
示例3：childTest 添加事务，传播属性设置为 SUPPORTS，伪代码如下：

public void mainTest(String name) { A(a1); childTest(name); } @Transactional(propagation = Propagation.SUPPORTS) public void childTest(String name) { B(b1); throw new RuntimeException(); }

传播属性为 SUPPORTS，如果没有事务，就以非事务的方式运行。表明两个方法都没有使用事务，没有事务的话，a1、b1 都添加成功。
示例4：mainTest 添加事务，设置传播属性为 REQUIRED。childTest 添加事务，设置传播属性为 SUPPORTS，伪代码如下：

@Transactional(propagation = Propagation.REQUIRED) public void mainTest(String name) { A(a1); childTest(name); } @Transactional(propagation = Propagation.SUPPORTS) public void childTest(String name) { B(b1); throw new RuntimeException(); B2(b2); }

SUPPORTS 传播属性，如果存在事务，就加入到当前事务。mainTest 和 childTest 都属于同一个事务，而 childTest 抛出异常，a1 和b1 添加都回滚，最终 a1、b1 添加失败。
MANDATORY

/** * Support a current transaction, throw an exception if none exists. * Analogous to EJB transaction attribute of the same name. */

如果存在事务，就加入到当前事务。如果不存在事务，就报错。
这就说明如果想调用 MANDATORY 传播属性的方法，一定要有事务，不然就会报错。

MANDATORY 类似功能限制，必须要被有事务的方法的调用，不然就会报错。

示例5： 首先在 childTest 添加事务，设置传播属性为 MANDATORY，伪代码如下：

public void mainTest(String name) { A(a1); childTest(name); } @Transactional(propagation = Propagation.MANDATORY) public void childTest(String name) { B(b1); throw new RuntimeException(); B2(b2); }

在控制台直接报错：

No existing transaction found for transaction marked with propagation 'mandatory'

说明被标记为 mandatory 传播属性没找到事务，直接报错。因为 mainTest 没有事务，a1 添加成功。而 childTest 由于报错，b1 添加失败。
示例6： mainTest 添加事务，设置传播属性为 REQUIRED。childTest 添加事务，设置传播属性为 MANDATOR，伪代码如下：

@Transactional(propagation = Propagation.REQUIRED) public void mainTest(String name) { A(a1); childTest(name); } @Transactional(propagation = Propagation.MANDATORY) public void childTest(String name) { B(b1); throw new RuntimeException(); }

如果存在事务，就把事务加入到当前事务。同一个事务中 childTest 抛出异常，a1 和 b1 添加被回滚，所以a1 和 b1添加失败。
REQUIRES_NEW

/** * Create a new transaction, and suspend the current transaction if one exists. * Analogous to the EJB transaction attribute of the same name. * NOTE: Actual transaction suspension will not work out-of-the-box */

创建一个新的事务。如果存在事务，就将事务挂起。

无论是否有事务，都会创建一个新的事务。

示例7：childTest 添加事务，设置传播属性为 REQUIRES_NEW，伪代码如下：

public void mainTest(String name) { A(a1); childTest(name); } @Transactional(propagation = Propagation.REQUIRES_NEW) public void childTest(String name) { B(b1); throw new RuntimeException(); }

mainTest 不存在事务，a1 添加成功，childTest 新建了一个事务，报错，回滚 b1。所以 a1 添加成功，b1 添加失败。
示例8：mainTest 添加事务，设置传播属性为 REQUIRED。childTest 添加事务，设置传播属性为 REQUIRES_NEW，伪代码如下：

@Transactional(propagation = Propagation.REQUIRED) public void mainTest(String name) { A(a1); childTest(name); } @Transactional(propagation = Propagation.REQUIRES_NEW) public void childTest(String name) { B(b1); throw new RuntimeException(); }

mainTest 创建了一个事务，childTest 新建一个事务，在 childTest 事务中，抛出异常，b1 回滚，异常抛到 mainTest 方法，a1 也回滚，最终 a1 和 b1 都回滚。
示例9：在示例8中，如果不想让 REQUIRES_NEW 传播属性影响到被调用事务，将异常捕获就不会影响到被调用事务。

@Transactional(propagation = Propagation.REQUIRED) public void mainTest(String name) { A(a1); try { childTest(name); } catch (Exception e) { e.printStackTrace(); } } @Transactional(propagation = Propagation.REQUIRES_NEW) public void childTest(String name) { B(b1); throw new RuntimeException(); }

childTest 抛出了异常，在 mainTest 捕获了，对 mainTest 没有影响，所以 b1 被回滚，b1 添加失败，a1 添加成功。
示例10：mainTest 设置传播属性为 REQUIRED，并在 mainTest 抛出异常。childTest 同样设置 REQUIRES_NEW 传播属性，伪代码如下：

@Transactional(propagation = Propagation.REQUIRED) public void mainTest(String name) { A(a1); childTest(name); throw new RuntimeException(); } @Transactional(propagation = Propagation.REQUIRES_NEW) public void childTest(String name) { B(b1); B2(b2); }

childTest 是一个新建的事务，只要不抛出异常是不会回滚，所以 b1 添加成功，而 mainTest 抛出了异常，a1 添加失败。

REQUIRES_NEW 传播属性如果有异常，只会从被调用方影响调用方，而调用方不会影响调用方，即 childTest 抛出异常会影响 mainTest，而 mainTest 抛出异常不会到 childTest。

NOT_SUPPORTED

/** * Execute non-transactionally, suspend the current transaction if one exists. * Analogous to EJB transaction attribute of the same name. * NOTE: Actual transaction suspension will not work out-of-the-box */

无论是否存在当前事务，都是以非事务的方式运行。
示例11：childTest 添加事务，设置传播属性为 NOT_SUPPORTED，伪代码如下：

public void mainTest(String name) { A(a1); childTest(name); } @Transactional(propagation = Propagation.NOT_SUPPORTED) public void childTest(String name) { B(b1); throw new RuntimeException(); }

NOT_SUPPORTED 都是以非事务的方式执行，childTest 不存在事务，b1 添加成功。而 mainTest 也是没有事务，a1 也添加成功。
示例12：childTest 添加事务，设置传播属性为 NOT_SUPPORTED，mainTest 添加默认传播属性 REQUIRED，伪代码如下：

@Transactional(propagation = Propagation.REQUIRED) public void mainTest(String name) { A(a1); childTest(name); } @Transactional(propagation = Propagation.NOT_SUPPORTED) public void childTest(String name) { B(b1); throw new RuntimeException(); }

其中 childTest 都是以非事务的方式执行，b1 添加成功。而 mainTest 存在事务，报错后回滚，a1 添加失败。
NEVER

/** * Execute non-transactionally, throw an exception if a transaction exists. * Analogous to EJB transaction attribute of the same name. */

不使用事务，如果存在事务，就抛出异常。

NEVER 的方法不使用事务，调用 NEVER 方法如果有事务，就抛出异常。

示例13：childTest 添加 NEVER 传播属性，伪代码如下：

public void mainTest(String name) { A(a1); childTest(name); } @Transactional(propagation = Propagation.NEVER) public void childTest(String name) { B(b1); throw new RuntimeException(); B2(b2); }

NEVER 不使用事务，mainTest 也不使用事务，所以 a1 和 b1 都添加成功，b2添加失败。
示例14： mainTest 添加 REQUIRED 传播属性，childTest 传播属性设置为 NEVER，伪代码如下：

@Transactional(propagation = Propagation.REQUIRED) public void mainTest(String name) { A(a1); childTest(name); } @Transactional(propagation = Propagation.NEVER) public void childTest(String name) { B(b1); throw new RuntimeException(); }

mainTest 存在事务，导致 childTest 报错，b1添加失败，childTest 抛错到 mainTest，a1 添加失败。
NESTED

/** * Execute within a nested transaction if a current transaction exists, * behave like PROPAGATION_REQUIRED else. There is no analogous feature in EJB. * Note: Actual creation of a nested transaction will only work on specific */

如果当前事务存在，就运行一个嵌套事务。如果不存在事务，就和 REQUIRED 一样新建一个事务。
示例15: childTest 设置 NESTED 传播属性，伪代码如下：

public void mainTest(String name) { A(a1); childTest(name); } @Transactional(propagation = Propagation.NESTED) public void childTest(String name) { B(b1); throw new RuntimeException(); }

在 childTest 设置 NESTED 传播属性，相当于新建一个事务，所以 b1 添加失败， mainTest 没有事务，a1 添加成功。
示例16：设置 mainTest 传播属性为 REQUIRED，新建一个事务，并在方法最后抛出异常。 childTest 设置属性为 NESTED，伪代码如下：

@Transactional(propagation = Propagation.REQUIRED) public void mainTest(String name) { A(a1); childTest(name); throw new RuntimeException(); } @Transactional(propagation = Propagation.NESTED) public void childTest(String name) { B(b1); B2(b2); }

childTest 是一个嵌套的事务，当主事务的抛出异常时，嵌套事务也受影响，即 a1、b1 和 b2 都添加失败。和示例10不同的是，示例10不会影响 childTest 事务。

• NESTED 和 REQUIRED_NEW 的区别：
  
  • REQUIRED_NEW 是开启一个新的事务，和调用的事务无关。调用方回滚，不会影响到 REQUIRED_NEW 事务。
  • NESTED 是一个嵌套事务，是调用方的一个子事务，如果调用方事务回滚，NESTED 也会回滚。

示例17：和示例16一样，在 mainTest 设置传播属性为 REQUIRED，childTest 设置传播属性为 NESTED，不同的是，在 mainTest 捕获 childTest 抛出的异常，伪代码如下：

@Transactional(propagation = Propagation.REQUIRED) public void mainTest(String name) { A(a1); try { childTest(name); } catch (RuntimeException e) { e.printStackTrace(); } } @Transactional(propagation = Propagation.NESTED) public void childTest(String name) { B(b1); B2(b2); throw new RuntimeException(); }

childTest 是一个子事务，报错回滚，b1 和 b2 都添加失败。而 mainTest 捕获了异常，不受异常影响，a1 添加成功。
示例18：将示例2改造一下，mainTest 捕获 childTest 抛出的异常，伪代码如下：

@Transactional(propagation = Propagation.REQUIRED) public void mainTest(String name) { A(a1); try { childTest(name); } catch (RuntimeException e) { e.printStackTrace(); } } @Transactional(propagation = Propagation.REQUIRED) public void childTest(String name) { B(b1); B2(b2); throw new RuntimeException(); }

mainTest 和 childTest 两个方法都处于同一个事务，如果有一个方法报错回滚，并且被捕获。整个事务如果还有数据添加就会抛出 Transaction rolled back because it has been marked as rollback-only 异常，同一个事务，不能出现有的回滚了，有的不回滚，要么一起回滚，要不一起执行成功。所以全部数据都添加失败。

• 对比示例17和示例18，NESTED 和 REQUIRED 的区别：
  
  • REQUIRED 传播属性表明调用方和被调用方都是使用同一个事务，被调用方出现异常，无论异常是否被捕获，因为属于同一个事务，只要发生异常，事务都会回滚。
  • NESTED 被调用方出现异常，只要异常被捕获，只有被调用方事务回滚，调用方事务不受影响。

总结

传播属性	总结
REQUIRED	默认属性，所有的事务都处于同一个事务下，出现异常，不管是否捕获所有事务回滚
SUPPORTS	如果不存事务，就以非事务的方式运行，存在事务就加入该事务
MANDATORY	强制调用方添加事务，如果不存在事务就报错，存在事务就加入该事务
REQUIRES_NEW	无论调用方是否存在事务，都会创建新的事务，并且调用方异常不会影响 REQUIRES_NEW事务
NOT_SUPPORTED	无论是否调用方是否存在事务，都是以非事务的方式执行，出现异常也会回滚
NEVER	不用事务，存在事务就报错，和 MANDATORY 相反
NESTED	嵌套事务，新建一个子事务，事务执行相互独立，如果调用方出现异常，直接回滚

测试源码

• 传播属性源码

参考

• 带你读懂Spring 事务——事务的传播机制

【18个示例详解 Spring 事务传播机制(附测试源码)】如果觉得文章对你有帮助的话，请点个赞吧!

推荐阅读

• 

  社保需要交多少年才可以领养老金?养老金是怎么算的
• 

  人造棉是棉绸吗
• 

  教你如何开挂，教你如何自己做挂不用担心被抓
• 

  老竹大方茶的产地及品质特征介绍
• 

  八小时工作制最早出现在哪个国家
• 

  故事里的人——石神与石泓
• 

  家里的小猫得了猫藓,医生照了一下说很严重开了八百多块钱药,请问这个花费正常吗,以后还要花多少钱？
• 

  锦鲤花养殖注意事项 锦鲤水花养殖注意事项
• 

  抖音朋友圈射箭穿心表白图制作教程
• 

  外用药能否治疗早泄 早泄的外用药
• 

  佳能5d拍摄技巧 佳能5ds拍体育
• 

  让龙猫亲近自己的方法有吗
• 

  重庆被起诉了但是实在没有钱还怎么办
• 

  科目4多少分才算合格
• 

  笔记|多线程基础
• 

  用户|为什么iQOO Z3能不让用户做“取舍”？
• 

  FGO情人节三期高难本怎么打 2019女帝情人节高难本攻略
• 

  一辈子闺蜜经典句子有哪些
• 

  大金空调制冷外机不工作怎么办,一般情况就放置在这个位置
• 

  如何搭建直播电商平台，如何做好电商直播平台

• Java|Java基础——数组
• 人工智能|干货！人体姿态估计与运动预测
• java简介|Java是什么（Java能用来干什么？）
• Java|规范的打印日志
• Linux|109 个实用 shell 脚本
• 程序员|【高级Java架构师系统学习】毕业一年萌新的Java大厂面经，最新整理
• Spring注解驱动第十讲--@Autowired使用
• SqlServer|sql server的UPDLOCK、HOLDLOCK试验
• jvm|【JVM】JVM08(java内存模型解析[JMM])
• 技术|为参加2021年蓝桥杯Java软件开发大学B组细心整理常见基础知识、搜索和常用算法解析例题（持续更新...)