事务的传播机制

事务的传播机制
目录

1.形象说明：

2.代码演示：

2.1?REQUIRED

2.1.1? 验证共用一个事务

2.1.2? 验证当前没有事务，就新建一个事务

2.2?SUPPORTS

2.2.1 支持使用当前事务

2.2.2?如果当前事务不存在，则不使用事务

2.3?MANDATORY

2.3.1 支持使用当前事务

2.3.2?如果当前事务不存在，则抛出Exception

2.4?REQUIRES_NEW

2.4.1 当前事务不存在，创建一个新事务

2.4.2 新建一个事务，当前事务存在，把当前事务挂起

2.5?NOT_SUPPORTED

2.5.1 无事务执行

2.5.2?如果当前事务存在，把当前事务挂起。

2.6?NEVER

2.6.1 无事务执行

2.6.2?如果当前有事务则抛出Exception

2.7??NESTED

事务的传播机制有7种，如下图所示：

1.形象说明：

为了更好的理解，下面我们形象的说明一下几种传播机制是什么意思：

比如你下班回家，有以下几种场景

0.REQUIRED ------ 就是如果老婆做饭了，你就吃老婆做的饭；如果老婆没有做饭，你就自己做饭吃，反正你就是要吃饭（反正要在事务中运行）；

1.SUPPORTS ------ 如果老婆做饭了，你就吃老婆做的饭；如果老婆没有做饭，你就不吃（不一定非要在事务中运行）；

2.MANDATORY ------ 非要吃老婆做的饭，老婆要是没有做饭，你就大发脾气，典型的家暴男；

3.REQUIRES_NEW ------ 劳资非要吃自己做的饭，就算老婆把饭做好了，你也不吃老婆做的；

4.NOT_SUPPORTED ------ 劳资就是不吃饭，就算老婆把饭做好了，我也不吃；

5.NEVER ------ 劳资就是不吃饭，如果老婆把饭做好了，我还要发脾气；

6.NESTED ------ 暂不做解释，后面会详解；

本文主要是想用代码实现这几种传播机制的具体使用；

2.代码演示：

有两张表：

school表

student表

我们如何去测试两个方法是否使用的同一个事务呢？就看是否共用同一个数据库连接或者共用同一个会话；

2.1REQUIRED

支持使用当前事务，如果当前事务不存在，创建一个新事务。

2.1.1 验证共用一个事务

schoolService.updateSchool()方法：
```
@Transactional
    public void updateSchool(){
        School school = new School();
        school.setId(1);
        school.setName("湖南大学");
        school.setLocation("湖南");
        //更新id为1的学校名称为湖南大学，地址为湖南
        schoolMapper.updateByPrimaryKeySelective(school);
        
        //调用另一个方法更新学生信息
        studentService.updateStudent();
        System.out.println(1/0);
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
```
studentService.updateStudent()方法，加了事务的，默认REQUIRED：
```
@Transactional
    public void updateStudent(){
        Student student = new Student();
        student.setSid(1);
        student.setAge(25);
        //更新sid为1的学生年龄为25
        studentMapper.updateByPrimaryKeySelective(student);
    }
1
2
3
4
5
6
7
8
```
如上所示：updateSchool方法是加了事务的，调用完studentService.updateStudent方法后，会报错，如果updateSchool和updateStudent共用同一个事务，updateSchool报错，自身回滚，肯定会带着updateStudent一起回滚；如果不是共用同一个事务，那么updateStudent会执行成功并提交，不会回滚；

结果：

updateSchool成功回滚了

updateStudent也成功回滚了

看过我写的深入理解@Transactional注解的使用和原理就知道，两个方法会共用同一个数据库连接，也就共用同一个事务，两个方法一起提交或者回滚；

2.1.2 验证当前没有事务，就新建一个事务

schoolService.updateSchool()方法：
```
  public void updateSchool(){
        School school = new School();
        school.setId(1);
        school.setName("湖南大学");
        school.setLocation("湖南");
        //更新id为1的学校名称为湖南大学，地址为湖南
        schoolMapper.updateByPrimaryKeySelective(school);
        
        //调用另一个方法更新学生信息
        studentService.updateStudent();
       
    }
1
2
3
4
5
6
7
8
9
10
11
12
```
studentService.updateStudent()方法：
```
@Transactional
    public void updateStudent(){
        Student student = new Student();
        student.setSid(1);
        student.setAge(25);
        //更新sid为1的学生年龄为25
        studentMapper.updateByPrimaryKeySelective(student);
        //报错
        System.out.println(1/0);
    }
1
2
3
4
5
6
7
8
9
10
```
如上所示：updateSchool方法是没有加事务的，调用studentService.updateStudent方法，updateStudent方法加了事务，并且会报错，如果updateStudent没有新建事务的话，不会回滚，如果是建了事务，就会回滚；

