Spring 事务的传播机制

最新推荐文章于 2024-05-22 10:00:08 发布
最新推荐文章于 2024-05-22 10:00:08 发布
阅读量2.9k 收藏 15
点赞数 7
文章标签： spring java spring boot Mybatis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_68288689/article/details/131269195
版权

在我们平常中, 说到传播肯定是扩散, 传送或者散布的意思. 在 Spring 的事务中, 它也有传播, 而Spring 中的事务传播它是一种机制即传播机制. 这个事务传播机制和我们说的传播定义很像, 也就是说在多个包含事务的方法里相互调用时, 它们之间是如何扩散或者传递的.

一. 传播机制的作用

我们之前学事务的隔离级别中, 解决的时多个事务同时调用数据库的问题. 它保证了多个并发但独立的事务执行时是可控的( 稳定性 ).
image.png

而在事务的传播机制中, 它保证的是一个事务在多个调用方法之间的可控性( 稳定性 )
image.png
比如在我们常说的运钞过程, 在这个过程中, 运钞人员有很多环节需要执行 : 点钞 -> 运钞 -> 清点等等. 而事务的传播机制就是保证运钞这个事务在运钞过程中是可靠的. 也就是在每个运钞环节中是可靠的.

二. 事务的传播机制

在 Spring 中事务的传播机制一共有七种 :

  1. Propagation.REQUIRED

默认的事务传播级别, 表示如果当前存在事务, 则加入该事务; 如果当前没有事务, 则创建一个新事物

  1. Propagation.SUPPORTS

如果当前存在事务, 则加入事务; 如果当前不存在事务, 则以非事务的方式继续运行

  1. Propagation.MANDATORY

如果当前存在事务, 则加入事务; 如果当前没有事务, 则抛出异常

  1. Propagation.REQUIRES_NEW

表示创建一个新的事物, 如果当前存在事务则把当前事务挂起. 即无论外部是否开启事务, REQUIRES_NEW 修饰的方法会新开启自己的事务, 并且开启的事务相互之间独立, 互不干扰

  1. Propagation.NOT_SUPPORTED

以非事务的方式运行, 如果当前存在事务则把当前事务挂起.

  1. Propagation.NEVER

以非事务的方式运行, 如果当前存在事务则抛出异常

  1. Propagation.NESTED

如果当前存在事务, 则创建一个事务作为当前事务的嵌套事务来运行; 如果当前不存在事务, 则等价于 Propagation.REQUIRED. 即创建一个新的事物

对于上面的七种事务, 根据是否支持当前事务可以划分为三类 :

  1. 支持当前事务 :
    1. REQUIRED ( 需要有 )
    2. SUPPORTS ( 可以有 )
    3. MANDATORY ( 强制有 )
  2. 不支持当前事务 :
    1. REQUIRES_NEW
    2. NOT_SUPPORTED
    3. NEVER
  3. 嵌套事务 :
    1. NESTED

三. 支持当前事务演示( REQUIRED )

为了方便演示, 需要建立两张表. 一张用户表和一张日志表. 通过往用户表中新增数据后加入成功添加的日志信息到日志表进行演示
image.png
image.png

具体的调用过程 :
image.png

1. 创建实体类

由于后面我会采用参数传实体对象的方式进行添加, 因此需要用户表的实体对象和日志表的实体对象
用户表实体对象 :

@Data // 记得加该注解
    public class UserEntity {
        private int id;
        private String username;
        private String password;
        private String photo;
        private LocalDateTime createtime;
        private LocalDateTime updatetime;
        private int state;
    }

日志表实体对象 :

@Data
    public class LogEntity {
        private int id;
        private String timestamp;
        private String message;
    }

2. 建立 Mybatis 接口方法

用户操作的接口方法

@Mapper
    public interface UserMapper {
        int add(UserEntity user); // 传入用户利于后期维护
    }

日志操作的接口方法

@Mapper
    public interface LogMapper {
        int addLog(LogEntity log);
    }

3. 建立Mybatis 的 XML 方法

用户操作接口中 add 方法的具体实现

