加入事务和嵌套事务有的区别

本文对比了Spring框架中加入事务(REQUIRED)和嵌套事务(NESTED)两种传播级别的区别。加入事务会在遇到异常时回滚所有事务,而嵌套事务则通过数据库的保存点机制仅回滚部分事务。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

加入事务和嵌套事务的区别

加入事务和嵌套事务是指在 Spring 事务传播机制中的加入事务(REQUIRED)和嵌套事务(NESTED)的区别,二者看似很像,实则截然不同,那么它们有什么区别呢?接下来我们一起来看。

Spring 事务传播机制是指,包含多个事务的方法在相互调用时,事务是如何在这些方法间传播的,Spring 事务传播机制分为 3 大类,总共 7 种级别,如下图所示:
在这里插入图片描述
其中,支持当前事务的 REQUIRED 是加入(当前)事务,而 NESTED 是嵌套(当前)事务,本文要讨论的就是这二者的区别。

1.加入事务

加入事务 REQUIRED 是 Spring 事务的默认传播级别。

所谓的加入当前事务,是指如果当前存在事务,则加入该事务;如果当前没有事务,则创建一个新的事务。我们这里重点要讨论的是第一种情况,也就是当前存在事务的情况下,它和嵌套事务的区别,接下来我们通过一个示例来看加入事务的使用和执行特点。

我们要实现的是用户添加功能,只不过在添加用户时,我们需要给用户表和日志表中分别插入一条数据,UserController 实现代码如下:

@Transactional(propagation = Propagation.REQUIRED)
@RequestMapping("/add")
public int add(UserInfo userInfo) {
    int result = 0;
    int userResult = userService.add(userInfo);
    System.out.println("用户添加结果:" + userResult);
    if (userResult > 0) {
        LogInfo logInfo = new LogInfo();
        logInfo.setName("添加用户");
        logInfo.setDesc("添加用户结果:" + userResult);
        int logResult = logService.add(logInfo);
        System.out.println("日志添加结果:" + logResult);
        result = 1;
    }
    return result;
}

从上述代码可以看出,添加用户使用了事务,并设置了事务传播机制为 REQUIRED(加入事务),此控制器调用的 UserService 实现代码如下:

@Transactional(propagation = Propagation.REQUIRED)
public int add(UserInfo userInfo) {
    int result = userMapper.add(userInfo);
    return result;
}

从上述代码可以看出,它也是使用事务,并设置了事务的传播机制为 REQUIRED,而 LogService 也是类似的实现代码:


@Transactional(propagation = Propagation.REQUIRED)
public int add(LogInfo logInfo) {
    int result = logMapper.add(logInfo);
    try {
        int number = 10 / 0;
    } catch (Exception e) {
        // 手动回滚事务
        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
    }
    return result;
}

从上述代码我们可以看出,在设置事务传播机制的同时,我们也在程序中主动的设置了一个异常。

运行以上程序的执行结果如下图所示:
在这里插入图片描述
从上述结果我们可以看出:当我们设置了加入事务的事务传播机制之后,程序的执行结果是将用户表和日志表的事务都回滚了。

2.嵌套事务

嵌套事务指的是事务传播级别中的 NESTED,所谓的嵌套当前事务,是指如果当前存在事务,则创建一个事务作为当前事务的嵌套事务来运行;如果当前没有事务,则该取值等价于 REQUIRED。当然,我们本文要研究的重点也是第一种情况,也就是当前存在事务的前提下,嵌套事务和加入事务的区别。

所以接下来我们将上面代码中的事务传播机制改为 NESTED,它的实现代码如下。UserController 实现代码如下:

@Transactional(propagation = Propagation.NESTED)
@RequestMapping("/add")
public int add(UserInfo userInfo) {
    int result = 0;
    int userResult = userService.add(userInfo);
    System.out.println("用户添加结果:" + userResult);
    if (userResult > 0) {
        LogInfo logInfo = new LogInfo();
        logInfo.setName("添加用户");
        logInfo.setDesc("添加用户结果:" + userResult);
        int logResult = logService.add(logInfo);
        System.out.println("日志添加结果:" + logResult);
        result = 1;
    }
    return result;
}

UserService 实现代码如下:


@Transactional(propagation = Propagation.NESTED)
public int add(UserInfo userInfo) {
    int result = userMapper.add(userInfo);
    return result;
}

LogService 实现代码如下:


@Transactional(propagation = Propagation.NESTED)
public int add(LogInfo logInfo) {
    int result = logMapper.add(logInfo);
    try {
        int number = 10 / 0;
    } catch (Exception e) {
        // 手动回滚事务    TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
    }
    return result;
}

运行以上程序的执行结果如下图所示:
在这里插入图片描述
从上述结果可以看出:当设置嵌套事务的事务传播级别之后,程序执行了部分事务的回滚,用户表添加的事务没有回滚,只是日志表的事务回滚了。

3.加入事务 VS 嵌套事务

加入事务(REQUIRED)和嵌套事务(NESTED)都是事务传播机制的两种传播级别,如果当前不存在事务,那么二者的行为是一样的;但如果当前存在事务,那么加入事务的事务传播级别在遇到异常之后,会将事务全部回滚;而嵌套事务在遇到异常时,只是执行了部分事务的回滚。

4.嵌套事务实现原理

事务全部回滚很好理解,这本来就是事务原子性的一种体现,而嵌套事务中的部分事务回滚是怎么实现的呢?