结果：

1.控制台提示报错

2. updateSchool方法没有回滚（将北京大学刚改为湖南大学）

3.updateStudent方法回滚了（将age更新为25）

验证通过；

2.2SUPPORTS

支持使用当前事务，如果当前事务不存在，则不使用事务。

2.2.1 支持使用当前事务

updateSchool方法，加事务，更新id为1的name为“湖南大学”，location为“湖南”，输出1/0，肯定会报错的；
```
    @Transactional
    public void updateSchool(){
        School school = new School();
        school.setId(1);
        school.setName("湖南大学");
        school.setLocation("湖南");
        schoolMapper.updateByPrimaryKeySelective(school);
        studentService.updateStudent();
        System.out.println(1/0);
    }
1
2
3
4
5
6
7
8
9
10
```
updateStudent方法更新id为1的age为25；
```
    @Transactional(propagation = Propagation.SUPPORTS)
    public void updateStudent(){
        Student student = new Student();
        student.setSid(1);
        student.setAge(25);
        studentMapper.updateByPrimaryKeySelective(student);
    }
1
2
3
4
5
6
7
```
如上所示：updateSchool方法是加了事务的，studentService.updateStudent方法也加了事务，而且传播机制是SUPPORTS，如果updateSchool和updateStudent共用同一个事务，updateSchool报错，自身回滚，肯定会带着updateStudent一起回滚；如果不是共用同一个事务，那么updateStudent会执行成功并提交，不会回滚；

结果：

1.控制台提示报错

2.updateSchool方法回滚（将北京大学刚改为湖南大学）

3.updateStudent方法回滚（将age改为25）

显然，updateSchool和updateSchool共用同一个事务，正好验证了传播机制为supports，如果当前有事务，就支持使用当前事务；

2.2.2如果当前事务不存在，则不使用事务

updateSchool方法更新id为1的name为“湖南大学”，location为“湖南”，将@Transactional注释掉了，没有加事务
```
    //@Transactional
    public void updateSchool(){
        School school = new School();
        school.setId(1);
        school.setName("湖南大学");
        school.setLocation("湖南");
        schoolMapper.updateByPrimaryKeySelective(school);
        studentService.updateStudent();
    }
1
2
3
4
5
6
7
8
9
```
updateStudent方法更新id为1的age为25，事务传播机制为SUPPORTS，打印1/0，将报错
```
    @Transactional(propagation = Propagation.SUPPORTS)
    public void updateStudent(){
        Student student = new Student();
        student.setSid(1);
        student.setAge(25);
        studentMapper.updateByPrimaryKeySelective(student);
        System.out.println(1/0);
    }
1
2
3
4
5
6
7
8
```
如上所示：updateSchool方法没有加事务，studentService.updateStudent方法加了事务，而且传播机制是SUPPORTS，如果updateStudent没有事务，报错就不会回滚，如果有事务，就会回滚；

结果：

1.控制台报错

2.updateSchool方法没有回滚，无事务执行（无事务这个说法其实不准确，任何操作数据库肯定是有事务的）；

3.updateStudent方法也没有回滚，也是无事务执行的；

显然： 事务传播机制为SUPPORTS的方法，支持使用当前事务，如果当前事务不存在，则不使用事务。

2.3MANDATORY

中文翻译为强制，支持使用当前事务，如果当前事务不存在，则抛出Exception。

2.3.1 支持使用当前事务

updateSchool方法更新id为1的name为“湖南大学”，location为“湖南”，打印1/0，会报错；
```
    @Transactional
    public void updateSchool(){
        School school = new School();
        school.setId(1);
        school.setName("湖南大学");
        school.setLocation("湖南");
        schoolMapper.updateByPrimaryKeySelective(school);
        studentService.updateStudent();
        System.out.println(1/0);
    }
1
2
3
4
5
6
7
8
9
10
```
updateStudent方法更新id为1的age为25，事务传播机制为MANDATORY
```
    @Transactional(propagation = Propagation.MANDATORY)
    public void updateStudent(){
        Student student = new Student();
        student.setSid(1);
        student.setAge(25);
        studentMapper.updateByPrimaryKeySelective(student);
    }
1
2
3
4
5
6
7
```
**如上所示：**updateSchool方法加事务，studentService.updateStudent方法加了事务，而且传播机制是MANDATORY，如果两者共用一个事务，都会回滚；

