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

java小杰要加油

发布于 2021-05-13 16:47:29

5310

发布于 2021-05-13 16:47:29

文章被收录于专栏：java小杰要加油 java小杰要加油java小杰要加油

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;
    }

结果是