18个实列详解 Spring 事务传播机制

Java架构师小森 Java架构师小森 博客等级 墨衍会员 · AI 创作全网分发 墨衍智能分发 本文由作者通过墨衍一键同步至各平台 1分发平台 300+累计阅读 347平均单平台 已同步平台 优快云 微信公众号 微博 知乎 掘金 百家号 博客园 抖音 小红书 你的文章也可以这样分发 墨衍会员 ¥399起/年，写一次发全网 我也要 码龄5年
关注
原创 最新推荐文章于 2026-07-07 14:53:27 发布 347 阅读 AI 写同款· GEO 优化 ›
事务的传播机制 事务的传播机制 事务的传播行为就是在两个都启用了事务的方法进行嵌套调用时，外层事务和内层事务的执行动作，Spring支持七种传播方式，他们的效果如下： REQUIRED：如果有外层事务，则加入这个事务，否则开启一个新的事务 SUPPORTS：如果有外层事务，则加入这个事务，否则就以非事务方式执行 MANDATORY：如果有外层事务，则加入这个事务，否则抛出异常 REQUIRES_NEW：开启一个独立的新事务执行 NOT_SUPPORTED：方法不应该以事务方法执行，如果有外层事务，就以非事务方式执行 NE 阅读详情

 什么是事务传播机制

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

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

传播属性 Propagation 枚举

Spring 对事务的传播机制在 http://​ 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.
	 * <p>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.
	 * <p>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.
	 * <p><b>NOTE:</b> 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.
	 * <p><b>NOTE:</b> 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.
	 * <p>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嵌套事务，新建一个子事务，事务执行相互独立，如果调用方出现异常，直接回滚

测试源码

原文链接：https://juejin.cn/post/7054340368124346399

标签
#spring #java #后端 #经验分享 #开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
Spring、Springboot中事务传播机制（事物嵌套） Spring、Springboot中事务传播机制（事物嵌套） 事务传播机制： 事务的传播行为是针对嵌套事务而言。即是针对（需要事务的业务方法）调用（需要事务的业务方法）。以下案例的业务方法在不同的类下: 注意事项 以下案例的业务方法在不同的类下: 在同一个类下面不同的方法就算都有事务，调用的方法事务都是不会生效的。 意思是在A类的a方法调用b方法，a，b方法均有事务，直接调用b方法，事务是不会生效的。 原因是spring事务处理实际是基于动态代理生成类进行事务管理的，而直接调用b方法，调用的实际是当前类的 阅读详情

相关推荐

Ubuntu本地部署CodeX编程助手：CLI配置全指南

本地AI编程助手是当前开发者关注的核心技术趋势，指在不依赖云端API、保障代码隐私前提下，于本地环境运行具备代码理解、多语言补全与知识库检索能力的智能辅助工具。其技术原理涉及模型加载、API网关编排、向量数据库集成及系统级资源调度，关键价值在于可控性、低延迟与合规性。典型应用场景包括企业内网DevOps提效、边缘设备嵌入式开发支持，以及敏感代码场景下的离线编程增强。本文聚焦Ubuntu系统下基于CLI的手动配置路径，深入解析Ollama服务注册、Node.js版本锁定、API Key环境隔离及Qwen2.5

weixin_26804345的博客 591

18个示例详解 Spring 事务传播机制(附测试源码)

什么是事务传播机制 事务的传播机制，顾名思义就是多个事务方法之间调用，事务如何在这些方法之间传播。 举个例子，方法 A 是一个事务的方法，方法 A 执行的时候调用了方法 B,此时方法 B 有无事务以及是否需要事务都会对方法 A 和方法 B 产生不同的影响，而这个影响是由两个方法的事务传播机制决定的。 传播属性 Propagation 枚举 Spring 对事务的传播机制在 Propagation 枚举中定义了7个分类： REQUIRED 默认 SUPPORTS 支持 MANDATORY 强制

qq_42700121的博客 741

影刀rpa的使用一--读取excel表格数据并循环出每一项

1、全部展示2、运行结果展示之后可以按照各自的需求对excel中取出的数据进行处理。

qq_69268437的博客 1万+

Spring事务管理（详解+实例）

写这篇博客之前我首先读了《Spring in action》，之后在网上看了很多关于Spring事务管理的文章，具体参考文章如下： 1、将相应的接口依赖图理清出 2、将每个类的具体配置弄明白 3、将具体的配置给出来 4、给出具体的例子（一个声明式的一个编程式的）

Trigl的博客 9万+

新手入门：从零开始学习PCB飞针测试全流程（附常见问题解答）