<insert id="add" >
    insert into userinfo(username, password) values(
    #{username}, #{password}
)
    </insert>

日志操作接口中 add 方法的具体实现

<insert id="addLog">
    insert into log(message) values(
    #{message}
)
    </insert>

4. service 层调用 mapper 层

在日志操作的 LogService 中建立 add 方法( 开启事务并默认设置为 REQUIRED 传播级别 )调用 mapper 层中的 add 添加日志方法

@Service
    public class LogService {
        @Autowired
        private LogMapper logMapper;

        // 
        @Transactional(propagation = Propagation.REQUIRED)
        public int add(LogEntity log) {
            int result = logMapper.add(log);
            System.out.println("添加日志条数 : " + result);
            int a = 10 / 0;
            return result;
        }
    }

在用户操作的 UserService 中建立 add 方法 ( 开启事务并默认设置为 REQUIRED 传播级别 ) 调用 mapper 层中的 add 添加用户方法, 完成后同时调用 LogService 中的 add 方法添加日志

@Service
    public class UserService {
        @Autowired
        private UserMapper userMapper;

        @Autowired
        private LogService logService;

        @Transactional(propagation = Propagation.REQUIRED)
        public int add(UserEntity user) {
            // 添加用户
            int addListUserResult = userMapper.add(user);
            System.out.println("添加用户条数 : " + addListUserResult);
            // 添加日志信息
            LogEntity log = new LogEntity();
            log.setMessage("添加用户成功");
            logService.add(log);
            return addListUserResult;
        }
    }

5. controller 层调用 service 层

实际上应该创建一个 LogController 来控制 LogService, 为了方便演示直接在 UserService 中直接调用了 LogService.add( ) 方法

@RestController
    @RequestMapping("/user3")
    public class UserController3 {

        @Autowired
        private UserService userService;

        @RequestMapping("/add")
        @Transactional(propagation = Propagation.REQUIRED)
        public int add(String username, String password) {
            if (username == null || password == null ||
                username.equals("") || password.equals("")) return 0;

            int result = 0;
            UserEntity user = new UserEntity();
            user.setUsername(username);
            user.setPassword(password);
            result = userService.add(user);
            return result;
        }
    }

由于上面我们的三个添加方法都开启了事务, 并且设置的是默认的隔离级别, 由 UserController -> UserService -> UserMapper和LogMapper. 存在着这样的方法调用链. 根据我们的 REQUIRED 传播机制, 因为当前的 UserController 存在事务, 后面的 UserService 开启事务后会加入到当前的 UserController 的事务中, 在 UserService 里出现了异常, 会不会影响到整个调用链呢 ?

6. 预期验证

可以明确的是, 在LogService.add 方法中出现了算数异常, 那么日志肯定是会进行回滚操作的. 但是这个算数异常会不会影响到调用链上的 UserService.add 方法添加用户呢 ?
可以看到, 控制台显示用户已经添加成功了, 日志也添加了, 最后报出了算数异常而终止了
image.png
先看数据库中的日志表 : 回滚了, 并没有添加数据, 符合异常后主动回滚的预期
image.png
再来看数据库中的用户表 : 可以看到, " wangwu " 这条数据是没有成功插入进来的.image.png
从上面的演示可以看到, 默认的传播机制 REQUIRED 调用链上的所有方法, 只要一个方法出现了异常, 那么这些方法开启的事务合并成的一个大流程的事务都会回滚. 也就是说无论是外部回滚还是内部回滚, 整个调用链都会回滚. 一荣俱荣一损俱损.

四. 不支持当前事务演示 ( REQUIRES_NEW )

将 UserController 中的添加方法以及 UserService 中添加用户方法和 LogService 中的添加日志方法开启事务后设置其事务的传播机制为 REQUIRES_NEW,
修改 UserController3 中的添加用户方法的传播机制

@RequestMapping("/add")
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public int add(String username, String password) {
        if (username == null || password == null ||
            username.equals("") || password.equals("")) return 0;

        int result = 0;
        UserEntity user = new UserEntity();
        user.setUsername(username);
        user.setPassword(password);
        result = userService.add(user);
        return result;
    }