结果：

1.控制台报错

2.updateSchool方法回滚（将北京大学刚改为湖南大学）

3.updateStudent方法回滚（将age改为25）

显然： 传播机制为MANDATORY，如果当前有事务，就使用当前事务；

2.3.2如果当前事务不存在，则抛出Exception

updateSchool方法更新id为1的name为“湖南大学”，location为“湖南”，没有事务；
```
    //@Transactional
    public void updateSchool(){
        School school = new School();
        school.setId(1);
        school.setName("湖南大学");
        school.setLocation("湖南");
        schoolMapper.updateByPrimaryKeySelective(school);
        studentService.updateStudent();
    }
1
2
3
4
5
6
7
8
9
```
updateStudent方法更新id为1的age为25，事务传播机制为MANDATORY；
```
    @Transactional(propagation = Propagation.MANDATORY)
    public void updateStudent(){
        Student student = new Student();
        student.setSid(1);
        student.setAge(25);
        studentMapper.updateByPrimaryKeySelective(student);
    }
1
2
3
4
5
6
7
```
**如上所示：**updateSchool方法没有加事务，studentService.updateStudent方法加了事务，而且传播机制是MANDATORY，就看执行到updateStudent就不会报错；

结果：

1.控制台报错

org.springframework.transaction.IllegalTransactionStateException: No existing transaction found for transaction marked with propagation ‘mandatory’

2.updateSchool方法没有回滚（将北京大学刚改为湖南大学）

3.pdateStudent方法直接报错： No existing transaction found for transaction marked with propagation ‘mandatory’，传播机制为mandatory的，必须有当前事务存在，不存在就报错；

**综上：**传播机制为MANDATORY，支持使用当前事务，如果当前事务不存在，则抛出Exception。

2.4REQUIRES_NEW

新建一个新事务；如果当前事务存在，把当前事务挂起。

2.4.1 当前事务不存在，创建一个新事务

updateSchool方法更新id为1的name为“湖南大学”，location为“湖南”，没有事务；
```
    //@Transactional
    public void updateSchool(){
        School school = new School();
        school.setId(1);
        school.setName("湖南大学");
        school.setLocation("湖南");
        schoolMapper.updateByPrimaryKeySelective(school);
        studentService.updateStudent();
    }
1
2
3
4
5
6
7
8
9
```
updateStudent方法更新id为1的age为25，事务传播机制为REQUIRES_NEW，打印1/0，报错；
```
    @Transactional(propagation = Propagation.MANDATORY)
    public void updateStudent(){
        Student student = new Student();
        student.setSid(1);
        student.setAge(25);
        studentMapper.updateByPrimaryKeySelective(student);
        System.out.println(1/0);
    }
1
2
3
4
5
6
7
8
```
**如上所示：**updateSchool方法没有加事务，studentService.updateStudent方法加了事务，而且传播机制是REQUIRES_NEW，如果updateStudent方法新建了事务，打印1/0，报错就会回滚，如果没有新建事务，updateStudent方法就不会回滚；

结果：

1.控制台报错

2.updateSchool方法没有回滚，无事务执行（无事务这个说法其实不准确，任何操作数据库肯定是有事务的）；

3.updateStudent方法回滚（将age改为25）

**显然：**传播机制为REQUIRES_NEW的，当前没有事务，就新建一个事务，在事务中运行；

2.4.2 新建一个事务，当前事务存在，把当前事务挂起

updateSchool方法更新id为1的name为“湖南大学”，location为“湖南”，有事务,打印1/0，报错；
```
    @Transactional
    public void updateSchool(){
        School school = new School();
        school.setId(1);
        school.setName("湖南大学");
        school.setLocation("湖南");
        schoolMapper.updateByPrimaryKeySelective(school);
        studentService.updateStudent();
        System.out.println(1/0);
    }
1
2
3
4
5
6
7
8
9
10
```
updateStudent方法更新id为1的age为25，事务传播机制为REQUIRES_NEW；
```
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void updateStudent(){
        Student student = new Student();
        student.setSid(1);
        student.setAge(25);
        studentMapper.updateByPrimaryKeySelective(student);
    }
1
2
3
4
5
6
7
```
**如上所示：**updateSchool方法有加事务，studentService.updateStudent方法加了事务，而且传播机制是REQUIRES_NEW，如果updateStudent方法新建了另一个事务，updateSchool报错，updateStudent不会回滚，如果不是新建一个事务而是共用一个事务，就会一起回滚；

结果：

1.控制台报错

2.updateSchool方法回滚（将北京大学刚改为湖南大学）

