搜索

面试官：聊聊spring的七种事务传播行为？

java宝典

共 16962字，需浏览 34分钟

 ·

2021-05-08 00:16

❝
  • 大家好，这里是公众号：「java小杰要加油」
  • 我们都知道 「spring」 有七种事务传播行为，面试也经常被问道，不过他们长得都太像啦，老虎老鼠傻傻分不清楚,今天我们就用这篇文章来彻底搞懂他们！
  • 文中有「大量代码」论证，建议「收藏在电脑端食用」
❞
  • 话不多说，直接开车

spring的七种事务传播行为

❝

以下事务传播属性都是打在B方法上的事务注解

❞

  • 「Propagation.REQUIRED：」 spring默认的事务传播行为，A方法调用B方法，如果A方法有事务，则B方法加入到A方法中的事务中，否则B方法自己开启一个新事务

  • 「Propagation.SUPPORTS：」 A方法调用B方法，如果A方法有事务，则B方法加入到A方法中的事务中，否则B方法自己使用非事务方式执行

  • 「Propagation.MANDATORY：」 只能在存在事务的方法中被调用，A方法调用B方法，如果A方法没事务，则B方法会抛出异常

  • 「Propagation.REQUIRES_NEW：」 A方法调用B方法，如果A方法有事务，则B方法把A方法的事务挂起，B方法自己重新开启一个新事务

  • 「Propagation.NOT_SUPPORTED：」 A方法调用B方法，如果A方法有事务，则B方法挂起A方法中的事务中，否则B方法自己使用非事务方式执行

  • 「Propagation.NEVER：」 不支持事务，A方法调用B方法，如果A方法有事务，则B方法会抛出异常

  • 「Propagation.NESTED：」 同 「Propagation.REQUIRED」，不过此传播属性还可以，「保存状态节点，从而避免所有嵌套事务都回滚」

我们看完了每个传播属性的一些解释，脑子里应该是还是蒙蒙的，下面来看下真正的代码

实战

Propagation.REQUIRED

  • spring 默认的事务传播属性，A方法调用B方法，如果A方法有事务，则B方法加入到A方法中的事务中，否则B方法自己开启一个新事务

A接口

@Transactional(rollbackFor = Exception.class,propagation = Propagation.REQUIRED)
    @Override
    public Integer updateTest(Test updateVO) {
        System.out.println("A updateTest方法");
        int i = testMapper.updateByPrimaryKey(updateVO);
        Test test =new Test("小杰",24);
        // 调用B接口的insertTest方法事务方法
        BTestService.insertTest(test);
        return i;
    }

我们再来看下B接口

 @Transactional(rollbackFor = Exception.class,propagation = Propagation.REQUIRED)
    @Override
    public Integer insertTest(Test updateVO) {
        System.out.println("B insertTest方法");
        int i = testMapper.insert(updateVO);
        //  抛出异常
        int a = 1 / 0 ;
        return i;
    }

假如说，我代码这么写的话，那么这个数据库里最终是会有什么数据呢？

@PostMapping("/update")
    public Object updateTest(@RequestBody Test updateVO){
        Integer flag = ATestService.updateTest(updateVO);
        return flag;
    }

原数据库内容

postman来一发看看

可以看到控制台的结果是这样的，他们共用一个事务（sqlSession是一样的）

此时数据库的内容也并没有发生变化，说明A,B接口都回滚了

❝

这个时候就会出现一个常见的面试题：如果B方法抛出的异常被「A方法try catch」 捕获了，那么A方法的操作还会回滚吗？

❞

答案是：「会回滚」

来看下测试代码，我们在A方法中添加了捕获B方法抛出异常的代码

@Transactional(rollbackFor = Exception.class,propagation = Propagation.REQUIRED)
    @Override
    public Integer updateTest(Test updateVO) {
        System.out.println("A updateTest方法");
        int i = testMapper.updateByPrimaryKey(updateVO);
        Test test =new Test("小杰",24);
          try {
               // 调用insertTest方法事务方法
               BTestService.insertTest(test);
           }catch (Exception e){
               System.out.println("A方法补获了异常"+e.getMessage());
           }
        return i;
    }

再次来一发postman，控制台输出测试结果如下

我们看数据库数据也没有变

❝

那么问题又来了,如果「A没有捕获，B方法自己捕获了异常」，那么事务还会回滚吗？答案是：「不会」

❞

把B接口的代码改一下

@Transactional(rollbackFor = Exception.class,propagation = Propagation.REQUIRED)
    @Override
    public Integer insertTest(Test updateVO) {
        System.out.println("B insertTest方法");
        int i = 0;

        try {
             i = testMapper.insert(updateVO);
            //  抛出异常
            int a = 1 / 0 ;
        }catch (Exception e){
            System.out.println("B方法补获了异常"+e.getMessage());
        }

        return i;
    }

