spring中7种事务传播行为测试demo

于 2023-01-31 15:41:44 发布
阅读量377 收藏 2
点赞数
分类专栏： Java spring 文章标签： spring java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42351206/article/details/128625119
版权
Java 同时被 2 个专栏收录
17 篇文章 0 订阅
订阅专栏
spring
4 篇文章 1 订阅
订阅专栏

spring中的事务传播机制的demo、事务7种传播行为Demo、@Transation常见面试题、@Transactional注解啥时候下失效?、一个service调用另一个service的事务传播行为、serviceA调用serviceB，serviceA中加了Transaction，serviceB没加，如果a、b有一个报错会怎样、@transtational可以加在私有方法中吗？、spring的事务传播行为，同一个类中，a事务正常，b方法报错了，这个整体是回滚还是提交、@Transaction详解、@Transaction中调用方报错，被调用方会回滚事务嘛、service调用另一个service报错了，两个都会回滚吗

文章目录

前言

之前部门内部开会，复盘线上事故时，同事有个bug，排查的时候发现是由于对spring中的事务传播行为理解的不清晰导致的。因此写篇文章，分享出来的同时，也能让我再次熟悉一下事务传播。本人水平有限，如有误导，欢迎斧正，一起学习，共同进步！

一、什么是事务？

事务的ACID四大特性，咱们这次主要针对于A原子性。原子性，简单的说，我要做两件事，要么同时成功，要么同时失败，不能是一件成功一件失败。如果第一件成功了，第二件失败了，那我会让第一件也失败，这就是事务。其实能搜到这篇文章的，大家应该都知道，直接看demo吧。

二、demo地址以及前置工作

1、git地址

项目代码路径是：git地址有需求的可以自行下载。

2、7种传播行为

在这里插入图片描述

  • REQUIRED：spring默认的事务传播级别，当前存在事务，则加入该事务，当前不存在事务，则新建一个事务。

  • REQUIRED_NEW：如果当前没有事务，则新建一个事务。如果当前存在事务，则新建一个事务。(不管原先有没有，都会新建事务)。新老事务相互独立，外部事务抛出异常回滚不会影响内部事务的正常提交。

  • SUPPORTS：如果调用方(A)有事务时，被调用方(B)加入到A的事务中；如果A没有事务，则以非事务的方式运行。

  • NOT_SUPPORTED：以非事务的方式运行，如果有事务，则将当前事务挂起。

  • MANDATORY：强制事务执行，如果当前存在事务，则加入该事务；如果当前不存在事务，则抛出异常。

  • NEVER：以非事务方式运行，如果不存在事务，以非事务方式运行。如果存在事务，则抛出异常。

  • NESTED：NESTED是说，如果当前存在事务，则嵌套在当前事务中执行；如果当前没有事务，则新建一个事务。

3、调用顺序

当A方法调用B方法时，流程如下。下面demo中的A方法指UserService，B方法指TeacherService ， 也就是调用方指A，被调用方指B。
在这里插入图片描述

三、demo代码。

1.Transactional(propagation = Propagation.REQUIRED)

spring默认的事务传播级别，当前存在事务，则加入该事务，当前不存在事务，则新建一个事务。

1.1、外部(调用方,A方法)无事务

测试：外部无事务，内部有事务，内部事务是required。外部抛异常。
结论：外层方法没有事务时，即使外层方法报错，两次提交都不会回滚。
因为外层没有事务时，insert(user的insert)会自动提交(由于连接的是mysql数据库，所以会自动提交)，所以你insert之后的异常，是没有用的，已经提交了。
而Teacher的insert，是由于teacher成功了，所以teacher他也提交了(由于连接的是mysql数据库，所以会自动提交)，导致的现象就是，即使方法报错了，也两次都提交了。

/**
 * @author: ztl
 * @date: 2022/12/27 11:18
 * @desc: 测试：外部无事务，内部有事务，内部事务是required。外部抛异常。
 *  结论：外部、内部都不会回滚。
 *  测试User(A)没有事务，teacher(B)会自己创建事务。
 *  这里没有开启事务，teacherService.insert(); 会自己开启事务。
 *          teacherService.insert()方法上有@Transactional(propagation = Propagation.REQUIRED)
 *  而且俩个添加操作都会成功。因为userMapper.insert(user);是自动提交的(因为这个insert0方法没开启事务，又是mysql，所以自动提交了)
 *
 *      因为调用方的A方法(insert0)没有事务，所以 userMapper.insert(user);会自动提交，因为没有事务，且是mysql默认级别是可重复读，自动提交
 *      而teacherService.insert();虽然加了注解，开启了事务，但是由于他成功了，所以他也提交了。
 *      所以尽管insert0方法最后报错了，但是由于这俩都各自提交了，所以并不会回滚。
 */
@Override
public void insert0(){

    teacherService.insert();

    User user = new User(1,"user_"+System.currentTimeMillis());
    userMapper.insert(user);

    int i = 1/0; // 这里抛出异常，两个提交操作都不会回滚(会成功)
}


============= teacherService.insert();方法如下： ==========
 
    @Override
    @Transactional(propagation = Propagation.REQUIRED)
    public int insert() {
        Teacher teacher = new Teacher(1,"teacher_"+System.currentTimeMillis());
        return teacherMapper.insert(teacher);
    }

1.2、外部(调用方，A方法)有事务

测试：外部有事务，是required，内部有事务，是required。外部抛异常。
结论：外部、内部都会回滚事务。
当外层的，调用方的方法(A方法)有事务时，被调用方(B方法)即使有事务，也会加入到当前的事务中，所以他们是同一个事务，都是insert1方法的事务，所以当有异常时，两个都会回滚。

