AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

Spring事务传播机制（最全示例）

2024-09-24 23
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 在使用Spring框架进行开发时，`service`层的方法通常带有事务。本文详细探讨了Spring事务在多个方法间的传播机制，主要包括7种传播类型：`REQUIRED`、`SUPPORTS`、`MANDATORY`、`REQUIRES_NEW`、`NOT_SUPPORTED`、`NEVER` 和 `NESTED`。通过示例代码和数据库插入测试，逐一展示了每种类型的运作方式。例如，`REQUIRED`表示如果当前存在事务则加入该事务，否则创建新事务；`SUPPORTS`表示如果当前存在事务则加入，否则以非事务方式执行；`MANDATORY`表示必须在现有事务中运行，否则抛出异常；

我们在使用Spring框架进行开发时，经常在service层写很多方法，而且这些方法都是带事务的，那么Spring的事务怎么在多个方法之间传播呢？今天我们就仔细聊一聊。

Spring的事务传播机制主要解决在多个方法之间，事务如何传递的问题，通常有7种传播类型：

  • REQUIRED
  • SUPPORTS
  • MANDATORY
  • REQUIRES_NEW
  • NOT_SUPPORTED
  • NEVER
  • NESTED

下面我们就一一演示这7种类型是如何工作的。

基础代码

在讲解7种传播类型之前，我们先看看基础代码，代码很简单，大家先熟悉一下：

public void outerTransaction() {
   
    //向表中插入文本“outerTransaction”
    TransactionPropagation tp = new TransactionPropagation();
    tp.setMethodName("outerTransaction");
    transactionPropagationMapper.insert(tp);

    //调用innerTransaction方法
    TransactionPropagationService currentProxy = (TransactionPropagationService)AopContext.currentProxy();
    currentProxy.innerTransaction();

    //抛出异常
    int i = 1 / 0 ;
}


public void innerTransaction() {
   
    //向表中插入文本“innerTransaction”
    TransactionPropagation tp = new TransactionPropagation();
    tp.setMethodName("innerTransaction");
    transactionPropagationMapper.insert(tp);

    //抛出异常
    int i = 1 / 0 ;
}

方法outerTransaction()向表中插入文本"outerTransaction"，然后调用innerTransaction()方法，最后通过计算1 / 0抛出异常。

方法innerTransaction()向表中插入文本"innerTransaction"，通过计算1 / 0抛出异常。

这里我们在调用innerTransaction()方法时，先获取当前的AOP代理，再通过代理调用。这是因为两个方法在同一个类中，如果不通过代理，直接调用，会脱离Spring事务AOP的管理，导致事务失效。

我们在这两个方法上使用注解，并配置不同的传播机制，通过查看数据库是否插入数据成功来演示不同传播机制的效果。

REQUIRED

REQUIRED是Spring默认的传播机制，含义：如果当前存在事务，则加入该事务，如果不存在事务，则创建一个事务。下面我们分别演示一下：

  1. 如果不存在事务，则创建一个事务。具体代码如下：
public void outerTransaction() {
   
    //向表中插入文本“outerTransaction”
    TransactionPropagation tp = new TransactionPropagation();
    tp.setMethodName("outerTransaction");
    transactionPropagationMapper.insert(tp);

    //调用innerTransaction方法
    TransactionPropagationService currentProxy = (TransactionPropagationService)AopContext.currentProxy();
    currentProxy.innerTransaction();
}


@Transactional(propagation = Propagation.REQUIRED)
public void innerTransaction() {
   
    //向表中插入文本“innerTransaction”
    TransactionPropagation tp = new TransactionPropagation();
    tp.setMethodName("innerTransaction");
    transactionPropagationMapper.insert(tp);

    //抛出异常
    int i = 1 / 0 ;
}

outerTransaction()方法没有事务注解，虽然调用innerTransaction()方法时有异常抛出，插入数据也应该成功。innerTransaction()方法有事务注解，传播方式为：REQUIRED，由于outerTransaction()没有事务，所以会新创建一个事务，后面有异常抛出，所以数据不会插入成功，我们测试一下，看看结果如何？
image-20240924121028544-1727151045051-1.png