同时把A方法的捕获异常去掉

@Transactional(rollbackFor = Exception.class,propagation = Propagation.REQUIRED)
    @Override
    public Integer updateTest(Test updateVO) {
        System.out.println("A updateTest方法");
        int i = testMapper.updateByPrimaryKey(updateVO);
        Test test =new Test("小杰",24);
        // 调用insertTest方法事务方法
        BTestService.insertTest(test);
        return i;
    }

这个时候的结果是

数据库的数据是

由此可见，A和B两个接口都生效了都操作数据库了，都没有回滚

A方法捕获和B方法捕获有什么区别吗（指捕获异常）
  • 区别就是,A方法捕获异常的话，B方法的事务注解会感知到异常的发生，从而回滚；
  • 而B方法自己捕获了，那么B方法的事务注解就不会感知到异常了，所以不会回滚
❝

只要理解了上面这个例子，我们以后各种异常/传播属性到底回滚不回滚就好分析啦！

❞

Propagation.SUPPORTS

  • A方法调用B方法，如果A方法有事务，则B方法加入到A方法中的事务中，否则B方法自己使用非事务方式执行

我们把B接口的事务传播属性换成 Propagation.SUPPORTS

@Transactional(rollbackFor = Exception.class,propagation = Propagation.SUPPORTS)
    @Override
    public Integer insertTest(Test updateVO) {
        System.out.println("B insertTest方法");
        int i = testMapper.insert(updateVO);
        //  抛出异常
        int a = 1 / 0 ;
        return i;
    }

A方法

@Transactional(rollbackFor = Exception.class,propagation = Propagation.REQUIRED)
    @Override
    public Integer updateTest(Test updateVO) {
        System.out.println("A updateTest方法");
        int i = testMapper.updateByPrimaryKey(updateVO);
        Test test =new Test("小杰",24);
        // 调用insertTest方法事务方法
        BTestService.insertTest(test);
        return i;
    }

测试结果是

数据库的值也没有被改变 ， 所以两个操作都被回滚了 那我们把A方法的事务注解去掉后再看一下

 @Override
    public Integer updateTest(Test updateVO) {
        System.out.println("A updateTest方法");
        int i = testMapper.updateByPrimaryKey(updateVO);
        Test test =new Test("小杰",24);
        // 调用insertTest方法事务方法
        BTestService.insertTest(test);
        return i;
    }

测试结果是是

数据库的值是

由此可见，两个操作都没有被回滚，B方法是以非事务方式进行的操作

Propagation.MANDATORY

❝

只能在存在事务的方法中被调用，A方法调用B方法，如果A方法没事务，则B方法会抛出异常

❞

A接口如下

@Override
    public Integer updateTest(Test updateVO) {
        System.out.println("A updateTest方法");
        int i = testMapper.updateByPrimaryKey(updateVO);
        Test test =new Test("小杰",24);
        // 调用insertTest方法事务方法
        BTestService.insertTest(test);
        return i;
    }

B接口如下

@Transactional(rollbackFor = Exception.class,propagation = Propagation.MANDATORY)
    @Override
    public Integer insertTest(Test updateVO) {
        System.out.println("B insertTest方法");
        int i = testMapper.insert(updateVO);
        //  抛出异常
        int a = 1 / 0 ;
        return i;
    }

数据库的值也没有变，由此可见，B方法的事务注解为 Propagation.MANDATORY 当A方法没事务时，则直接报错。

Propagation.REQUIRES_NEW

  • A方法调用B方法，如果A方法有事务，则B方法把A方法的事务挂起，B方法自己重新开启一个新事务

A方法

@Transactional(rollbackFor = Exception.class,propagation = Propagation.REQUIRED)
    @Override
    public Integer updateTest(Test updateVO) {
        System.out.println("A updateTest方法");
        int i = testMapper.updateByPrimaryKey(updateVO);
        Test test =new Test("小杰",24);
        // 调用insertTest方法事务方法
        BTestService.insertTest(test);
        return i;
    }

B方法

@Transactional(rollbackFor = Exception.class,propagation = Propagation.REQUIRES_NEW)
    @Override
    public Integer insertTest(Test updateVO) {
        System.out.println("B insertTest方法");
        int i = testMapper.insert(updateVO);
        //  抛出异常
        int a = 1 / 0 ;
        return i;
    }

结果是其中可以发现 两个接口的 DefaultSqlSession  不一样，那么就表明，这两个不是一个事务，所以就是，当A接口存在事务的时候，B接口将其挂起并且重新开启一个新的事务

❝
  • B方法抛出了异常，那么A方法没有捕获的话，则A,B方法都会回滚
  • A方法捕获了异常，则A方法不回滚
❞