/**
 * @author: ztl
 * @date: 2022/12/28 10:20
 * @desc: 测试：外部有事务，是required，内部有事务，是required。外部抛异常。
 *   结论：外部、内部都会回滚事务。
 *   A(调用方，也就是insert1)方法加了@Transactional注解，会开启事务。
 *   teacherService.insert(); 也加了@Transactional注解，也会开启事务
 *   由于user的insert1方法有事务了，而且teacherService.insert()的类型是REQUIRED，
 *          所以teacher的事务会加入到user的事务(insert1方法的事务)，就是同一个事务了。
 *   同一个事务中，有异常，所以两个都会回滚
 *
 */
@Transactional(propagation = Propagation.REQUIRED)
@Override
public void insert1(){
    teacherService.insert();

    User user = new User(2,"user_"+System.currentTimeMillis());
    userMapper.insert(user);

    int i = 1/0; // 这里抛出异常，两个提交操作都会回滚(不会成功)
}

============= teacherService.insert();方法如下： ==========
@Override
@Transactional(propagation = Propagation.REQUIRED)
public int insert() {
    Teacher teacher = new Teacher(1,"teacher_"+System.currentTimeMillis());
    return teacherMapper.insert(teacher);
}

2、Transactional(propagation = Propagation.REQUIRED_NEW)

2.1、外部(调用方,A方法)抛异常

REQUIRED_NEW的意思是，如果当前没有事务，则新建一个事务。如果当前存在事务，则新建一个事务。(不管原先有没有，都会新建事务)。新老事务相互独立，外部事务抛出异常回滚不会影响内部事务的正常提交。

测试：外部有事务，是required，内部有事务，是required_new。外部抛异常
结论：外层insert2报错，teacherService.insert2不会回滚，userMapper.insert会回滚。
内部事务是required_new的传播行为时，会新建一个事务，即使外部事务回滚也不会影响内部事务的提交。外层方法开启事务时，即使外层方法报错，内部的事务不会回滚，依然会提交。
注意：外部方法是 required，内部方法是 required_new

/**
 * @author: ztl
 * @date: 2022/12/27 11:18
 * @desc: 测试：外部有事务，是required，内部有事务，是required_new。外部抛异常
 *  结论：外层insert2报错，teacherService.insert2不会回滚，userMapper.insert会回滚。
 *   teacherService.insert2()的传播行为是propagation = Propagation.REQUIRES_NEW
 *   由于调用方(A,也就是insert2)加了Transactional，开启了事务，被调用方(B,也就是teacherService.insert2)也开启了事务，
 *          并且B的传播行为是REQUIRED_NEW，不管当前有没有事务，都会新建一个事务，并且外部事务回滚不会影响内部事务提交。
 *          所以teacherService.insert2()新建了一个新事务，并且新事务成功，所以会提交。
 *          即使外部user的insert2方法异常了，也不影响内部teacher的insert2方法的提交
 *   总的流程如下：
 *      user的insert2开启了一个事务。
 *      teacher的insert2开启了一个事务，并且将user的insert2的事务挂起
 *      user的insert2的事务运行完毕，再恢复user的insert2的事务，
 *      两个事务的提交和回滚都在各自的事务中完成。
 */
@Transactional(propagation = Propagation.REQUIRED)
@Override
public void insert2(){
    teacherService.insert2();

    User user = new User(1,"user_"+System.currentTimeMillis());
    userMapper.insert(user);

    int i = 1/0; // 这里抛出异常，两个提交操作都会回滚(不会成功)
}


============= teacherService.insert();方法如下： ==========

@Override
@Transactional(propagation = Propagation.REQUIRES_NEW)
public int insert2() {
    Teacher teacher = new Teacher(1,"teacher_"+System.currentTimeMillis());
    return teacherMapper.insert(teacher);
}

2.2、内部(被调用方，B方法)抛异常

测试：外部有事务，是required。内部有事务，是required_new，在内部抛出异常。
结论：外部、内部都会回滚。
虽然是俩事务，但是内部事务异常回滚了，内部会将异常抛出去，抛到外层，相当于外部调用那行直接new throw Exception，所以会回滚。

/**
 * @author: ztl
 * @date: 2022/12/27 11:18
 * @desc: 测试：外部有事务，是required。内部有事务，是required_new，在内部抛出异常。
 *  结论：外部、内部都会回滚。虽然是俩事务，但是内部事务异常回滚了，内部会将异常抛出去，相当于外部也有异常了。
 *  外部有事务，是required，内部有事务，是required_new.
 *  内部事务开启，将外部事务挂起，内部事务异常，内部事务回滚。并且，内部将异常抛出到外部，
 *  内部事务执行完毕，将外部事务从挂起恢复，外部事务异常(是由内部抛出来的)，外部事务回滚。
 *  其实teacherService.insert3()异常，就相当于直接在这行代码下面，写一句：
 *      throw new Exception..，所以，内部、外部都会回滚。
 */
@Transactional(propagation = Propagation.REQUIRED)
@Override
public void insert3(){

    User user = new User(1,"user_"+System.currentTimeMillis());
    userMapper.insert(user);

    // 这个方法会抛出异常，就相当于直接在这个代码的下面写： int i = 1/0,也就相当于直接在这段下面 throw new Exception..
    teacherService.insert3();
}