和我们的预期是一致的，innerTransaction()创建了新的事务，由于抛出异常，所以数据没有插入成功。

  1. 如果当前存在事务，则加入该事务，代码如下：
@Transactional(propagation = Propagation.REQUIRED)
public void outerTransaction() {
   
    //向表中插入文本“outerTransaction”
    TransactionPropagation tp = new TransactionPropagation();
    tp.setMethodName("outerTransaction");
    transactionPropagationMapper.insert(tp);

    //调用innerTransaction方法
    TransactionPropagationService currentProxy = (TransactionPropagationService)AopContext.currentProxy();
    currentProxy.innerTransaction();

    //抛出异常
    int i = 1 / 0 ;
}


@Transactional(propagation = Propagation.REQUIRED)
public void innerTransaction() {
   
    //向表中插入文本“innerTransaction”
    TransactionPropagation tp = new TransactionPropagation();
    tp.setMethodName("innerTransaction");
    transactionPropagationMapper.insert(tp);
}

outerTransaction()增加了事务注解，传播类型为REQUIRED，由于之前没有事务，所以新创建了一个事务，然后调用innerTransaction()，innerTransaction()的传播类型也为REQUIRED，由于前面有事务，所以加入事务，最后outerTransaction()抛出异常，由于两个方法在同一个事务中，所以两个数据都不会插入成功。我们测试一下，
image-20240924122731048.png

和我们的预期是一致的，innerTransaction()加入了outerTransaction()的事务，抛出异常后，两条数据都不会插入成功。

SUPPORTS

如果当前存在事务，则加入该事务，如果不存在事务，则以非事务的方式执行。同样我们分别演示一下。

  1. 如果当前存在事务，则加入该事务，代码如下：
@Transactional(propagation = Propagation.REQUIRED)
public void outerTransaction() {
   
    //向表中插入文本“outerTransaction”
    TransactionPropagation tp = new TransactionPropagation();
    tp.setMethodName("outerTransaction");
    transactionPropagationMapper.insert(tp);

    //调用innerTransaction方法
    TransactionPropagationService currentProxy = (TransactionPropagationService)AopContext.currentProxy();
    currentProxy.innerTransaction();

    //抛出异常
    int i = 1 / 0 ;
}


@Transactional(propagation = Propagation.SUPPORTS)
public void innerTransaction() {
   
    //向表中插入文本“innerTransaction”
    TransactionPropagation tp = new TransactionPropagation();
    tp.setMethodName("innerTransaction");
    transactionPropagationMapper.insert(tp);

}

outerTransaction()是有事务的，innerTransaction()的传播类型为：SUPPORTS，则会加入到事务中，由于两个方法在同一个事务中，抛出异常后，两条数据都不会插入成功，我们测试一下，
image-20240924123357342-1727152445217-3.png

和预期一致，没有问题。

  1. 如果不存在事务，则以非事务的方式执行，具体代码如下：
public void outerTransaction() {
   
    //向表中插入文本“outerTransaction”
    TransactionPropagation tp = new TransactionPropagation();
    tp.setMethodName("outerTransaction");
    transactionPropagationMapper.insert(tp);

    //调用innerTransaction方法
    TransactionPropagationService currentProxy = (TransactionPropagationService)AopContext.currentProxy();
    currentProxy.innerTransaction();
}


@Transactional(propagation = Propagation.SUPPORTS)
public void innerTransaction() {
   
    //向表中插入文本“innerTransaction”
    TransactionPropagation tp = new TransactionPropagation();
    tp.setMethodName("innerTransaction");
    transactionPropagationMapper.insert(tp);

    //抛出异常
    int i = 1 / 0 ;
}

我们将outerTransaction()方法的事务注解去掉，抛出异常的位置挪到innerTransaction()中，由于innerTransaction()的传播类型是SUPPORTS，外层是没有事务的，所以innerTransaction()也是没有事务的，虽然抛出了异常，但是不会回滚，两条数据都应该插入成功，我们测试一下，
image-20240924125916177-1727153959454-5.png

和预期一致，没有问题。

MANDATORY

如果当前存在事务，则加入到事务当中；如果当前没有事务，则抛出异常。我们分别演示一下，

  1. 如果当前存在事务，则加入到事务当中，代码如下：