「还是那句话，如果在方法内捕获了异常，则此方法上的事务注解就感知不到这个异常的存在了，那么此方法的操作就不会回滚！」

Propagation.NOT_SUPPORTED

❝

A方法调用B方法，如果A方法有事务，则B方法挂起A方法中的事务中，否则B方法自己使用非事务方式执行

❞

A接口

@Transactional(rollbackFor = Exception.class,propagation = Propagation.REQUIRED)
    @Override
    public Integer updateTest(Test updateVO) {
        System.out.println("A updateTest方法");
        int i = testMapper.updateByPrimaryKey(updateVO);
        Test test =new Test("小杰",24);
        // 调用insertTest方法事务方法
        BTestService.insertTest(test);
        return i;
    }

B接口

@Transactional(rollbackFor = Exception.class,propagation = Propagation.NOT_SUPPORTED)
    @Override
    public Integer insertTest(Test updateVO) {
        System.out.println("B insertTest方法");
        int i = testMapper.insert(updateVO);
        //  抛出异常
        int a = 1 / 0 ;
        return i;
    }

测试结果是

数据库的结果是

❝

我们可以看到，B接口生效了，确实插入了一条数据，A接口没有生效，没有更改数据，这是因为，异常在B接口内抛出来了，由于B接口的事务传播行为是 Propagation.NOT_SUPPORTED 则会挂起A接口的事务，B接口以非事务情况操作（所以报错也不回滚），异常刨到了A接口内，A接口是有事务的，则会回滚，所以就没有更改数据

❞

Propagation.NEVER

  • 不支持事务，A方法调用B方法，如果A方法有事务，则B方法会抛出异常

A接口

@Transactional(rollbackFor = Exception.class,propagation = Propagation.REQUIRED)
    @Override
    public Integer updateTest(Test updateVO) {
        System.out.println("A updateTest方法");
        int i = testMapper.updateByPrimaryKey(updateVO);
        Test test =new Test("小杰",24);
        // 调用insertTest方法事务方法
        BTestService.insertTest(test);
        return i;
    }

B接口

@Transactional(rollbackFor = Exception.class,propagation = Propagation.NEVER)
    @Override
    public Integer insertTest(Test updateVO) {
        System.out.println("B insertTest方法");
        int i = testMapper.insert(updateVO);
        //  抛出异常
        int a = 1 / 0 ;
        return i;
    }

结果是

数据库也没有被改变， 可见，当A接口有事务的情况下调用B接口，直接报错

Propagation.NESTED

  • 同 「Propagation.REQUIRED」，不过此传播属性还可以，「保存状态节点，从而避免所有嵌套事务都回滚」

A接口

@Transactional(rollbackFor = Exception.class,propagation = Propagation.REQUIRED)
    @Override
    public Integer updateTest(Test updateVO) {
        System.out.println("A updateTest方法");
        int i = testMapper.updateByPrimaryKey(updateVO);
        Test test =new Test("小杰",24);
          try {
               // 调用insertTest方法事务方法
               BTestService.insertTest(test);
           }catch (Exception e){
               System.out.println("A方法补获了异常"+e.getMessage());
           }
        return i;
    }

B接口

@Transactional(rollbackFor = Exception.class,propagation = Propagation.NESTED)
    @Override
    public Integer insertTest(Test updateVO) {
        System.out.println("B insertTest方法");
        int i = testMapper.insert(updateVO);
        //  抛出异常
        int a = 1 / 0 ;
        return i;
    }

结果是

数据库的变化如下

A接口的操作没有回滚，B操作的回滚了，这就是因为“savePoint”安全点，在进行B接口操作时，当前的状态（A接口已经操作完了）被保存至安全点，B接口失败的话，回滚只会回滚到这个安全点

❝

注：需要在A接口里try catch B接口的异常

❞

这里是公众号：「java小杰要加油」，我们下期见

好文推荐


浏览 31
点赞
评论
收藏
分享

手机扫一扫分享

分享
举报
评论
图片
表情
推荐
Spring 事务传播行为的理解
泥瓦匠BYSocket
0
Spring事务传播行为详解
泥瓦匠BYSocket
0
带你读懂Spring的事务传播行为
好好学java
0
浅谈Spring的事务隔离级别与传播行为
互联网全栈架构
0
手把手利用实战代码带你读懂Spring的事务传播行为
业余草
0
京东面试官问我：“聊聊MySql事务？”
程序IT圈
0
一个99%的人都说不清楚知识点——Spring 事务传播行为
博文视点Broadview
0
面试官：聊聊分布式事务，再说说解决方案！
互联网架构师
0
面试官：聊聊分布式事务，再说说解决方案！
小哈学Java
0
面试官：聊聊分布式事务，再说说解决方案！
Java技术栈
0
点赞
评论
收藏
分享

手机扫一扫分享

分享
举报