Springboot事务控制中A方法调用B方法@Transactional生效与不生效情况实战总结

已于 2024-05-28 10:56:19 修改
阅读量1k 收藏 12
点赞数 25
分类专栏： # 玩转Spring Boot Java-Web 文章标签： spring spring boot 事务失效 a调用b
于 2024-05-28 10:54:45 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/indexman/article/details/139244564
版权

介绍

本篇对Springboot事务控制中A方法调用B方法@Transactional生效与不生效情况进行实战总结，让容易忘记或者困扰初学者甚至老鸟的开发者，只需要看这一篇文章即可立马找到解决方案，这就是干货的价值。喜欢的朋友别忘记来个一键三连哈：）

实战步骤

由于A方法调用B方法的情况较多，此处按照 一定的命名规则复现各种情况。
例如：

c代表class，c0代表不同类，c1代表同类
a代表a方法，a0代表a方法无事务注解，a1代表有
b代表b方法，b0代表b方法无事务注解，b1代表有
e代表抛异常，ea代表a方法中抛异常；eb代表b方法执行抛异常；

组合起来：c1a0b1ea 表示：同类中a调用b,b上有事务，a中抛异常

创建表

CREATE TABLE `tb_user`  (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `username` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_bin NULL DEFAULT NULL,
  `password` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_bin NULL DEFAULT NULL,
  `nickname` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_bin NULL DEFAULT NULL,
  PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 36 CHARACTER SET = utf8mb4 COLLATE = utf8mb4_bin ROW_FORMAT = Dynamic;

创建测试类

AbstractUserService执行事务操作

@Service
public class AbstractUserService {
    @Autowired
    private UserService userService;

    /**
     *  新增用户
     * @param username
     */
    public void saveUser(String username) {
        UserEntity userEntity = new UserEntity();
        userEntity.setUsername(username);
        userService.save(userEntity);
    }

    /**
     *  更新密码
     * @param username
     */
    public void updatePassword(String username) {
        UserEntity entity = userService.getOne(new LambdaQueryWrapper<UserEntity>().eq(UserEntity::getUsername,username));
        entity.setPassword("123456");
        userService.updateById(entity);
    }

    /**
     * 制造异常
     */
    public void makeException() {
        int i=1/0;
    }
}

Service01 代表a类

@Service
public class Service01 extends AbstractUserService{
    @Autowired
    private Service02 service02;

    // 同类调用
    public void c1_a0_b1_ea(String username){
        saveUser(username);
        this.b1(username,false);
        makeException();
    }

    public void c1_a0_b1_eb(String username){
        saveUser(username);
        this.b1(username,true);
    }

    @Transactional(rollbackFor = Exception.class)
    public void c1_a1_b0_ea(String username){
        saveUser(username);
        this.b0(username,false);
        makeException();
    }


    @Transactional(rollbackFor = Exception.class)
    public void c1_a1_b0_eb(String username){
        saveUser(username);
        this.b0(username,true);
    }

    @Transactional(rollbackFor = Exception.class)
    public void c1_a1_b1_ea(String username){
        saveUser(username);
        this.b1(username,false);
        makeException();
    }

    @Transactional(rollbackFor = Exception.class)
    public void c1_a1_b1_eb(String username){
        try{
            saveUser(username);
            this.b1(username,true);
        }catch (Exception e){
            System.out.println("c1_a1_b1_eb执行失败：");
            throw new RuntimeException("c1_a1_b1_eb执行失败");
        }
    }

    // 不同类调用
    public void c0_a0_b1_ea(String username){
        saveUser(username);
        service02.b1(username,false);
        makeException();
    }

    public void c0_a0_b1_eb(String username){
        saveUser(username);
        service02.b1(username,true);
    }

    @Transactional(rollbackFor = Exception.class)
    public void c0_a1_b0_ea(String username){
        saveUser(username);
        service02.b0(username,false);
        makeException();
    }

    @Transactional(rollbackFor = Exception.class)
    public void c0_a1_b0_eb(String username){
        saveUser(username);
        service02.b0(username,true);
    }

    @Transactional(rollbackFor = Exception.class)
    public void c0_a1_b1_ea(String username){
        saveUser(username);
        service02.b1(username,false);
        makeException();
    }

    @Transactional(rollbackFor = Exception.class)
    public void c0_a1_b1_eb(String username){
        saveUser(username);
        service02.b1(username,true);
    }

    public void b0(String username,boolean hasException){
        updatePassword(username);
        if(hasException){
            makeException();
        }
    }

    @Transactional(rollbackFor = Exception.class)
    public void b1(String username, boolean hasException){
        updatePassword(username);
        if(hasException){
            makeException();
        }
    }




}

Service02 代表b类

@Service
public class Service02 extends AbstractUserService{

    public void b0(String username,boolean hasException){
        updatePassword(username);
        if(hasException){
            makeException();
        }
    }

    @Transactional(rollbackFor = Exception.class)
    public void b1(String username, boolean hasException){
        updatePassword(username);
        if(hasException){
            makeException();
        }
    }
}

测试接口TestController

@RestController
@RequestMapping("")
public class TestController {
    @Autowired
    private Service01 service01;

    /**
     * 同类
     * a没有事务，b有 ，异常发生在a中 不会回滚
     * @return
     */
    @GetMapping("/c1_a0_b1_ea")
    public String test1() {
        service01.c1_a0_b1_ea("c1_a0_b1_ea");
        return "ok";
    }

    /**
     * 同类
     *  a没有事务，b有 ，异常发生在b中 不会回滚
     * @return
     */
    @GetMapping("/c1_a0_b1_eb")
    public String test2() {
        service01.c1_a0_b1_eb("c1_a0_b1_eb");
        return "ok";
    }

    /**
     * 同类
     *  a有事务，b没有 ，异常发生在a中 会回滚
     * @return
     */
    @GetMapping("/c1_a1_b0_ea")
    public String test3() {
        service01.c1_a1_b0_ea("c1_a1_b0_ea");
        return "ok";
    }

    /**
     * 同类
     *  a有事务，b没有 ，异常发生在b中 会回滚
     * @return
     */
    @GetMapping("/c1_a1_b0_eb")
    public String test4() {
        service01.c1_a1_b0_eb("c1_a1_b0_eb");
        return "ok";
    }

    /**
     * 同类
     *  a有事务，b有 ，异常发生在a中 会回滚
     * @return
     */
    @GetMapping("/c1_a1_b1_ea")
    public String test5() {
        service01.c1_a1_b1_ea("c1_a1_b1_ea");
        return "ok";
    }

    /**
     * 同类
     *  a有事务，b有 ，异常发生在b中 会回滚
     * @return
     */
    @GetMapping("/c1_a1_b1_eb")
    public String test6() {
        service01.c1_a1_b1_eb("c1_a1_b1_eb");
        return "ok";
    }


    /**
     * 不同类
     *  a没有事务，b有 ，异常发生在a中 不会回滚
     * @return
     */
    @GetMapping("/c0_a0_b1_ea")
    public String test7() {
        service01.c0_a0_b1_ea("c0_a0_b1_ea");
        return "ok";
    }

    /**
     * 不同类
     *  a没有事务，b有 ，异常发生在b中 只有b回滚
     * @return
     */
    @GetMapping("/c0_a0_b1_eb")
    public String test8() {
        service01.c0_a0_b1_eb("c0_a0_b1_eb");
        return "ok";
    }

    /**
     * 不同类
     *  a有事务，b没有 ，异常发生在a中 会回滚
     * @return
     */
    @GetMapping("/c0_a1_b0_ea")
    public String test9() {
        service01.c0_a1_b0_ea("c0_a1_b0_ea");
        return "ok";
    }

    /**
     * 不同类
     *  a有事务，b没有 ，异常发生在b中 会回滚
     * @return
     */
    @GetMapping("/c0_a1_b0_eb")
    public String test10() {
        service01.c0_a1_b0_eb("c0_a1_b0_eb");
        return "ok";
    }

    /**
     * 不同类
     *  a有事务，b有 ，异常发生在a中 会回滚
     * @return
     */
    @GetMapping("/c0_a1_b1_ea")
    public String test11() {
        service01.c0_a1_b1_ea("c0_a1_b1_ea");
        return "ok";
    }

    /**
     * 不同类
     *  a有事务，b有 ，异常发生在b中 会回滚
     * @return
     */
    @GetMapping("/c0_a1_b1_eb")
    public String test12() {
        service01.c0_a1_b1_eb("c0_a1_b1_eb");
        return "ok";
    }
}

测试结果

http://localhost:9000/test/c0_a1_b1_eb

在浏览器中依次访问测试接口中的每个方法，得到表中结果：
以下情况未回滚或者半回滚，不在表里的均正常回滚事务。
在这里插入图片描述

原理总结

原理：
spring 在扫描bean的时候会扫描方法上是否包含@Transactional注解，如果包含，spring会为这个bean动态地生成一个子类（即代理类，proxy），代理类是继承原来那个bean的。
此时，当这个有注解的方法被调用的时候，实际上是由代理类来调用的，代理类在调用之前就会启动transaction。然而，如果这个有注解的方法是被同一个类中的其他方法调用的，那么该方法的调用并没有通过代理类，而是直接通过原来的那个bean，所以就不会启动transaction，我们看到的现象就是@Transactional注解无效。

那回到一开始的问题，我们调用的方法A不带注解，因此代理类不开事务，而是直接调用目标对象的方法。当进入目标对象的方法后，执行的上下文已经变成目标对象本身了，因为目标对象的代码是我们自己写的，和事务没有半毛钱关系，此时你再调用带注解的方法，照样没有事务，只是一个普通的方法调用而已。
简单来说，内部调用本类方法，不会再走代理了，所以B的事务不起作用。

如果AB不同类，A调用的事代理类B，故B有事务。

参考文章

  • https://blog.csdn.net/weixin_36586564/article/details/105687331
  • https://juejin.cn/post/7031446300142862373
  • 【@Transactional注解失效的几种情况】
    https://blog.csdn.net/Yaml4/article/details/138123693
罗汉爷
关注
  • 25
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
@Transactional 同一个类中无事务方法a()内部调用有事务方法b()的问题
u010235716的博客
05-13 9809
1. 事务的4种特性 序号 参数 含义 1 原子性(Atomicity) 事务是数据库的逻辑工作单位，它对数据库的修改要么全部执行，要么全部不执行。 2 一致性(Consistemcy) 事务前后，数据库的状态都满足所有的完整性约束。 3 隔离性(Isolation) 并发执行的事务是隔离的，一个不影响一个。通过设置数据...
SpringBoot开启异步调用方法
08-25
* 异步方法的调用：在同一个类中，一个方法调用另外一个有 @Async 注解的方法，注解是不会生效的。 总结，SpringBoot 异步调用可以提高系统的性能和响应速度，但是需要注意相关的注意事项和缺点。
serviceA调用serviceB,如果serviceB抛出异常,serviceA会不会回滚?
一蓑烟雨任平生
10-19 5462
https://blog.csdn.net/J080624/article/details/74999858/ 问题描述 serviceA中的methodA调用serviceB中的methodB，methodB抛出一个异常，然后methodA捕获掉这个异常，就会出现 Transaction rolled back because it has been marked as rollback-only 异常 (serviceA和serviceB都加了注解@Transactional(rollbackFor
Spring事务嵌套机制
热门推荐
sun82111的专栏
07-10 1万+
Spring 事务机制回顾 Spring事务一个被讹传很广说法是：一个事务方法不应该调用另一个事务方法，否则将产生两个事务.结果造成开发人员在设计事务方法时束手束脚，生怕一不小心就踩到地雷。 其实这是不认识Spring事务传播机制而造成的误解，Spring对事务控制的支持统一在TransactionDefinition类中描述，该类有以下几个重要的接口方法： int ge...
@Transactional注解使用注意
最新发布
qq_43577998的博客
03-26 904
程序继续执行，aFunction函数里面把异常给抓出来了，这个时候aFunction函数没有抛出异常，既然你没有异常那事务就需要提交，会调事务的commit函数；这种情况也很好解释，因为两个函数不是同一个事务了，所以bFunction抛异常只会导致bFunction的回滚，不影响aFunction所在事务的正常执行；原因：方法被事务管理是因为Apring AOP为其生成代理了对象，但是直接this调用同类方法，调用的是目标类对象的方法，而非代理类方法，因此，在同类中的方法直接内部调用，会导致事务失效；
Spring事务使用的一个误区
utf7的技术博客
12-09 2538
Spring bean 假设有如下类 public class Service implement IService{ @Transactional(readOnly = false, propagation=Propagation.REQUIRED) public void methodA(){ ..... methodB() ......
事务方法A调用事务方法B，方法B抛出的异常被方法A catch后会发生什么？
吴就业
05-14 1万+
方法抛出异常导致事务已经回滚，且当前事务被标志为仅回滚，因此当前事务只能回滚，不能再执行提交，如果执行提交，就能看到上述异常。去掉配置后对系统的影响很大，事务不生效会引发很多问题，将整个系统让测试部门重新测试一遍也不现实。业务需要，不抛出异常)只要找出在哪里配置的，将配置去掉问题也就能解决了。方法执行完成时，事务切面走的不是回滚逻辑，而是提交逻辑。虽然方法没有声明事务，可是该方法却在事务中执行，那么我们可以在。是在事务中执行的，也是因为如此，我才调试了半天。方法抛出异常后，当前事务回滚，异常往外抛出，被。
springboot：A事务调用B事务问题
hh790941693的博客
12-01 619
请问下：为什么小王没有插入到数据库？小红插入失败回滚会什么会导致小王也回滚了？调用createUser3方法时，会调用内部事务方法createUser4。预期：小王成功插入，小红没有插入。实际：小王和小红都没有插入。
@Transactional
u011393781的博客
09-19 1057
@Transactional (1)可以标注在类和方法上，也可以标注的定义的接口和接口方法上。 （2）若在接口上标注@Transactional注解，会留下这样的隐患：因为注解不能被继承，所以业务接口中标注的@Transactional注解会被业务实现类继承，所以可能会出现不启动事务的情况，所以Spring建议我们将@Transaction注解在是实现类上。 （3）在方法上的@Tra
springBoot方法上或类上面添加@Transactional注解 A调用B问题【亲测】
weixin_43594592的博客
03-10 2435
一、A调用B，B调用C，C加注解 @Component public class Abc{ public void a(ApplyTaskOriginalDataCustomizeMapper applyTaskOriginalDataMapper){ b(applyTaskOriginalDataMapper); } public void b(ApplyTaskOriginalDataCustomizeMapper applyTaskOriginal
Spring事务@Transactional
wey1234567的博客
07-17 214
spring支持声明式事务管理和编程式事务管理两种方式。 编程式事务管理使用TransactionTemplate或者使用底层的PlatformTransactionManager，推荐使用TransactionTemplate。 声明式事务是建立在aop之上的，其本质是对方法前后进行拦截，然后再目标方法开始之前创建或者加入一个事务，在执行完目标方法之后根据执行情况进行提交或者回滚。 @Trans...
Java注解@Transactional事务类内调用不生效问题及解决办法
08-19
但是，如果在同一个类中的其他方法调用有@Transactional注解的方法时，Spring不会生成代理对象，导致事务不生效。 例如，以下代码中，dosome()方法上有@Transactional注解，但是如果在action()方法中调用dosome()，...
什么情况会导致@Transactional事务失效？
10-08
在Java编程中，`@Transactional`注解是Spring框架提供的一种事务管理机制，它使得开发者能够在方法级别方便地声明事务边界。然而，在某些特定情况下，`@Transactional`可能会失效，导致事务无法正常工作。以下是一些...
Spring3事务管理——使用@Transactional 注解.rar
09-16
- `@Transactional`注解仅在Spring AOP代理能够拦截到的方法上生效，因此，如果在非Spring管理的类或静态方法中使用，事务管理将不起作用。 - 如果事务属性设置不当，可能会导致数据不一致或并发问题，应谨慎调整...
Spring @Transactional注解失效解决方案
08-25
如果方法没有关联到一个事务，容器不会为他开启事务，如果方法在一个事务中被调用，该事务会被挂起，调用结束后，原先的事务会恢复执行。 3. REQUIRESNEW：不管是否存在事务，该方法总汇为自己发起一个新的事务。...
spring，springboot之事务（事务传播机制详解、嵌套事务）
qq_35493807的博客
04-27 8641
spring，springboot之事务（事务传播机制、嵌套事务、事务隔离机制详解）
A调用B方法，@Transactional事务问题几种场景
星威四海的博客
09-29 1890
Transactional事务问题几种场景
Spring的事务 方法A调用方法B，事务是否失效
lzq2357639195的博客
03-21 6139
springboot的有事务方法调用没有方法的事务，事务是否失效？
@Transactional方法A调用 @Transactional方法B 会有什么问题
12-20
当使用@Transactional注解时，方法会被包装在一个事务中。如果方法A调用了方法B，并且两个方法都被@Transactional注解修饰，那么事务将无法正常工作。这是因为Spring默认使用基于代理的AOP来实现@Transactional注解的功能，而代理只能拦截外部调用，无法拦截类内部方法的调用。 在你提供的引用中，方法A没有@Transactional注解，而方法B有@Transactional注解。当方法A调用方法B时，事务不会起作用，因为方法A内部的方法调用无法被代理拦截。 在你提供的引用中，方法A调用了方法B，方法B调用了方法C，并且方法C被@Transactional注解修饰。然而，由于方法A内部的方法调用无法被代理拦截，所以方法C的事务也无法起作用。即使方法C抛出了异常，事务也不会回滚。 为了解决这个问题，可以将@Transactional注解放在类级别上，而不是方法级别上。这样，整个类的所有方法都会被包装在同一个事务中，无论是外部调用还是内部调用。 另外，还可以通过将方法C提取到一个独立的类中，并通过依赖注入的方式调用该类的方法，来实现事务的正常工作。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值