@Transactional(propagation = Propagation.REQUIRED)
public void outerTransaction() {
   
    //向表中插入文本“outerTransaction”
    TransactionPropagation tp = new TransactionPropagation();
    tp.setMethodName("outerTransaction");
    transactionPropagationMapper.insert(tp);

    //调用innerTransaction方法
    TransactionPropagationService currentProxy = (TransactionPropagationService)AopContext.currentProxy();
    currentProxy.innerTransaction();

    //抛出异常
    int i = 1 / 0 ;
}


@Transactional(propagation = Propagation.MANDATORY)
public void innerTransaction() {
   
    //向表中插入文本“innerTransaction”
    TransactionPropagation tp = new TransactionPropagation();
    tp.setMethodName("innerTransaction");
    transactionPropagationMapper.insert(tp);
}

outerTransaction()方法是有事务的，innerTransaction()方法的传播类型是MANDATORY，会加入到事务中，由于outerTransaction()方法抛出了异常，所以两条数据都不会成功，我们测试一下，
image-20240924130447464-1727154298756-7.png

和预期一致，都没有成功。

  1. 如果当前没有事务，则抛出异常，代码如下：
public void outerTransaction() {
   
    //向表中插入文本“outerTransaction”
    TransactionPropagation tp = new TransactionPropagation();
    tp.setMethodName("outerTransaction");
    transactionPropagationMapper.insert(tp);

    //调用innerTransaction方法
    TransactionPropagationService currentProxy = (TransactionPropagationService)AopContext.currentProxy();
    currentProxy.innerTransaction();

    //抛出异常
    int i = 1 / 0 ;
}


@Transactional(propagation = Propagation.MANDATORY)
public void innerTransaction() {
   
    //向表中插入文本“innerTransaction”
    TransactionPropagation tp = new TransactionPropagation();
    tp.setMethodName("innerTransaction");
    transactionPropagationMapper.insert(tp);
}

我们只是去掉了outerTransaction()上的事务注解，我们看一下会不会抛出异常，测试一下，

org.springframework.transaction.IllegalTransactionStateException: No existing transaction found for transaction marked with propagation 'mandatory'

确实是抛出了异常，我们再查看一下数据库的数据，
image-20240924130839780.png

outerTransaction()方法的数据插入成功了，因为outerTransaction()方法没有事务，虽然后面的方法抛出了异常，但数据还是会插入成功。

REQUIRES_NEW

总是创建一个新的事务，如果当前存在事务，则挂起当前事务。这句话怎么理解呢？我们看看下面的代码，

@Transactional(propagation = Propagation.REQUIRED)
public void outerTransaction() {
   
    //向表中插入文本“outerTransaction”
    TransactionPropagation tp = new TransactionPropagation();
    tp.setMethodName("outerTransaction");
    transactionPropagationMapper.insert(tp);

    //调用innerTransaction方法
    TransactionPropagationService currentProxy = (TransactionPropagationService)AopContext.currentProxy();
    currentProxy.innerTransaction();

    //抛出异常
    int i = 1 / 0 ;
}

@Transactional(propagation = Propagation.REQUIRES_NEW)
public void innerTransaction() {
   
    //向表中插入文本“innerTransaction”
    TransactionPropagation tp = new TransactionPropagation();
    tp.setMethodName("innerTransaction");
    transactionPropagationMapper.insert(tp);
}

outerTransaction()是有事务的，innerTransaction()方法的传播类型是REQUIRES_NEW，会创建一个新的事务，虽然outerTransaction()最后抛出了异常，由于两个方法是两个事务，所以异常只会对外层事务回滚，我们测试一下，
image-20240924131729385.png

innerTransaction()插入数据成功，outerTransaction()方法由于有异常，所以进行了回滚。如果将异常从外层挪到内层，也就是外层不抛出异常，而内层抛出异常，执行结果会是什么样子呢？小伙伴们自己思考一下吧。

NOT_SUPPORTED

以非事务的方式执行操作，如果当前存在事务，则挂起当前事务。这种传播类型说明方法都是非事务的，不管外层有没有事务，我们先看看代码，