修改 UserService 中的添加用户方法的传播机制

@Service
    public class LogService {
        @Autowired
        private LogMapper logMapper;

        @Transactional(propagation = Propagation.REQUIRES_NEW)
        public int add(LogEntity log) {
            int result = logMapper.add(log);
            System.out.println("添加日志条数 : " + result);
            int a = 10 / 0;
            return result;
        }
    }

修改 LogService 中的添加日志方法的传播机制

@Service
    public class LogService {
        @Autowired
        private LogMapper logMapper;

        @Transactional(propagation = Propagation.REQUIRES_NEW)
        public int add(LogEntity log) {
            int result = logMapper.add(log);
            System.out.println("添加日志条数 : " + result);
            int a = 10 / 0;
            return result;
        }
    }

对于上面的代码, 由于设置其隔离级别为 REQUIRES_NEW 表示开启新的事务, 并且和其他事务独立. 因此在 LogService 中出现算数异常会进行回滚, 但并不会影响调用链上的其他事务. 因此用户应该正常添加, 日志进行回滚.

同样调用 UserController3 里的添加方法观察
image.png
在控制台中看到, 用户已经添加, 日志也已经显示添加
在这里插入图片描述
数据库中查看却发现, 日志虽然回滚了, 但是用户添加也跟着回滚了. 这是为什么 ?
image.png
对于此事不符合我们设置的传播机制的预期结果而言, 是因为设置了事务注解, 此时虽然日志添加出现了算数异常, 它是一个单独的事务. 但在这一整个事务的调用链上出现了异常, 让外面的 UserController 的添加方法 和 UserService 的添加方法感知到了异常, 因此进行了回滚.

因此, 对于日志异常这个问题, 我们可以单独抛出异常处理后再来观察 REQUIRES_NEW 的传播机制

@Transactional(propagation = Propagation.REQUIRES_NEW)
    public int add(LogEntity log) {
        int result = 0;
try {
    result = logMapper.add(log);
    System.out.println("添加日志条数 : " + result);
    int a = 10 / 0;
} catch (Exception e) {
    // 主动对异常进行处理回滚
    TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
}
return result;
}

此时再去访问刚刚的路由方法就不在报错了, 因我们已经捕获异常并主动处理了
在这里插入图片描述

image.png
此时在到数据库中查看可以看到, 日志正确回滚. 但添加用户并不受到算数异常的影响正确添加了
image.png
也就是说, REQUIRES_NEW 传播机制中, 会建立新的事务, 并且这些事务都是相互独立的, 互不干扰. 也就是常说的各干各的.

五. 嵌套式事务演示

嵌套式事务就一个高中有三个年级, 一个年级又有很多个班一样. 类似于套娃的的形式.
同样的将上面的 UserController 中的添加方法以及 UserService 中添加用户方法和 LogService 中的添加日志方法开启事务后设置其事务的传播机制为 NESTED 嵌套式 ( 我就不重复演示修改了 ) . 其余代码还是刚刚演示不支持当前事务的代码
image.png
访问同样的路由方法
image.png
可以看到, 日志和用户都添加成功了. 由于在日志添加中主动进行算数异常的回滚. 因此日志是会回滚的. 看看用户添加是否也回滚了呢 ?
image.png
在数据库中可以看到, 日志正确回滚了. 但是用户也正常添加了. 这就是嵌套式事务.
image.png
肯定有细心的人发现了, 和我们上面演示的不支持当前事务的 REQUIRES_NEW 效果一样. 它两有什么区别呢 ?

六. 嵌套式事务和加入式事务的区别