本文详细介绍了PCB飞针测试的全流程，从核心原理、设备解析到实操步骤和常见问题解答，帮助新手快速掌握这一电子制造领域的关键质检技术。内容涵盖测试资料准备、参数设置、设备操作技巧以及故障排查方法，特别适合小批量PCB生产的质量检测需求。

weixin_29295541的博客 388

mcgs数据导出到U盘

mcgs触摸屏在工业中应用还是很多的，尤其他的脚本功能策略功能等将开放性放到了最大，让用户可以根据实际需求进行自由创作，正因为这样，对一些初学者就不是很友好，初学者想要简单操作就能实现功能，但是mcgs不可能两者兼备，在做工业设备，一些数据的采集保存就比较常见，但是mcgs没有相关按钮能够直接实现将数据导出到U盘的功能。这里我给大家讲解关于mcgs将报警历史记录、日志记录、历史数据记录导出到U盘的方法。

qq_24866535的博客 6230

事务传播机制的实际应用

我们在自测中就出现了这样的场景，我们的需求是update一个状态，并在之后的代码去筛选符合修改过的状态的数据再进行操作，例如这样的伪代码。默认可重复读，由于在update前查询过数据，所以即使新事物提交了，在当前事务中新事务的变更是不可见的。发现之后，我想着这种方法很好解决，就将update方法独立出来，加上@Transactional(propagation=REQUEST.NEW)注解，将它的传播机制定为REQUEST.NEW，作用是如果当前事务的外层有事务则独立出来视为新事物，不与外层事务关联。

m0_60407371的博客 215

livox avia平台搭建

livox雷达数据采集平台搭建

Shilong的博客 1308

【spring的事务】传播机制应用实践-单应用单数据源

都知道Spring可以通过增加@Transactional注解来支持事物。 根据阿里编码规范，一般建议加在方法级别，不要笼统的加在类的级别。 这个注解一般要加rollbackFor，就是指定哪些异常类型才要回滚事务 还有比较重要的，就是有个isolation属性，你可以自己手动调整事务的隔离级别。 问题： 一个加了@Transactional的事务方法，和嵌套了另外一个@Transactional的事务方法的时候，包括再次嵌入@Transactional事务方法的时候，如果出现异常， 是怎么传播的？ pub

hikeboy的博客 474

R | 提取文件夹内栅格数据的最小值、最大值、标准差和平均值

各位同学好，我们长需要用长时间序列栅格数据的平均值做变量的时间变化分析，用代码能够帮助我们省下很多时间。

qq_48539301的博客 448

使用 Simulink 进行电力电子系统的大信号模型仿真

电力电子系统（Power Electronics System）包括各种功率转换器（如 DC-DC 转换器、逆变器等）。这些设备中的关键组件（如 MOSFET、IGBT、电容器、电感器等）不仅影响系统的性能，还直接关系到系统的稳定性、效率和可靠性。因此，在设计阶段进行详细的建模和仿真至关重要。大信号模型仿真的目的是通过模拟系统在非线性条件下的真实行为，评估其瞬态响应、稳态性能以及对不同负载和输入电压变化的响应。通过本教程，我们介绍了如何使用 Simulink 进行电力电子系统的大信号模型仿真。背景介绍。

xiaoheshang_123的博客 303

Spring事务传播机制以及事务嵌套

事务传播机制以及事务嵌套场景

qq_45731464的博客 1863

IEM模型，地表粗糙度模拟

利用微波反演土壤水分时候，利用IEM模型可以实现对随机地表的模拟

通过18个实列为你详细讲解 Spring 事务传播机制

什么是事务传播机制 事务的传播机制，顾名思义就是多个事务方法之间调用，事务如何在这些方法之间传播。 举个例子，方法 A 是一个事务的方法，方法 A 执行的时候调用了方法 B,此时方法 B 有无事务以及是否需要事务都会对方法 A 和方法 B 产生不同的影响，而这个影响是由两个方法的事务传播机制决定的。 传播属性 Propagation 枚举 Spring 对事务的传播机制在 http://​ Propagation​ 枚举中定义了7个分类： REQUIRED 默认 SUPPORTS 支持 M

wdjnb的博客 125

lwip-2.0.3

lwip是瑞典计算机科学院(SICS)的Adam Dunkels 开发的一个小型开源的TCP/IP协议栈。实现的重点是在保持TCP协议主要功能的基础上减少对RAM 的占用。

Statistics and Machine Learning Toolbox

Statistics and Machine Learning Toolbox（带书签），MATLAB统计学习工具

spring事务传播机制

spring事务的7种传播机制解释，以及运用场景和结果分析

qq_38316918的博客 811

VC中sqlite的使用

在VC中对sqlite的使用，实现数据库大批数据的快速插入，读取数据库中的数据在ListCtrl中显示