@Transactional(propagation = Propagation.REQUIRED)
public void outerTransaction() {
   
    //向表中插入文本“outerTransaction”
    TransactionPropagation tp = new TransactionPropagation();
    tp.setMethodName("outerTransaction");
    transactionPropagationMapper.insert(tp);

    //调用innerTransaction方法
    TransactionPropagationService currentProxy = (TransactionPropagationService)AopContext.currentProxy();
    currentProxy.innerTransaction();
}

@Transactional(propagation = Propagation.NOT_SUPPORTED)
public void innerTransaction() {
   
    //向表中插入文本“innerTransaction”
    TransactionPropagation tp = new TransactionPropagation();
    tp.setMethodName("innerTransaction");
    transactionPropagationMapper.insert(tp);

    //抛出异常
    int i = 1 / 0 ;
}

outerTransaction()是有事务的，innerTransaction()的传播类型是NOT_SUPPORTED，说明innerTransaction()以非事务执行，数据插入后，抛出异常，由于外层是有事务的，所以外层事务回滚，我们测试一下，
image-20240924132822937.png

和预期是一致的，内层以非事务执行，插入数据成功，外层有事务，而且有异常，所以事务回滚。

NEVER

以非事务的方式执行操作，如果当前存在事务，则抛出异常。我们具体看一下代码，

@Transactional(propagation = Propagation.REQUIRED)
public void outerTransaction() {
   
    //向表中插入文本“outerTransaction”
    TransactionPropagation tp = new TransactionPropagation();
    tp.setMethodName("outerTransaction");
    transactionPropagationMapper.insert(tp);

    //调用innerTransaction方法
    TransactionPropagationService currentProxy = (TransactionPropagationService)AopContext.currentProxy();
    currentProxy.innerTransaction();
}

@Transactional(propagation = Propagation.NEVER)
public void innerTransaction() {
   
    //向表中插入文本“innerTransaction”
    TransactionPropagation tp = new TransactionPropagation();
    tp.setMethodName("innerTransaction");
    transactionPropagationMapper.insert(tp);

    //抛出异常
    int i = 1 / 0 ;
}

outerTransaction()有事务，innerTransaction() 的传播类型是NEVER，由于外层方法有事务，所以要抛异常，外层方法也要回滚，所以两条数据都不会插入成功，我们测试一下，

抛出的异常是：

org.springframework.transaction.IllegalTransactionStateException: Existing transaction found for transaction marked with propagation 'never'

再看看数据库中的数据，
image-20240924133329275.png

和预期是一致的。

NESTED

如果当前存在事务，则在当前事务中创建一个新的嵌套事务；如果当前没有事务，则创建一个新的任务。我们分别看一下是什么意思。

  1. 如果当前没有事务，则创建一个新的任务。这个感觉和REQUIRED是一样的，我们先看看代码，
public void outerTransaction() {
   
    //向表中插入文本“outerTransaction”
    TransactionPropagation tp = new TransactionPropagation();
    tp.setMethodName("outerTransaction");
    transactionPropagationMapper.insert(tp);

    //调用innerTransaction方法
    TransactionPropagationService currentProxy = (TransactionPropagationService)AopContext.currentProxy();
    currentProxy.innerTransaction();
}

@Transactional(propagation = Propagation.NESTED)
public void innerTransaction() {
   
    //向表中插入文本“innerTransaction”
    TransactionPropagation tp = new TransactionPropagation();
    tp.setMethodName("innerTransaction");
    transactionPropagationMapper.insert(tp);

    //抛出异常
    int i = 1 / 0 ;
}

outerTransaction()没有事务，innerTransaction()的传播类型是NESTED，会创建一个新的事务，由于抛出了异常所以内层会回滚，外层没有事务，会插入数据成功，我们测试一下，
image-20240924134045654.png

和预期一致。

  1. 如果当前存在事务，则在当前事务中创建一个新的嵌套事务。我们再看看代码，
@Transactional(propagation = Propagation.REQUIRED)
public void outerTransaction() {
   
    //向表中插入文本“outerTransaction”
    TransactionPropagation tp = new TransactionPropagation();
    tp.setMethodName("outerTransaction");
    transactionPropagationMapper.insert(tp);

    //调用innerTransaction方法
    TransactionPropagationService currentProxy = (TransactionPropagationService)AopContext.currentProxy();
    try {
   
        currentProxy.innerTransaction1();
        currentProxy.innerTransaction2();
    } catch (Exception e) {
   
        e.printStackTrace();
    }
}

