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

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

转载作者：撒哈拉更新时间：2024-09-24 16:18:58

我们在使用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默认的传播机制，__含义：__如果当前存在事务，则加入该事务，如果不存在事务，则创建一个事务。下面我们分别演示一下:

如果不存在事务，则创建一个事务。具体代码如下：

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()创建了新的事务，由于抛出异常，所以数据没有插入成功.

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

@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

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

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

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

和预期一致，没有问题.

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

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

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

如果当前存在事务，则加入到事务当中，代码如下：

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

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

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

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

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

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

和预期一致.

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

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

最后此篇关于Spring事务传播机制（最全示例）的文章就讲到这里了,如果你想了解更多关于Spring事务传播机制（最全示例）的内容请搜索CFSDN的文章或继续浏览相关文章，希望大家以后支持我的博客！。

文章推荐： HuggingFace论文平台DailyPapers功能全解析

文章推荐：在Linux中使用pidstat命令监控进程性能

文章推荐： .NET8+Vue/UniApp高性能前后端分离框架

文章推荐： flink大批量任务提交yarn失败问题

java - @Transactional(传播=传播。需要)
如果有人能解释这个注释的作用以及我们何时使用它: @Transactional(propagation=Propagation.REQUIRED) 谢谢最佳答案如果您需要在 Spring Docs
Javascript - 阻止模态键盘事件冒泡/传播
我有一个页面，它有一个 keydown 事件监听器，用于监听 Escape 键，以便返回。我还有一个简单的模态类，它也监听 Escape 键以关闭它。主页监听器检查模式是否打开，如果打开，则不执行任何
Modelica 传播/默认变量名
我想在模型中设置默认变量名称 T (=xx) - 将该模型拖到新模型中并在其中定义变量 xx。我收到错误消息:使用未声明的变量 xx。这是子模型 model test parameter Rea
jqueryMobile 水龙头和冒泡/传播
在 android 2.x 浏览器中查看此示例..它是在我的应用程序中复制场景的示例.. http://johnchacko.net/samples/tap.html 它是关于监听“tap”并从监听器
C# 捕获特定异常类型的重新抛出/传播
如您所见，我正在尝试将 GatewayConnectionFailedException 传播到我的 UI。我希望此代码捕获除异常之外的所有内容，我希望表示层捕获该异常以通知用户数据库是问题所在，以便
CMake 静态库依赖项不随 ExternalProject_Add 传播
我目前正在尝试让可执行文件与它需要的所有依赖项正确链接。这是依赖项的示例结构: exe -> libA -> libB exe和 libA有自己的存储库。 exe拉入libA像这样的东西: add_
scala - Scala中的“传播”参数？
有什么方法可以调用带有单个参数的 Scala 函数，给定一个数组 (类似于 JavaScript Spreads在 ECMAScript 6) 中？ ys = [10.0, 2.72, -3.14]
Cmake:包含目录的 target_link_libraries 传播
我有一个小型静态库，它需要 boost 头文件，并且需要包含目录中的“include”目录。 ... add_library(alib STATIC ...) target_include_direc
javascript - 传播 Promise 并在新对象中扩展
我有一些 promise 可以返回对象。现在我想将它们合并/扩展为一个新对象，因此我使用 Lodash's extend . var whenEverythingIsDone = Promise.a
scala - 传播 Scala 类型参数
这是我认为人们通常希望在 Scala 中做的事情，但如果我能在任何地方找到一个例子，我就该死了。这段代码由于类型删除而无法编译，但它演示了我正在努力完成的事情: def parse[T](json:
scala - 传播 Scala 类型参数
这是我认为人们通常希望在 Scala 中做的事情，但如果我能在任何地方找到一个例子，我就该死了。这段代码由于类型删除而无法编译，但它演示了我正在努力完成的事情: def parse[T](json:
Sharepoint default.master 传播？
我们有大量 MOSS 2007 站点需要添加大量的 javascript。我编辑、 checkin 、发布并批准了对 default.master 的更改，更改反射(reflect)在根网站上，但没有
jQuery:函数被调用两次。传播？为什么会出现这种情况？
请看一下下面的 fiddle :http://jsfiddle.net/K9NjY/ 我在这段代码上花了 3-4 个小时，并将其缩小到最短的版本，但现在我陷入了困境。问题:1. 点击“divOne”
java - Spring 集成中的错误处理/传播
我读到如果在流程中抛出异常，框架要做的第一件事就是检查消息头中的错误 channel 属性。总是这样吗？在我的特殊情况下，我将自定义错误 channel 分配给消息 header ，但该消息似乎已向
c++ - 不能通过carry让值(value)传播
创建一个小的 C++ 大型精度类，一切似乎都运行良好，但是添加，如果我将 0xffffffff 和 0x04 加在一起，我会得到 0xffff0003，而我应该得到 0x0100000003。这是有问
javascript - react : problems with . ..传播
我正在尝试重新创建 Dan Abramov 类(class)中的 Redux 示例。传播{...store.getState()}在应用程序级别不起作用，Redux 正在更改状态并且 React 不会
mysql - 传播.REQUIRES_NEW 锁定
考虑一个需要很长时间的事务。在此期间，我想对 TableSmall 执行一些小更新。，它应该立即执行，并且主事务的回滚不应该回滚那些小的更新。我当前的问题是这些小更新将锁定 TableSmall\
c - 如何处理子函数中的 const 传播
我需要对现有函数进行修改，具有一些 const 输入参数: int f(const owntype *r1, const owntype *r2) 为了做到这一点，我想调用一个使用相同类型但没有 co
c# - 传播 DependencyProperty 默认值
我有一个带有 ViewModel 的 WPF UserControl: 这个 UserControl 有一个 De
android - 停止 SMS 传播
我试图在收到这样的短信时不传播 public class SMSReceiver extends BroadcastReceiver { @Override public void onRec

撒哈拉

个人简介

我是一名优秀的程序员,十分优秀！

作者热门文章

滴滴打车优惠券免费领取

全站热门文章

首页

博学

6Ren·AI

商城