全部标签
写点什么
OpenHarmony算法元宇宙MySQL移动开发学习方法学习方法Web3.0高效工作数据库Python音视频前端AI大数据团队管理程序员运维深度思考低代码redisgolang微服务架构flutter 查看更多

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

作者：快乐非自愿限量之名
  • 2024-11-15
    福建

  • 本文字数：7583 字

    阅读完需：约 25 分钟

我们在使用 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()没有事务，所以会新创建一个事务，后面有异常抛出，所以数据不会插入成功，我们测试一下，看看结果如何？



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


2、如果当前存在事务，则加入该事务，代码如下：


@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()抛出异常，由于两个方法在同一个事务中，所以两个数据都不会插入成功。我们测试一下，



和我们的预期是一致的，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，则会加入到事务中，由于两个方法在同一个事务中，抛出异常后，两条数据都不会插入成功，我们测试一下，



和预期一致，没有问题。


2、如果不存在事务，则以非事务的方式执行，具体代码如下：


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()也是没有事务的，虽然抛出了异常，但是不会回滚，两条数据都应该插入成功，我们测试一下，



和预期一致，没有问题。


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()方法抛出了异常，所以两条数据都不会成功，我们测试一下，



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


2、如果当前没有事务，则抛出异常，代码如下：


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'
复制代码


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



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()最后抛出了异常，由于两个方法是两个事务，所以异常只会对外层事务回滚，我们测试一下，



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()以非事务执行，数据插入后，抛出异常，由于外层是有事务的，所以外层事务回滚，我们测试一下，



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


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'
复制代码


再看看数据库中的数据，



和预期是一致的。


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，会创建一个新的事务，由于抛出了异常所以内层会回滚，外层没有事务，会插入数据成功，我们测试一下，



和预期一致。


2、如果当前存在事务，则在当前事务中创建一个新的嵌套事务。我们再看看代码，


@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()回滚。我们测试一下，



和我们的预测是一致的。


总结


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


文章转载自：牛初九

原文链接：https://www.cnblogs.com/boboooo/p/18429072

体验地址：http://www.jnpfsoft.com/?from=infoq

划线
评论
复制
发布于: 刚刚阅读数: 4
spring
用户头像

快乐非自愿限量之名

关注

还未添加个人签名 2023-06-19 加入

还未添加个人简介

评论

发布
暂无评论
Copyright © 2024, Geekbang Technology Ltd. All rights reserved. 极客邦控股（北京）有限公司 | 京 ICP 备 16027448 号 - 5京公网安备京公网安备 11010502039052号 | 产品资质
Spring事务传播机制（最全示例）_spring_快乐非自愿限量之名_InfoQ写作社区