@Transactional(propagation = Propagation.NESTED)
public void innerTransaction1() {
   
    //向表中插入文本“innerTransaction”
    TransactionPropagation tp = new TransactionPropagation();
    tp.setMethodName("innerTransaction1");
    transactionPropagationMapper.insert(tp);
}

@Transactional(propagation = Propagation.NESTED)
public void innerTransaction2() {
   
    //向表中插入文本“innerTransaction”
    TransactionPropagation tp = new TransactionPropagation();
    tp.setMethodName("innerTransaction2");
    transactionPropagationMapper.insert(tp);

    //抛出异常
    int i = 1 / 0 ;
}

outerTransaction()有事务，分别调用innerTransaction1()和innerTransaction2() ，并catch异常，innerTransaction1()和innerTransaction2()的传播机制都是NESTED，会分别创建一个内嵌事务，innerTransaction1()正常结束，没有异常，innerTransaction2()抛出异常事务回滚，而外层由于catch了异常，方法也可以正常结束，所以不会回滚。我们预测的是：outerTransaction()插入成功，innerTransaction1()插入成功，innerTransaction2()回滚。我们测试一下，
image-20240924135549273.png

和我们的预测是一致的。

总结

到此，Spring的7种传播机制就介绍完了。这里边的内容很多，是不好记忆的，其实我们也不必死记硬背，看看源码中的注释就可以了。如果再不行，就翻翻我的博客多看看吧~~

文章标签：
Java
Spring
数据库
测试技术
关键词：
Spring事务传播机制
Spring事务示例
Spring示例
Spring事务
小忽悠
目录
相关文章
热爱技术的小郑
|
1月前
|
安全 Java 数据库
一天十道Java面试题----第四天（线程池复用的原理------＞spring事务的实现方式原理以及隔离级别）
这篇文章是关于Java面试题的笔记，涵盖了线程池复用原理、Spring框架基础、AOP和IOC概念、Bean生命周期和作用域、单例Bean的线程安全性、Spring中使用的设计模式、以及Spring事务的实现方式和隔离级别等知识点。
热爱技术的小郑
54 3
路边两盏灯
|
1月前
|
缓存 NoSQL Java
【Azure Redis 缓存】示例使用 redisson-spring-boot-starter 连接/使用 Azure Redis 服务
【Azure Redis 缓存】示例使用 redisson-spring-boot-starter 连接/使用 Azure Redis 服务
路边两盏灯
44 0
香吧香
|
2月前
|
Java 关系型数据库 MySQL
Spring 事务失效场景总结
Spring 事务失效场景总结
香吧香
45 4
服务端技术栈
|
1月前
|
Java 程序员 数据库连接
女朋友不懂Spring事务原理，今天给她讲清楚了！
该文章讲述了如何解释Spring事务管理的基本原理，特别是针对女朋友在面试中遇到的问题。文章首先通过一个简单的例子引入了传统事务处理的方式，然后详细讨论了Spring事务管理的实现机制。
服务端技术栈
39 4
女朋友不懂Spring事务原理，今天给她讲清楚了！
热爱技术的小郑
|
1月前
|
XML Java 数据库
Spring5入门到实战------15、事务操作---概念--场景---声明式事务管理---事务参数--注解方式---xml方式
这篇文章是Spring5框架的实战教程，详细介绍了事务的概念、ACID特性、事务操作的场景，并通过实际的银行转账示例，演示了Spring框架中声明式事务管理的实现，包括使用注解和XML配置两种方式，以及如何配置事务参数来控制事务的行为。
热爱技术的小郑
34 0
Spring5入门到实战------15、事务操作---概念--场景---声明式事务管理---事务参数--注解方式---xml方式
热爱技术的小郑
|
1月前
|
前端开发 Java 数据库连接
一天十道Java面试题----第五天（spring的事务传播机制------＞mybatis的优缺点）
这篇文章总结了Java面试中的十个问题，包括Spring事务传播机制、Spring事务失效条件、Bean自动装配方式、Spring、Spring MVC和Spring Boot的区别、Spring MVC的工作流程和主要组件、Spring Boot的自动配置原理和Starter概念、嵌入式服务器的使用原因，以及MyBatis的优缺点。
热爱技术的小郑
21 2
理想shi做条咸鱼
|
1月前
|
Java 关系型数据库 MySQL
Spring Boot事务配置管理
主要总结了 Spring Boot 中如何使用事务，只要使用 @Transactional 注解即可使用，非常简单方便。除此之外，重点总结了三个在实际项目中可能遇到的坑点，这非常有意义，因为事务这东西不出问题还好，出了问题比较难以排查，所以总结的这三点注意事项，希望能帮助到开发中的朋友。
理想shi做条咸鱼
47 2
杭州小哥哥
|
2月前
|
Java 数据库连接 API
Spring事务管理嵌套事务详解 : 同一个类中，一个方法调用另外一个有事务的方法
Spring事务管理嵌套事务详解 : 同一个类中，一个方法调用另外一个有事务的方法
杭州小哥哥
87 1
日星月云
|
SQL Java 数据库
第一季：8spring支持的常用数据库事务传播属性和事务隔离级别【Java面试题】
第一季：8spring支持的常用数据库事务传播属性和事务隔离级别【Java面试题】
日星月云
132 0
柠檬茶五元
|
3月前
|
Java 开发者 Spring
spring事务类型，事务传递，隔离级别？
spring事务类型，事务传递，隔离级别？
柠檬茶五元
31 2