3.updateStudent没有回滚（将age改为25）

**显然：**updateStudent新建了另外一个事务，和updateSchool并不是共用一个事务；

**总结：**传播机制是REQUIRES_NEW，新建一个新事务；如果当前事务存在，把当前事务挂起。

使用场景：被调用方法，不想因为调用方出错而回滚，可以使用REQUIRES_NEW；

2.5NOT_SUPPORTED

无事务执行，如果当前事务存在，把当前事务挂起。

2.5.1 无事务执行

updateSchool方法更新id为1的name为“湖南大学”，location为“湖南”，没有事务,打印1/0，报错；
```
    //@Transactional
    public void updateSchool(){
        School school = new School();
        school.setId(1);
        school.setName("湖南大学");
        school.setLocation("湖南");
        schoolMapper.updateByPrimaryKeySelective(school);
        studentService.updateStudent();
    }
1
2
3
4
5
6
7
8
9
```
updateStudent方法更新id为1的age为25，事务传播机制为NOT_SUPPORTED；
```
    @Transactional(propagation = Propagation.NOT_SUPPORTED)
    public void updateStudent(){
        Student student = new Student();
        student.setSid(1);
        student.setAge(25);
        studentMapper.updateByPrimaryKeySelective(student);
        System.out.println(1/0);
    }
1
2
3
4
5
6
7
8
```
**如上所示：**updateSchool方法没有事务，studentService.updateStudent方法加了事务，而且传播机制是NOT_SUPPORTED，如果updateStudent没有事务，那么在执行打印1/0报错后，也就不会回滚；

结果：

1.控制台报错

2.updateSchool方法不回滚（将北京大学刚改为湖南大学）

3.updateStudent没有回滚（将age改为25）

**显然：**两个方法都没有在事务中运行，都没有回滚，所以，如果当前没有事务，NOT_SUPPORTED并不会新建一个事务，也是无事务执行；

2.5.2如果当前事务存在，把当前事务挂起。

updateSchool方法更新id为1的name为“湖南大学”，location为“湖南”，有事务；
```
    @Transactional
    public void updateSchool(){
        School school = new School();
        school.setId(1);
        school.setName("湖南大学");
        school.setLocation("湖南");
        schoolMapper.updateByPrimaryKeySelective(school);
        studentService.updateStudent();
    }
1
2
3
4
5
6
7
8
9
```
updateStudent方法更新id为1的age为25，事务传播机制为NOT_SUPPORTED，打印1/0，报错；
```
    @Transactional(propagation = Propagation.NOT_SUPPORTED)
    public void updateStudent(){
        Student student = new Student();
        student.setSid(1);
        student.setAge(25);
        studentMapper.updateByPrimaryKeySelective(student);
        System.out.println(1/0);
    }
1
2
3
4
5
6
7
8
```
**如上所示：**updateSchool方法有事务，studentService.updateStudent方法加了事务，而且传播机制是NOT_SUPPORTED，如果updateStudent没有事务，那么在执行打印1/0报错后，也就不会回滚，而updateSchool检测到报错，如果当前事务有效，updateSchool就会回滚；

结果：

1.控制台报错

2.updateSchool方法回滚（将北京大学刚改为湖南大学）

3.updateStudent没有回滚（将age改为25）

**显然：**当前有事务的情况下，传播机制为NOT_SUPPORTED的方法无事务运行；

**总结：**事务传播机制为NOT_SUPPORTED，无事务执行，如果当前存在事务，把当前事务挂起；

**使用场景：**被调用方法想无事务运行，但又不影响调用方的事务，可以用NOT_SUPPORTED；

2.6NEVER

无事务执行，如果当前有事务则抛出Exception。

这个和MANDATORY就是两个完全相反的极端，一个强制不要事务，一个强制要事务，不满足都会报错；

2.6.1 无事务执行

updateSchool方法更新id为1的name为“湖南大学”，location为“湖南”，没有事务；
```
    //@Transactional
    public void updateSchool(){
        School school = new School();
        school.setId(1);
        school.setName("湖南大学");
        school.setLocation("湖南");
        schoolMapper.updateByPrimaryKeySelective(school);
        studentService.updateStudent();
    }
1
2
3
4
5
6
7
8
9
```
updateStudent方法更新id为1的age为25，事务传播机制为NEVER，打印1/0，报错；
```
    @Transactional(propagation = Propagation.NEVER)
    public void updateStudent(){
        Student student = new Student();
        student.setSid(1);
        student.setAge(25);
        studentMapper.updateByPrimaryKeySelective(student);
        System.out.println(1/0);
    }
1
2
3
4
5
6
7
8
```
**如上所示：**updateSchool方法没有事务，studentService.updateStudent方法加了事务，而且传播机制是NEVER，打印1/0，会报错，如果updateStudent是无事务执行，那么就不会回滚