============= teacherService.insert();方法如下： ==========
@Transactional(propagation = Propagation.REQUIRES_NEW)
@Override
public int insert3() {
    Teacher teacher = new Teacher(1,"teacher_"+System.currentTimeMillis());
    int insert = teacherMapper.insert(teacher);

    int i = 1/0; // 这里抛出异常，内部有异常的话，会将异常抛出去，所以外部也会有异常了。
    return insert;
}

3、Transactional(propagation = Propagation.SUPPORTS

如果调用方(A)有事务时，被调用方(B)加入到A的事务中；如果A没有事务，则以非事务的方式运行。

3.1、外部(调用方,A方法)有事务

测试：外部有事务REQUIRED，内部有事务SUPPORTS,外部抛异常
结论：两个都回滚。

/**
 * @author: ztl
 * @date: 2022/12/29 16:54
 * @desc: 外部有事务REQUIRED，内部有事务SUPPORTS,外部抛异常
 *  结论：两个都回滚。
 *  SUPPORTS是，外部有事务，则加入该事务，外部无事务，则以非事务方式运行
 *  外部方法user.insert4 有Transactional注解，则开启了事务，属于外部有事务
 *  内部teacherService.insert4()是supports，会直接加入到外部事务，是同一个事务了。
 *  同一个事务，发生异常，回滚，所以俩都回滚了。
 */
@Transactional(propagation = Propagation.REQUIRED)
@Override
public void insert4(){

    teacherService.insert4();

    User user = new User(1,"user_"+System.currentTimeMillis());
    userMapper.insert(user);

    int i = 1/0; // 这里抛出异常，
}

============= teacherService.insert();方法如下： ==========

@Transactional(propagation = Propagation.SUPPORTS)
@Override
public int insert4() {
    Teacher teacher = new Teacher(1,"teacher_"+System.currentTimeMillis());
    int insert = teacherMapper.insert(teacher);

    return insert;
}

3.2、外部(调用方,A方法)无事务

测试：外部无事务，内部有事务且为supports类型。外部抛出异常
结论：两者都不会回滚，都提交了。

/**
 * @author: ztl
 * @date: 2022/12/29 17:08
 * @desc: 外部无事务，内部有事务且为supports类型。外部抛出异常
 *  结论：两者都不会回滚，都提交了。
 *  supports是，外部有事务，则加入该事务；外部无事务，则以非事务的方式运行。
 *  外部无事务(user的insert5方法没加Transactional)，则以非事务运行。
 *  teacherService.insert5以非事务，又是mysql数据库，mysql是自动提交，insert5方法没报错，则提交了
 *  user。insert也一样，insert方法没报错，则自动提交了。
 *  都提交完事务了才报错，跟他俩就没关系了，因为已经提交了，所以俩都不会回滚。
 */
@Override
public void insert5(){

    teacherService.insert5();

    User user = new User(1,"user_"+System.currentTimeMillis());
    userMapper.insert(user);

    int i = 1/0; // 这里抛出异常，
}

============= teacherService.insert();方法如下： ==========

@Transactional(propagation = Propagation.SUPPORTS)
@Override
public int insert5() {
    Teacher teacher = new Teacher(1,"teacher_"+System.currentTimeMillis());
    int insert = teacherMapper.insert(teacher);

    return insert;
}

4、@Transactional(propagation = Propagation.NOT_SUPPORTED

以非事务的方式运行，如果有事务，则将当前事务挂起。

4.1、外部(调用方,A方法)有事务

测试：外部有事务，内部有事务，内部事务NOT_SUPPORTED，外部抛异常
结论：外部(user)insert回滚，内部(teacher)insert提交。

/**
 * @author: ztl
 * @date: 2023/01/03 10:35
 * @desc: 外部有事务，内部有事务，内部事务NOT_SUPPORTED，外部抛异常
 *  结论：外部(user)insert回滚，内部(teacher)insert提交。
 *   NOT_SUPPORTED，不支持事务，如果有事务，则挂起该事务并以非事务运行。
 *   外部user。insert加了注解Transactional，开启了事务。
 *   内部teacher加了注解，并且是not_supported，
 *   内部挂起外部的事务，并以非事务方式运行，非事务，mysql数据库，自动提交了
 *   内部运行完毕，已经提交的前提下，恢复外部事务，外部事务遇到异常，外部事务回滚。
 */
@Transactional(propagation = Propagation.REQUIRED)
@Override
public void insert6(){

    teacherService.insert6();

    User user = new User(1,"user_"+System.currentTimeMillis());
    userMapper.insert(user);

    int i = 1/0; // 这里抛出异常，
}

============= teacherService.insert();方法如下： ==========

// 外部调用方有事务
@Transactional(propagation = Propagation.NOT_SUPPORTED)
@Override
public int insert6() {
    Teacher teacher = new Teacher(1,"teacher_"+System.currentTimeMillis());
    int insert = teacherMapper.insert(teacher);

    return insert;
}

4.2、外部(调用方,A方法)无事务

测试：外部无事务，内部有事务，内部not_supported，外部抛出异常
结论：两个都提交

/**
 * @author: ztl
 * @date: 2022/12/27 11:18
 * @desc: 外部无事务，内部有事务，内部not_supported，外部抛出异常
 *  结论：两个都提交。
 *  not_supported，以非事务运行，如果有事务则挂起，以非事务运行。
 *  外部无事务，内部not_supports，都是没事务，都自动提交，
 *  因为mysql是自动提交的，都已经提交完再抛出异常，所以俩都提交。
 */
@Override
public void insert7(){

    teacherService.insert7();

    User user = new User(1,"user_"+System.currentTimeMillis());
    userMapper.insert(user);

    int i = 1/0; // 这里抛出异常，
}


============= teacherService.insert();方法如下： ==========

// 外部调用方无事务
@Transactional(propagation = Propagation.NOT_SUPPORTED)
@Override
public int insert7() {
    Teacher teacher = new Teacher(1,"teacher_"+System.currentTimeMillis());
    int insert = teacherMapper.insert(teacher);

    return insert;
}

5、Transactional(propagation = Propagation.MANDATORY)

强制事务执行，如果当前存在事务，则加入该事务；如果当前不存在事务，则抛出异常

5.1、外部(调用方,A方法)有事务

测试：外部有事务，内部有事务，内部是MANDATORY,外部抛出异常
结论：内部、外部都回滚。(抛出的是外部的异常by zero)

/**
 * @author: ztl
 * @date: 2023/01/03 14:36
 * @desc: 外部有事务，内部有事务，内部是MANDATORY,外部抛出异常
 *  结论：内部、外部都回滚。(抛出的是外部的异常by zero)
 *  mandatory是，强制事务执行，如果有事务，加入该事务；如果没有事务，则抛出异常。
 *  内部事务是MANDATORY，如果外部有事务，则内部事务加入到外部事务；
 *      如果外部没事务，内部事务抛出异常。
 *  外部加了Transactional注解，开启了事务，内部的(teacher)事务会加入，
 *  加入了以后，是一个事务，同一个事务内，出现异常，回滚，两个都回滚。
 */
@Transactional(propagation = Propagation.REQUIRED)
@Override
public void insert8(){

    teacherService.insert8();

    User user = new User(1,"user_"+System.currentTimeMillis());
    userMapper.insert(user);

    int i = 1/0; // 这里抛出异常，
}

============= teacherService.insert();方法如下： ==========

// 外部调用方无事务、有事务
@Transactional(propagation = Propagation.MANDATORY)
@Override
public int insert8() {
    Teacher teacher = new Teacher(1,"teacher_"+System.currentTimeMillis());
    int insert = teacherMapper.insert(teacher);

    return insert;
}

5.2、外部(调用方，B方法)无事务

测试：外部无事务，内部有事务，mandatory，外部抛异常，
结论：外部、内部全部回滚(抛出的是内部的异常，no existing transaction for ‘mandatory’)

/**
 * @author: ztl
 * @date: 2023/01/03 11:18
 * @desc: 外部无事务，内部有事务，mandatory，外部抛异常，
 *  结论：外部、内部全部回滚(抛出的是内部的异常，no existing transaction for 'mandatory')
 *  mandatory是，强制事务执行，若当前存在事务，则加入该事务；若当前不存在事务，则抛出异常。
 *  外部有事务，则加入该事务，外部没事务，直接抛出异常。
 *  所以即使你 1/0 了，报错也不是 by zero，而是：
 *          org.springframework.transaction.IllegalTransactionStateException: No existing transaction found for transaction marked with propagation 'mandatory'
 *  由于teacher(内部)抛出了异常，所以内部回滚。内部抛出去了，异常到外部了，
 *  外部有异常，所以外部也回滚了。
 */
@Override
public void insert9(){

    teacherService.insert8();

    User user = new User(1,"user_"+System.currentTimeMillis());
    userMapper.insert(user);

    int i = 1/0; // 这里抛出异常，
}

============= teacherService.insert();方法如下： ==========

// 外部调用方无事务、有事务
@Transactional(propagation = Propagation.MANDATORY)
@Override
public int insert8() {
    Teacher teacher = new Teacher(1,"teacher_"+System.currentTimeMillis());
    int insert = teacherMapper.insert(teacher);

    return insert;
}

6、Transactional(propagation = Propagation.NEVER)

以非事务方式运行，如果不存在事务，以非事务方式运行。如果存在事务，则抛出异常。

6.1、外部(调用方,A方法)有事务

测试：外部有事务，内部有事务，内部为never，外部抛出异常
结论：内部、外部都回滚。不会提交。(异常是Existing transaction for ‘never’)

/**
 * @author: ztl
 * @date: 2023/01/03 15:08
 * @desc: 外部有事务，内部有事务，内部为never，外部抛出异常
 *  结论：内部、外部都回滚。不会提交。(异常是Existing transaction for 'never')
 *  never是，以非事务方式运行，如果当前不存在事务，以非事务运行；如果当前存在事务，则抛出异常。异常是：
 *          org.springframework.transaction.IllegalTransactionStateException: Existing transaction found for transaction marked with propagation 'never'
 *  外部加了transaction注解，外部有事务，内部是never，never如果存在事务，则抛出异常，内部抛出异常，内部回滚
 *  内部抛出的异常到外部了，外部遇到异常，直接不往下执行了，user的insert不会进行。
 */
@Transactional(propagation = Propagation.REQUIRED)
@Override
public void insert11(){

    teacherService.insert10();

    User user = new User(1,"user_"+System.currentTimeMillis());
    userMapper.insert(user);

    int i = 1/0; // 这里抛出异常，
}

============= teacherService.insert();方法如下： ==========

// 外部调用方无事务、有事务
@Transactional(propagation = Propagation.NEVER)
@Override
public int insert10() {
    Teacher teacher = new Teacher(1,"teacher_"+System.currentTimeMillis());
    int insert = teacherMapper.insert(teacher);

    return insert;
}

6.2、外部(调用方,A方法)无事务

测试：外部无事务，内部有事务，内部为never，外部抛出异常
结论：两个都不回滚，都提交。(异常是by zero)

/**
 * @author: ztl
 * @date: 2023/01/03 15:02
 * @desc: 外部无事务，内部有事务，内部为never，外部抛出异常
 *  结论：两个都不回滚，都提交。(异常是by zero)
 *  never是，以非事务方式运行，如果当前存在事务，则抛出异常，如果当前不存在事务，以非事务方式运行。
 *  外部没加transaction，所以外部无事务，内部为never，所以以非事务方式运行。
 *  非事务运行，内部(teacher)成功，直接提交。
 *  非事务运行，外部(user)因为是连接的mysql数据库，自动提交，所以也提交，提交完了才报错，不影响，所以不回滚。
 */
@Override
public void insert10(){

    teacherService.insert10();

    User user = new User(1,"user_"+System.currentTimeMillis());
    userMapper.insert(user);

    int i = 1/0; // 这里抛出异常，
}

============= teacherService.insert();方法如下： ==========

// 外部调用方无事务、有事务
@Transactional(propagation = Propagation.NEVER)
@Override
public int insert10() {
    Teacher teacher = new Teacher(1,"teacher_"+System.currentTimeMillis());
    int insert = teacherMapper.insert(teacher);

    return insert;
}

7、Transactional(propagation = Propagation.NESTED)

NESTED是说，如果当前存在事务，则嵌套在当前事务中执行；如果当前没有事务，则新建一个事务。

7.1、外部(调用方,A方法)抛异常

测试：外部有事务，内部有事务，内部NESTED，外部抛异常
结论：外部、内部、全部回滚(外部事务异常，会导致嵌套内事务同步回滚)。

/**
 * @author: ztl
 * @date: 2023/01/09 15:22
 * @desc: 外部有事务，内部有事务，内部NESTED，外部抛异常
 *  结论：外部、内部、全部回滚(外部事务异常，会导致嵌套内事务同步回滚)。
 *  NESTED是说，如果当前存在事务，则嵌套在当前事务中执行；如果当前没有事务，则新建一个事务
 *  外部加了Transaction，外部有事务，内部是nested，内部事务会嵌套在外部事务中。
 *  内部teacher成功，提交了，外部事务user失败了，会导致内部的teacher同步回滚。
 */
@Transactional(propagation = Propagation.REQUIRED)
@Override
public void insert12(){

    try {
        teacherService.insert12();
    }catch (Exception e){
        e.printStackTrace();
        System.out.printf("exception:"+e);
    }

    User user = new User(1,"user_"+System.currentTimeMillis());
    userMapper.insert(user);

    int i = 1/0; // 这里抛出异常，
}

============= teacherService.insert();方法如下： ==========

@Transactional(propagation = Propagation.NESTED)
@Override
public int insert12() {
    Teacher teacher = new Teacher(1,"teacher_"+System.currentTimeMillis());
    int insert = teacherMapper.insert(teacher);

    return insert;
}

7.2、内部(被调用方，B方法)抛异常

测试：外部有事务required，内部有事务nested，内部抛异常
结论：外部提交，内部回滚

/**
 * @author: ztl
 * @date: 2023/01/09 15:41
 * @desc: 外部有事务required，内部有事务nested，内部抛异常
 *  结论：外部提交，内部回滚
 *  NESTED是说，如果当前存在事务，则嵌套在当前事务中执行；如果当前没有事务，则新建一个事务
 *  说明外层的异常可以影响到内层的事务，内层的事务影响不到外部的事务。
 *  teacher异常，被回滚了，teacher抛到外层user这层的，被捕获了，没异常，提交
 */
@Transactional(propagation = Propagation.REQUIRED)
@Override
public void insert13(){

    try {
        teacherService.insert13();
    }catch (Exception e){
        e.printStackTrace();
        System.out.printf("exception:"+e);
        throw new RuntimeException("123");
    }

    User user = new User(1,"user_"+System.currentTimeMillis());
    userMapper.insert(user);
}

============= teacherService.insert();方法如下： ==========

// 外部调用方无事务、有事务
@Transactional(propagation = Propagation.NESTED)
@Override
public int insert13() {
    Teacher teacher = new Teacher(1,"teacher_"+System.currentTimeMillis());
    int insert = teacherMapper.insert(teacher);

    int i = 1/0; // 这里抛出异常，
    return insert;
}

7.3、内部(被调用方，B方法)、外部都不抛异常

测试：外部有事务required，内部有事务nested，内部外部都不抛异常
结论：内部、外部都提交

@Transactional(propagation = Propagation.REQUIRED)
@Override
public void insert14(){

    teacherService.insert14();

    User user = new User(1,"user_"+System.currentTimeMillis());
    userMapper.insert(user);

}

============= teacherService.insert();方法如下： ==========

@Transactional(propagation = Propagation.NESTED)
@Override
public int insert14() {
    Teacher teacher = new Teacher(1,"teacher_"+System.currentTimeMillis());
    int insert = teacherMapper.insert(teacher);

    return insert;
}

7.4、requires_new和nested区别测试demo

7.4.1、外部(调用方,A方法)抛异常

测试：外部有事务required，内部有事务，分别为nested、requires_new。外部抛异常
结论：当为nested时，外部异常，内部、外部都回滚。当为requires_new时，外部异常。外部回滚，内部提交。

/**
     * @author: ztl
     * @date: 2022/12/27 11:18
     * @desc: 测试nested和requires_new区别：
     *  外部有事务required，内部有事务，分别为nested、requires_new。外部抛异常，
     *  结论：当为nested时，外部异常，内部、外部都回滚。当为requires_new时，外部异常。外部回滚，内部提交
     */
    @Transactional(propagation = Propagation.REQUIRED)
    @Override
    public void insert17(){

        try {
//            teacherService.insert17(); // 外部required，内部nested，外部抛异常，内部、外部都回滚
            teacherService.insert18(); // 外部required，内部requires_new，外部抛异常，外部回滚，内部提交
        }catch (Exception e){
            e.printStackTrace();
            System.out.printf("exception:"+e);
        }

        User user = new User(1,"user_"+System.currentTimeMillis());
        userMapper.insert(user);
        int i = 1/0; // 这里抛出异常，
    }
    
============= teacherService.insert();方法如下： ==========
        
// 测试nested和requires_new的区别，外部抛异常
@Transactional(propagation = Propagation.NESTED)
@Override
public int insert17() {
    Teacher teacher = new Teacher(1,"teacher_"+System.currentTimeMillis());
    int insert = teacherMapper.insert(teacher);


    return insert;
}

// 测试nested和requires_new的区别，外部抛异常
@Transactional(propagation = Propagation.REQUIRES_NEW)
@Override
public int insert18() {
    Teacher teacher = new Teacher(1,"teacher_"+System.currentTimeMillis());
    int insert = teacherMapper.insert(teacher);

    return insert;
}
7.4.2、内部(被调用方，B方法)抛异常

测试：外部有事务required，内部有事务，内部事务分别为nested、requires_new。内部抛异常，外部catch住。
结论：内部都回滚，外部都提交。nested、requires_new在内部有异常外部无异常时，这俩一样

/**
     * @author: ztl
     * @date: 2023/01/16 16:26
     * @desc: 测试nested和requires_new区别：
     *  外部有事务required，内部有事务，分别为nested、requires_new。内部抛异常，外部catch住，
     *  结论：内部都回滚，外部都提交。nested、requires_new在内部有异常外部无异常时，这俩一样
     */
    @Transactional(propagation = Propagation.REQUIRED)
    @Override
    public void insert15(){

        try {
//            teacherService.insert15(); // 外部required，内部nested，内部抛异常，外部提交，内部回滚
            teacherService.insert16(); // 外部required，内部requires_new，内部抛异常，外部提交，内部回滚
        }catch (Exception e){
            e.printStackTrace();
            System.out.printf("exception:"+e);
        }

        User user = new User(1,"user_"+System.currentTimeMillis());
        userMapper.insert(user);
    }
    
    
    ============= teacherService.insert();方法如下： ==========
    
    
// 测试nested和requires_new的区别，内部抛异常
@Transactional(propagation = Propagation.NESTED)
@Override
public int insert15() {
    Teacher teacher = new Teacher(1,"teacher_"+System.currentTimeMillis());
    int insert = teacherMapper.insert(teacher);

    int i = 1/0; // 这里抛出异常，
    return insert;
}

// 测试nested和requires_new的区别，内部抛异常
@Transactional(propagation = Propagation.REQUIRES_NEW)
@Override
public int insert16() {
    Teacher teacher = new Teacher(1,"teacher_"+System.currentTimeMillis());
    int insert = teacherMapper.insert(teacher);

    int i = 1/0; // 这里抛出异常，
    return insert;
}

8、注：我上面A、B是在两个类中，同一个类中A、B方法不会回滚和提交！！！)

四、日常开发中常用的方式

1、无事务场景

测试：内部、外部都没事务，外部抛异常，
结论：内部外部都提交
由于连接的是mysql数据库，自动提交，是提交完以后才报的错，已经提交过了，所以不会回滚，会提交。

/**
 * @author: ztl
 * @date: 2023/01/16 16:46
 * @desc: 内部、外部都没事务，外部异常，内部外部都提交
 *  因为连接的是mysql数据库，会自动提交，都已经提交完了才报错，所以两个都不会回滚
 */
@Override
public void insert19(){

    teacherService.insert19();
    User user = new User(1,"user_"+System.currentTimeMillis());
    userMapper.insert(user);
    int i = 1/0; // 这里抛出异常，
}

============= teacherService.insert();方法如下： ==========

@Override
public int insert19() {
    Teacher teacher = new Teacher(1,"teacher_"+System.currentTimeMillis());
    int insert = teacherMapper.insert(teacher);

    return insert;
}

2、(最常用)外部@Transaction，内部无事务(无注解)

外部加了@Transaction注解，所以开启了事务，未指定propagation，即是默认required。外部加了注解，开启了事务，required，内部无事务。
不管是外部、内部，任何一个地方有异常，则内部、外部全部回滚。
测试：外部抛异常
结论：内部、外部都回滚
测试：内部抛异常
结论：内部、外部都回滚

/**
     * @author: ztl
     * @date: 2023/01/16 16:46
     * @desc: 外部有事务，required，内部无事务，
     *  外部抛异常：内部、外部都回滚。
     *  内部抛异常：
     */
    @Transactional
    @Override
    public void insert20(){

        teacherService.insert19(); // 外部异常，内部无事务，内部、外部都要回滚。
//        teacherService.insert20(); // 内部异常，内部无事务，内部、外部都要回滚
        User user = new User(1,"user_"+System.currentTimeMillis());
        userMapper.insert(user);
//        int i = 1/0; // 这里抛出异常，
    }
    
    @Override
public int insert19() {
    Teacher teacher = new Teacher(1,"teacher_"+System.currentTimeMillis());
    int insert = teacherMapper.insert(teacher);

    return insert;
}

@Override
public int insert20() {
    Teacher teacher = new Teacher(1,"teacher_"+System.currentTimeMillis());
    int insert = teacherMapper.insert(teacher);
    int i = 1/0; // 这里抛出异常，
    return insert;
}

五、Transaction常见面试题

1、spring的事务传播行为，同一个类中，a事务正常，b方法报错了，这个整体是回滚还是提交

在一个Service内部，事务方法之间的嵌套调用，普通方法和事务方法之间的嵌套调用，都不会开启新的事务.是因为spring采用动态代理机制来实现事务控制，而动态代理最终都是要调用原始对象的，而原始对象在去调用方法时，是不会再触发代理了！
如果spring的同一个类中，a方法有事务，b方法没有事务，那么a，b之间，事务没法传播，都不会自动的传播事务，需要自己手动提交或回滚。
不管循环嵌套了多少个事务，只要最上层的类有事务控制，那么不管是哪个方法调用异常，都会回滚(前提是不是同一个类)。
如果一个有事务的方法，去调用了没有事务的方法，会走事务；如果一个没有事务的方法，调用了带有事务的方法，是不会有事务的。
因为@Transational注解是，给当前类生成一个子类，然后在子类执行响应的业务逻辑前，先加上事务，如果执行结束，就提交或者回滚。而如果同一个类的话，事务方法是在当前类的子类(代理类)里面执行的，普通方法是在当前类中执行的，都不是一个类，肯定没法统一的事务处理。
要解决的话：可以在类上加@Transactional而不是在类的方法中加上，或者你在嵌套调用的时候，加一个try，catch，用来捕获，并做处理。
spring的默认事务规则(7种传播行为)是，如果当前存在事务，则加入该事务；如果当前不存在事务，则创建一个新事务。

2、spring的@Transactional注解啥时候下失效?

私有方法、同一个类中、@Transactional 注解，不支持静态方法

3、@transtational可以加在私有方法中吗

方法可见性和@Transactional在使用代理时，应用@Transactional只对具有公共可见性的方法进行注释。如果确实对受保护的、私有的或包可见的方法进行注释，则使用@Transactional注释，不会引发错误，但带注释的方法不会显示已配置的事务设置。如果需要注释非公共方法，请考虑使用AspectJ(见下文)。@Transactional修饰static方法时，会报错
原理： spring
在扫描bean的时候会扫描方法上是否包含@Transactional注解，如果包含，spring会为这个bean动态地生成一个子类（即代理类，proxy），代理类是继承原来那个bean的。此时，当这个有注解的方法被调用的时候，实际上是由代理类来调用的，代理类在调用之前就会启动transaction。然而，如果这个有注解的方法是被同一个类中的其他方法调用的，那么该方法的调用并没有通过代理类，而是直接通过原来的那个bean，所以就不会启动transaction，我们看到的现象就是@Transactional注解无效。

总结

到这里大家应该对spring中的传播行为有了一定的了解了。建议平时开发的时候多测测，这样即使线上环境真出问题了，也会同步失败，不会造成大量的脏数据，也不会有很严重的生产事故。以后有时间了，还会从源码的角度，分析为何@Transaction会起作用。以及何时不会起作用。

郑..方..醒
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
Spring事务传播Demo.zip
06-11
参考博客https://blog.csdn.net/qq_42192693/article/details/91359997，用到的模型
Spring事务传播特性实例解析
445822357
11-05 487
背景介绍 目前系统正在进行代码重构前期预研工作，目标采用spring控制事务以减少开发代码量，提高开发效率。同时避免开发人员编码控制事务所带来的链接没有释放，事务没有提交，出现异常事务没有回滚的Bug。 为保证系统能正确使用Spring控制事务，必须很好的理解其传播特性。在沟通中发现，好多人知道这个概念但是对于事务的实际传播行为往往模棱两可。 基于上述原因，本文采用Demo实例的方式对...
spring事务的配置以及事务传播机制和相关的测试demo
dianxiaoer20111的博客
05-12 396
在实际项目中为了保证数据的一致性,事务是非常重要的,而spring对事务的支持方便了我们对事务相关操作的开发. 事务的配置方式 spring支持编程式事务管理和声明式事务管理两种方式。 　　编程式事务管理使用TransactionTemplate或者直接使用底层的PlatformTransactionManager。对于编程式事务管理，spring推荐使用TransactionTemplate。 　　声明式事务管理建立在AOP之上的。其本质是对方法前后进行拦截，然后在目标方法开始之前创建或者..
Spring 事务管理之事务传播行为
luzhensmart的专栏
05-01 393
打印当前事务名的方式:后来发现只要是加了事务注解，它都会有返回值。其实有些传播行为如 System.out.println(TransactionSynchronizationManager.getCurrentTransactionName()); 实验准备 分别有UserService 和 CuserService 两个service，他们之内都有实现各自的insert方法。且...
【Spring事务详解】--- 1.事务传播的案例演示
自律使我自由
12-31 1567
事务的传播案例演示
spring 事务传播 demo
06-05
本示例“spring 事务传播 demo”将聚焦于Spring的事务传播行为，这是在多个方法调用中控制事务边界的关键概念。下面我们将详细讨论相关知识点。 首先，事务传播行为是指当一个被@Transactional注解的方法被另一个@...
spring 事务传播与隔离级别DEMO
05-03
本DEMO主要探讨的是Spring事务的传播行为和隔离级别，这些概念对于理解和优化数据库操作至关重要。让我们深入理解这些概念及其实际应用。 首先，我们来谈谈事务的传播行为。在Spring中，当一个方法被另一个具有事务...
Spring事务管理Demo
05-01
在Spring事务管理Demo中，通常会包含以下几个步骤： 1. 配置事务管理器：在Spring的XML配置文件中，根据数据库类型（如JDBC、Hibernate、MyBatis等）配置相应的事务管理器。 2. 开启事务：使用`@Transactional`注解...
Spring事务小demo
05-08
6. **测试与调试**：在"Spring事务小demo"项目中，可以编写JUnit测试类来验证事务的正确性。测试类中，使用@Test注解并配置@Test rollback属性，可以确保每次测试结束后，事务都会被回滚，保持数据库的原始状态。 ...
Spring事务的传播属性
大龙的博客
11-22 273
一、事务特性 事务具有四个特点（ACID），如下： 1）原子性：要不全部成功，要不全部撤销 2）隔离性：事务之间相互独立，互不干扰 3）一致性：数据库正确的改变状态后，数据库的一致性约束没有被破坏 4）持久性：事务的提交结果，将持久保存在数据库中 二、Spring事务传播源码 Spring事务的传播特性定义在 TransactionDefinition 类中，源码如下： pac...
Spring事务传播属性
cgm625637391的博客
03-07 177
参考文献 Spring事务传播属性和隔离级别 https://www.cnblogs.com/eunice-sun/p/11024584.html spring事务传播机制总结 https://blog.csdn.net/m18330808841/article/details/109543815 正文 扫盲示例 pom.xml <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apac
【Spring】Spring不同事务传播行为测试
sfh2018的博客
04-01 1602
Spring不同的事务传播行为测试结果
Spring 事务介绍（二）之 事务的传播机制
挂机的阿洋zzZ
02-19 550
Spring 事物介绍（二）之 事物的传播机制 Spring中对事物的支持 Spring 事物相关API： spring事物是在数据库事物的基础上进行封装扩展，其主要特性如下: 支持原有的数据事物的隔离级别 加入了事物传播的概念，提供多个事物的合并和隔离的功能 提供声明式事物，让业务代码与事物分离，事物更易用 spring提供了三个接口用来使用事物： TransactionDefiniti...
事务管理的简介及demo演示
weixin_48632843的博客
04-07 884
会话管理基本了解及demo演示
Spring事务管理及几种简单的实现
热门推荐
zhuxinquan的博客
05-01 1万+
事务是逻辑上的一组操作，这组操作要么全部成功，要么全部失败，最为典型的就是银行转账的案例：A要向B转账，现在A，B各自账户中有1000元，A要给B转200元，那么这个转账就必须保证是一个事务，防止中途因为各种原因导致A账户资金减少而B账户资金未添加，或者B账户资金添加而A账户资金未减少，这样不是用户有损失就是银行有损失，为了保证转账前后的一致性就必须保证转账操作是一个事务。事务具有的ACID特性，参
Spring的事务传播效果示例
绅士jiejie的博客
11-22 348
在业务中，为了保证数据的一致性，我们需要事务，不管是单体事务还是分布式事务。而在正常的开发流程中，我们控制单体的事务一般都会使用到@Transactional注解，不过很多朋友都是觉得直接加上这个注解，就能控制好事务了。但是其实Spring的事务控制也是分级别的，@Transactional这个注解里就有提供这么一个属性propagation来配合控制事务传播级别。 所以先看看属性propagation到底能够有哪几种值？ public enum Propagation { REQUIRED(0
Spring 事务传播行为-测试代码+源码分析
wuhulala的休息室
04-15 975
spring事务有如下七种类型 REQUIRED 默认，需要事务，没有则新建 REQUIRED_NEW 需要新事务，每次都新建 SUPPORTS 支持事务但不强制有事务 NOT_SUPPORTS 不支持事务，有事务挂起事务，执行完方法再唤醒 MONDATORY 强制事务，没有事务抛出异常 NEVER 当前方法不能有事务，否则抛出异常 NESTED 嵌套事务，无论是否有事务都会创建一个内部事务事...
事务的七种传播行为(以代码为例,做个笔记)
m0_37034934的博客
08-21 6785
PROPAGATION_REQUIRED:支持当前事务，如果不存在，则创建一个新事务。类似于同名的EJB事务属性。这是事务注释的默认设置。 PROPAGATION_SUPPORTS:支持当前事务，如果不存在则以非事务方式执行。同名EJB事务属性。 注意：对于具有事务同步的事务管理器，PROPAGATION_SUPPORTS与没有事务略有不同，因为它定义了同步将应用的事务范围。因此，对于...
Spring 事物传播行为（简单案例）
Dangerous
04-09 871
 最近想了解下Spring 中的事务的传播行为，百度了一下，发现网上的东西很多居然就是把Propagation中的每个注解上的注释翻译一半就拿出来写个文章 还有很多纯属瞎扯，懒得再慢慢找精华的文章，决定用 Spring Boot 创建的项目做测试，这个项目没有用AOP配置事物，而是采用注解,  为方便测试事务是注解在controller 层User 表 就二个字段 id, name 其中id 为主...
spring中事务的传播行为
最新发布
05-21
Spring 中提供了 7 种不同的事务传播行为： 1. REQUIRED：如果当前没有事务，就新建一个事务，如果已经存在一个事务中，加入到这个事务中。 2. SUPPORTS：支持当前事务，如果当前没有事务，就以非事务方式执行。 ...
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值