区别在于 REQUIRES_NEW 无论当前存不存在事务都会建立一个新的事务, 而我们的 NESTED 如果当前存在事务则会把这个嵌套进到当前事务中, 并不会创建新事务.
**嵌套事务之所以能够实现部分事务的回滚，是因为事务中有⼀个保存点（savepoint）的概念，嵌套事务 进⼊之后相当于新建了⼀个保存点，⽽滚回时只回滚到当前保存点，因此之前的事务是不受影响的. 而 REQUIRED 是加⼊到当前事务中，并没有创建事务的保存点，因此出现了回滚就是整个事务回滚, 这就是嵌套事务和加⼊事务的区别 **

  • 整个事务如果执行成功, 二者结果就是一样的
  • 如果事务执行到一半失败了, 那么加入事务整个事务会全部回滚. 而嵌套事务会局部回滚, 不会影响上一个方法中执行的结果.
别时须清欢
关注
  • 7
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
Spring 事务 - 基本使用、传播机制、失效场景、嵌套事务多回滚解决
CYK_byte的博客
03-12 3652
带你一次学懂：编程式事务、声明式事务、事务的传播机制！
【Spring】Spring的7种事务传播机制讲解，以及49种组合方式介绍
zxy2361380031的博客
03-09 6980
Spring的7种事务传播机制讲解，以及49种组合方式介绍
Spring事务
最新发布
2302_82270778的博客
05-22 889
事务就是一组操作的集合，是一个不可分割的操作，事务会把所有的操作作为一个整体，一起向数据库提交或者撤销操作请求，要么同时成功，要么同时失败。
Spring事务及其传播机制
weixin_74352792的博客
01-25 4277
在数据库的时候我们就接触过事物这一概念,简单说事务是一组操作的集合, 是一个不可分割的操作.事务会把所有的操作作为一个整体, 一起向数据库提交或者是撤销操作请求. 所以这组操作要么同时成功, 要么同时失败,事物出现的场景一般都为,操作两个或者多个方法是,需要这些方法要么同时进行要么同时失败.例如银行卡存取钱,我通过ATM机存取钱的时候,后端的数据系统肯定是要进行同步操作的,总不能我通过ATM机取或存了钱,但是由于事故我钱存取了,但是后端数据库却没有变化,这个时候就是"事务"的登场了.
Spring的7种事务传播机制
dayuiicghaid的博客
06-13 2万+
什么是事务？ 事务就是用户定义的一系列数据库操作，这些操作可以视为一个完成的逻辑处理工作单元，要么全部执行，要么全部不执行，是不可分割的工作单元。对数据库的增删改查操作传播机制是什么？ 当A调用B的时候，两个事务是怎么运行的？A出现异常，或者B出现异常，A回不回滚，B回不回滚？还是A回滚，B不回滚？这些问题事务 以非事务性方式运行是什么意思？ 非事务的方式运行，其实就是设置为自动提交了，如果一个方法中有多个操作，则每个操作都会在不同事务中完成，不会保证他们的原子性。事务挂起是什么意思？ 在方法A开始运行时，
Spring事务传播机制
szy350的博客
01-13 2万+
目录 一、事务在Spring中是如何运作的 1.1 开启事务(DataSourceTransactionManager.doBegin) 二、Spring的事务传播机制 2.1 子事务的传播机制为REQUIRED 2.2 子事务的传播机制为REQUIRES_NEW 2.3 子事务的传播机制为NESTED 当我们在使用Spring所提供的事务功能时，如果是仅仅处理单个的事务，是比较容易把握事务的提交与回滚，不过一旦引入嵌套事务后，多个事务的回滚和提交就会变得复杂起来，各个事务之间是如何相互影响的
一文搞通Spring事务的七种传播机制（通俗易懂）
黄团团的个人博客
07-29 3182
最近阅读了网上很多关于讲解Spring事务的七种传播机制的文章，很少有通过结合实际代码进行讲解的，对于小白来说干巴巴的文字解释略微抽象，没有一个具体形象化的概念，下面我就通过理论+实践的方式来对Spring事务的每一种传播机制进行剖析，这样大家也容易记得住，毕竟实践才是检验真理的唯一标准！每一个字和每一行代码都是博主纯手打的！
事务的传播机制
weixin_44771989的博客
04-05 2万+
事务的传播行为
事务的传播机制详解
vespera的博客
06-08 5243
本篇博客详细介绍了事务的七种传播行为，文章通过举例和详细的代码演示，展示了每种传播行为在实际应用中的具体作用和使用场景，以便读者更好地理解和应用这些事务传播行为。文章还强调了正确理解和使用这些传播行为对于有效管理应用中的事务的重要性。
Spring的事务详解
热门推荐
h295928126的博客
06-29 4万+
Spring的事务详解
Spring事务的传播机制
weixin_39885962的博客
07-12 1万+
spring事务指封装在数据库事务之上的一种事务处理机制。其管理方法有两种，分别是编程式事务以及声明式事务。事务的传播，是指一个方法调用另一个方法并将事务传递给它。事务的转播机制主要针对被调用者而言，控制它是否被传播或者被怎样传播。......
Spring传播机制(七种)
qq_36138652的博客
05-22 1916
状态REQUIRES_NEW(两个独立事务)NESTED(B事务嵌套在A事务中)REQUIRED同一个事务A异常B正常A回滚，B正常提交A与B一起回滚A与B一起回滚A正常B异常B先回滚，A正常提交B先回滚，A再正常提交A与B一起回滚A正常B正常B先提交，A再提交A与B一起提交A与B一起提交。
Spring事务传播机制详细讲解
qq_39939541的博客
08-01 2113
事务传播机制允许开发者根据实际需求来控制事务的行为。通过合理选择事务传播机制，可以保证事务的一致性和可靠性，提高系统的稳定性和性能。需要注意的是，事务传播机制只对方法级别的事务起作用，对注解方式的事务不适用。在使用注解方式时，可以通过@Transactional注解的propagation属性来指定事务的传播行为。
Spring 事务（详解）
qq_45559559的博客
03-24 6811
将⼀组操作封装成⼀个执⾏单元，要么全部成功要么全部失败。
Spring中的事务传播机制
LYJbao的博客
03-31 895
为什么需要事务呢？首先需要了解什么是事务，事务就是一组操作封装成一个单元，执行时要么全部成功，要么全部失败~就好比，你给我转账，你那边的金额减少了，我这边突然出故障了，钱就凭空没了，你当然是第一个不乐意呀~ 所以需要事务，当我这边失败时，事务回滚，你那边的金额就会回到转账前的金额~
Spring的事务
weixin_44895829的博客
03-14 9972
1.什么是事务 事务是数据库操作最基本单元，逻辑上一组操作，要么都成功，如果有一个失败所有操 作都失败 （2）典型场景：银行转账 lucy 转账 100 元 给 mary lucy 少 100，mary 多 100 事务四个特性（ACID） （1）原子性 一个事务是一个不可分割的工作单位，事务中包括的诸操作要么都做，要么都不做 （2）一致性 事务必须是使数据库从一个一致性状态变到另一个一致性状态。一致性与原子性是密切相关的。 （3）隔离性 一个事务的执行不能被其他事务干扰...
Spring 事务和事务传播机制
qq_63983125的博客
06-18 2915
Spring 事务和事务传播机制
spring事务传播机制
06-09
Spring事务传播机制是指在一个方法调用中，如果该方法中嵌套了其他事务方法，那么这些事务方法应该如何处理事务。Spring提供了7种不同的事务传播行为，它们分别是： 1. REQUIRED：如果当前存在事务，则加入该事务；如果不存在事务，则创建一个新的事务。 2. SUPPORTS：如果当前存在事务，则加入该事务；如果不存在事务，则以非事务的方式继续运行。 3. MANDATORY：如果当前存在事务，则加入该事务；如果不存在事务，则抛出异常。 4. REQUIRES_NEW：创建一个新的事务，并且暂停当前事务（如果存在）。 5. NOT_SUPPORTED：以非事务的方式运行方法，并且暂停当前事务（如果存在）。 6. NEVER：以非事务的方式运行方法，并且如果当前存在事务，则抛出异常。 7. NESTED：如果当前存在事务，则在嵌套事务中执行；如果不存在事务，则与REQUIRED一样。 在使用事务传播机制时，需要根据具体的业务场景选择适当的传播行为，以确保事务的正确性和完整性。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值