结果：

1.控制台报错

2.updateSchool方法不回滚（将北京大学刚改为湖南大学）

3.updateStudent没有回滚（将age改为25）

**显然：**updateSchool和updateStudent都没有回滚，都是无事务执行，所以，传播机制为NEVER，如果当前没有事务，则无事务执行；

2.6.2如果当前有事务则抛出Exception

updateSchool方法更新id为1的name为“湖南大学”，location为“湖南”，有事务；
```
    @Transactional
    public void updateSchool(){
        School school = new School();
        school.setId(1);
        school.setName("湖南大学");
        school.setLocation("湖南");
        schoolMapper.updateByPrimaryKeySelective(school);
        studentService.updateStudent();
    }
1
2
3
4
5
6
7
8
9
```
updateStudent方法更新id为1的age为25，事务传播机制为NEVER；
```
    @Transactional(propagation = Propagation.NEVER)
    public void updateStudent(){
        Student student = new Student();
        student.setSid(1);
        student.setAge(25);
        studentMapper.updateByPrimaryKeySelective(student);
    }
1
2
3
4
5
6
7
```
**如上所示：**updateSchool方法有事务，studentService.updateStudent方法加了事务，而且传播机制是NEVER，当前有事务，就看执行updateStudent方法时到底报不报错；

结果：

1.控制台报错

2.updateSchool方法回滚（将北京大学刚改为湖南大学）

3.updateStudent直接报错

org.springframework.transaction.IllegalTransactionStateException: Existing transaction found for transaction marked with propagation ‘never’

**显然：**传播机制为NEVER，如果当前有事务，则报错；

总结：这种传播机制感觉没啥用途，哈哈，反正我是基本没用过；

2.7NESTED

嵌套事务，如果当前事务存在，那么在嵌套的事务中执行。如果当前事务不存在，则表现跟REQUIRED一样。

这个直接说，如果父事务回滚，子事务也会跟着回滚；如果子事务回滚，并抛出异常，父事务肯定会跟着回滚；

如果当前没有事务，就和REQUIRED,新建一个事务运行；

关于@Transactional注解的原理和事务传播机制的原理可以看我上一篇文章：

深入理解@Transactional注解的使用和原理

先自我介绍一下，小编13年上师交大毕业，曾经在小公司待过，去过华为OPPO等大厂，18年进入阿里，直到现在。深知大多数初中级java工程师，想要升技能，往往是需要自己摸索成长或是报班学习，但对于培训机构动则近万元的学费，着实压力不小。自己不成体系的自学效率很低又漫长，而且容易碰到天花板技术停止不前。因此我收集了一份《java开发全套学习资料》送给大家，初衷也很简单，就是希望帮助到想自学又不知道该从何学起的朋友，同时减轻大家的负担。添加下方名片，即可获取全套学习资料哦
相关阅读:
我服了！SpringBoot升级后这服务我一个星期都没跑起来！（下）
多线程并发、线程池、同步方法、同步代码块（锁）
Java注解学习与实战
 DP4054H完全兼容替代TP4054 36V 耐压 500mA 线性锂电充电芯片
 使用Python查询国内 COVID-19 疫情
 【Vue】computed方法生成计算属性
 List集合Stream流转PageInfo或Page分页
 近来的一些小感悟
 关于Oracle数据库审计、诊断文件及跟踪文件操作
 猿创征文|【Maven】分模块开发、依赖管理、聚合、继承、属性
原文地址：https://blog.csdn.net/m0_67401270/article/details/126065811

1.形象说明：

2.代码演示：

2.1REQUIRED

2.1.1 验证共用一个事务

2.1.2 验证当前没有事务，就新建一个事务

2.2SUPPORTS

2.2.1 支持使用当前事务

2.2.2如果当前事务不存在，则不使用事务

2.3MANDATORY

2.3.1 支持使用当前事务

2.3.2如果当前事务不存在，则抛出Exception

2.4REQUIRES_NEW

2.4.1 当前事务不存在，创建一个新事务

2.4.2 新建一个事务，当前事务存在，把当前事务挂起

2.5NOT_SUPPORTED

2.5.1 无事务执行

2.5.2如果当前事务存在，把当前事务挂起。

2.6NEVER

2.6.1 无事务执行

2.6.2如果当前有事务则抛出Exception

2.7NESTED