热门文章

最新文章

  • 1
    通过JMX监控Spring Boot应用
  • 2
    Spring-boot+Dubbo应用启停源码分析
  • 3
    Spring Boot 中文乱码问题解决方案汇总
  • 4
    Spring编程式事务
  • 5
    开发者学堂课程干货总结——Spring Cloud微服务架构设计与开发实战（九）
  • 6
    Spring Roo 命令行说明
  • 7
    Spring+SpringMVC +MyBatis整合配置文件案例
  • 8
    spring注解
  • 9
    Spring Boot 3 整合 xxl-job 实现分布式定时任务调度，结合 Docker 容器化部署（图文指南）
  • 10
    Spring Security（14）——权限鉴定基础
  • 1
    【Springcloud Alibaba微服务分布式架构 | Spring Cloud】之学习笔记（一）基础知识+各个组件介绍+聚合父工程创建
    704
  • 2
    spring cache整合redis实现springboot项目中的缓存功能
    103
  • 3
    Spring Boot整合Spring Security--学习笔记
    94
  • 4
    【spring（六）】WebSocket网络传输协议
    62
  • 5
    【spring（五）】SpringMvc总结 SSM整合流程
    57
  • 6
    【spring（四）】Spring事务管理和@Transactional注解
    83
  • 7
    Spring Boot 4.0：构建云原生Java应用的前沿工具
    293
  • 8
    Java 新手如何使用Spring MVC 中的查询字符串和查询参数
    55
  • 9
    Spring Boot的定时任务与异步任务
    105
  • 10
    通用Shell脚本执行Spring Boot项目Jar包
    77

    • 相关课程

    更多
  • 全面讲解Spring Cloud Alibaba技术栈（知识精讲+项目实战）第一阶段
  • 精通Spring Cloud Alibaba
  • 微服务框架 Spring Cloud 快速入门
  • Java Web开发系列课程 - Spring框架入门
  • Spring Boot 2.5.x开发实战
  • Spring Cloud微服务架构设计与开发实战

    • 相关电子书

    更多
  • 云栖社区特邀专家徐雷Java Spring Boot开发实战系列课程（第20讲）：经典面试题与阿里等名企内部招聘求职面试技巧
  • 微服务架构模式与原理Spring Cloud开发实战
  • 阿里特邀专家徐雷Java Spring Boot开发实战系列课程（第18讲）：制作Java Docker镜像与推送到DockerHub和阿里云Docker仓库

    • 相关实验场景

    更多
  • 从零搭建Spring Boot的Hello World
    • 下一篇
    DataWorks售前咨询