Spring事务 - 事务传播机制

举个例子，方法 A 是一个事务的方法，方法 A 执行的时候调用了方法 B，此时方法 B 有无事务以及是否需要事务都会对方法 A 和方法 B 产生不同的影响，而这个影响是由两个方法的事务传播机制决定的。mainTest 创建了一个事务，childTest 新建一个事务，在 childTest 事务中，抛出异常，b1 回滚，异常抛到 mainTest 方法，a1 也回滚，最终 a1 和 b1 都回滚。mainTest 不存在事务，a1 添加成功，childTest 新建了一个事务，报错，回滚 b1。

xwnxwn的专栏 160

Spring事务7种传播机制（代码示例）

Spring事务7种传播机制（代码示例） 文章目录Spring事务7种传播机制（代码示例）前言1.项目环境2.相关资料2.1 Spring 源码2.2 官网地址3.示例代码3.1 无事务示例3.1.1 正常示例3.1.2 异常示例3.2 REQUIRED（默认）3.2.1 代码示例3.2.2 结果分析3.3 REQUIRES_NEW3.3.1 代码示例3.3.2 结果分析3.4 SUPPORTS3.4.1 代码示例3.4.2 结果分析3.5 MANDATORY3.5.1 代码示例3.5.2 结果分析3.6

谢文峰的博客 1545

Spring事务传播机制,看完这篇你就明白了

判断当前事务传播机制，默认事务则看此事务对象是否有数据库连接，没有则创建设置数据库的隔离级别,autocommit设置为false，设置超时时间把数据连接conn放入ThreadLocal中执行insertUser方法中的sql 时,获取此线程的数据库连接调用自身的insertTest方法insertTest抛出异常，异常被捕获看完以上的流程后,不知道大家会不会已经有答案了,实际上，这两个方法执行的sql还是会提交成功的，我给大家来分析一下里面的细节。

2401_83641098的博客 681

Spring的事务传播机制

1）特性A、当前存在事务，加入；B、当前不存在事务，新开启一个事务。（2）提交外层事务提交了，内层才会提交（3）回滚因为是一个事务，内/外只要有报错，他俩会一块儿回滚。

m0_67393828的博客 314

Spring 事务 (编程式 & 声明式, Spring 事务传播机制)

事务会把所有的操作作为一个整体, 一起向数据库提交或是撤销操作请求. 所以这组操作要么同时成功, 要么同时失败。如果方法执行过程中, 出现异常, 且未被捕获, 就进行事务回滚.如果当前存在事务, 则创建一个事务作为当前事务的。一个新事务, 如果当前存在事务, 就将当前事务。的方式运行, 如果当前存在事务, 就将当前事务。以非事务的方式运行, 如果当前存在事务, 就。该事务, 如果当前不存在事务, 则。该事务, 如果当前不存在事务,就以。强制性, 如果当前存在事务, 就。该事务, 如果当前不存在事务, 就。

shianla的博客 624

Spring 事务机制

1. 引言 1.1 什么是事务 事务是由用户定义的一系列操作序列所组成的最小工作单元；这些操作要么全部完成，要么全部不完成，是一个不可分割的工作单元。常见于数据库中的并发控制和数据一致性处理场景。 1.2 事务的特性 事务具有以下特性： 原子性（Atomicity）：事务是由操作序列组成的不可分割的最小工作单元。 一致性（Consistency）：事务中操作的状态最终是一致的，要么全都完成，要么全都失败。 隔离性（Isolation）：事务与事务之间的操作与状态是隔离开的，事务只受到自身操作状态的影响。

weixin_65837469的博客 1853

Spring事务的7个传播行为，4个隔离级别

Spring事务的传播行为和隔离级别[transaction behavior and isolated level] Spring中事务的定义：  一、Propagation  key属性确定代理应该给哪个方法增加事务行为。这样的属性最重要的部份是传播行为。有以下选项可供使用： PROPAGATION_REQUIRED--支持当前事务，如果当前没有事务，就新建一个事务。这

辉悦天成的专栏 8557

（18）Spring - 声明式事务，事务的传播行为，使用XML文件配置事务

我们在前面的（18）中详细的弄出了代码，接下来，我们就来看怎么声明事务 xml文件中加入内容: <!-- 配置事务管理器 --> <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"> ...

魚 504
上一篇： 阿里p8耗时一个月整理的面试突击手册助力金三银四
下一篇： 阿里微服务架构师三年经验分享：Spring Cloud开发入门到实战
点赞 1
评论 0
书签 书签 2
Java架构师小森
Java架构师小森
博客等级 码龄5年 23粉丝 32原创
+ 关注
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值