嵌套事务只所以能实现部分事务的回滚,是因为在数据库中存在一个保存点(savepoint)的概念,以 MySQL 为例,嵌套事务相当于新建了一个保存点,而滚回时只回滚到当前保存点,因此之前的事务是不受影响的,这一点可以在 MySQL 的官方文档汇总找到相应的 资料
图片
而 REQUIRED 是加入到当前事务中,并没有创建事务的保存点,因此出现了回滚就是整个事务回滚,这就是嵌套事务和加入事务的区别。

保存点就像玩通关游戏时的“游戏存档”一样,如果设置了游戏存档,那么即使当前关卡失败了,也能继续上一个存档点继续玩,而不是从头开始玩游戏。
在这里插入图片描述

总结

加入事务(REQUIRED)和嵌套事务(NESTED)都是事务传播机制中的两种传播级别,如果当前不存在事务,那么二者的行为是一致的;但如果当前存在事务,那么加入事务的事务传播级别当遇到异常时会回滚全部事务,而嵌套事务则是回滚部分事务。嵌套事务之所以能回滚部分事务,是因为数据库中存在一个保存点的概念,嵌套事务相对于新建了一个保存点,如果出现异常了,那么只需要回滚到保存点即可,这样就实现了部分事务的回滚。

<think>嗯,用户想了解Spring事务嵌套,我需要详细解释清楚。首先,我应该从基本概念入手,介绍事务嵌套是什么。然后,可能需要讲传播机制,特别是PROPAGATION_REQUIREDPROPAGATION_REQUIRES_NEW的区别。记得要举例子,比如方法A调用方法B,不同传播行为下的表现。 用户可能遇到事务嵌套的问题,比如内层事务回滚是否影响外层,或者如何配置不同的传播行为。需要说明默认的传播行为是什么,以及常见的使用场景。比如,当方法B需要独立事务时,使用REQUIRES_NEW,这样B的回滚不会影响A,但要注意异常处理。 另外,要提到事务的隔离级别它们对嵌套事务的影响,但可能不需要太深入,除非用户特别问到。需要强调事务失效的常见情况,比如自调用问题,以及如何通过AOP代理解决。 还要注意语法部分,确保数学表达式代码都用正确的格式。比如传播行为应该用代码块标出,例如@Transactional(propagation = Propagation.REQUIRES_NEW)。例子部分要清晰,可能用代码示例说明不同传播行为下的结果。 最后,总结一下关键点,帮助用户记忆。可能还需要提醒常见的陷阱,比如异常被捕获导致事务不回滚,或者配置错误导致传播行为不生效。确保回答结构清晰,分点说明,让用户容易理解。</think>Spring事务嵌套是分布式事务处理中的典型场景,其核心通过传播机制(Propagation Behavior)控制事务边界。以下从工作机制到实际场景逐步分析: 一、传播机制7种类型(关键4种) $$ \begin{array}{|l|l|} \hline \text{传播行为} & \text{行为特征} \\ \hline \text{PROPAGATION\_REQUIRED(默认)} & \text{加入当前事务,不存在则新建} \\ \hline \text{PROPAGATION\_REQUIRES\_NEW} & \text{始终新建独立事务} \\ \hline \text{PROPAGATION\_NESTED} & \text{嵌套事务(Savepoint机制)} \\ \hline \text{PROPAGATION\_SUPPORTS} & \text{跟随当前事务状态} \\ \hline \end{array} $$ 二、典型嵌套场景分析(A方法调用B方法) 1. **默认传播行为(REQUIRED)** ```java @Transactional void A() { insertTable1(); B(); // 传播行为=REQUIRED // 异常发生点影响最终结果 } @Transactional void B() { insertTable2(); } ``` - 若B()执行失败:A()中insertTable1B()的insertTable2同时回滚 - 若B()成功,A()后续失败:所有操作回滚 2. **独立事务(REQUIRES_NEW)** ```java @Transactional void A() { insertTable1(); B(); // 传播行为=REQUIRES_NEW throw new Exception(); } @Transactional(propagation = Propagation.REQUIRES_NEW) void B() { insertTable2(); } ``` - B()事务先提交 - A()抛出异常后,仅回滚insertTable1 3. **嵌套事务NESTED)** ```java @Transactional void A() { insertTable1(); try { B(); // 传播行为=NESTED } catch (Exception e) { // 处理子事务异常 } insertTable3(); } @Transactional(propagation = Propagation.NESTED) void B() { insertTable2(); throw new RuntimeException(); } ``` - B()回滚到Savepoint,不影响A()后续insertTable3执行 - 需要数据库支持(如MySQL的InnoDB引擎) 三、实现原理 1. 通过`TransactionInterceptor`实现AOP切面 2. 使用`TransactionSynchronizationManager`管理事务上下文 3. 事务管理器(`PlatformTransactionManager`)决策传播行为 四、实践注意事项 1. **异常处理**:默认只回滚RuntimeException ```java @Transactional(rollbackFor = Exception.class) ``` 2. **事务失效场景**: - 自调用(同类中非代理方法调用) - 异常被捕获未抛出 - 非public方法 五、调试建议 1. 开启事务日志: ```properties logging.level.org.springframework.transaction.interceptor=TRACE logging.level.org.springframework.jdbc.datasource=DEBUG ``` 2. 使用`TransactionSynchronizationManager.isActualTransactionActive()`检测事务状态 理解事务嵌套的关键是掌握传播行为对事务边界的影响,实际开发中需要根据业务原子性要求选择合适的传播策略。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值