目录
事务的传播机制有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);
}
studentService.updateStudent()方法,加了事务的,默认REQUIRED:
@Transactional
public void updateStudent(){
Student student = new Student();
student.setSid(1);
student.setAge(25);
//更新sid为1的学生年龄为25
studentMapper.updateByPrimaryKeySelective(student);
}
如上所示: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();
}
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);
}
如上所示: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);
}
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);
}
如上所示: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();
}
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);
}
如上所示: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);
}
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);
}
**如上所示:**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();
}
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);
}
**如上所示:**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();
}
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);
}
**如上所示:**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);
}
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);
}
**如上所示:**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();
}
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);
}
**如上所示:**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();
}
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);
}
**如上所示:**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();
}
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);
}
**如上所示:**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();
}
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);
}
**如上所示:**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注解的原理和事务传播机制的原理可以看我上一篇文章:
先自我介绍一下,小编13年上师交大毕业,曾经在小公司待过,去过华为OPPO等大厂,18年进入阿里,直到现在。深知大多数初中级java工程师,想要升技能,往往是需要自己摸索成长或是报班学习,但对于培训机构动则近万元的学费,着实压力不小。自己不成体系的自学效率很低又漫长,而且容易碰到天花板技术停止不前。因此我收集了一份《java开发全套学习资料》送给大家,初衷也很简单,就是希望帮助到想自学又不知道该从何学起的朋友,同时减轻大家的负担。添加下方名片,即可获取全套学习资料哦