目录标题
事务的传播机制(7种)
说明 | 形象举例 | |
---|---|---|
REQUIRED | 当前方法必须运行在事务中。如果当前事务存在,则加入;不存在则创建事务。 | 如果老婆做饭了,你就吃老婆做的饭;如果老婆没有做饭,你就自己做饭吃,反正你就是要吃饭(反正要在事务中运行) |
REQUIRES_NEW | 创建一个新事务,如果事务存在则挂起,创建新的事务。 | 劳资非要吃自己做的饭,就算老婆把饭做好了,你也不吃老婆做的; |
SUPPORTS | 存在事务就支持,不存在事务就非事务执行。 | 如果老婆做饭了,你就吃老婆做的饭;如果老婆没有做饭,你就不吃(不一定非要在事务中运行) |
NOT_SUPPORTED | 总是非事务的执行,如果存在事务则将事务挂起 。 | 劳资就是不吃饭,就算老婆把饭做好了,我也不吃; |
MANDATORY | 当前方法必须在事务中运行,没有事务就报错。 | 非要吃老婆做的饭,老婆要是没有做饭,你就大发脾气,典型的家暴男; |
NEVER | 总是非事务的执行,如果存在事务就报错。 | 劳资就是不吃饭,如果老婆把饭做好了,我还要发脾气; |
NESTED | 嵌套事务,如果当前事务存在,则在嵌套事务中执行;如果不存在事务,则同REQUIRED 。 |
REQUIRED
如果存在一个事务,则支持当前事务。如果没有事务则开启一个新的事务。
可以把事务想像成一个胶囊,在这个场景下方法B用的是方法A产生的胶囊(事务)。
举个例子
@Transactional(propagation = Propagation.REQUIRED)
public void methodA() {
methodB();
// do something
}
@Transactional(propagation = Propagation.REQUIRED)
public void methodB() {
// do something
}
单独调用methodB方法时,因为当前上下文不存在事务,所以会开启一个新的事务。
调用methodA方法时,因为当前上下文不存在事务,所以会开启一个新的事务。当执行到methodB时,methodB发现当前上下文有事务,因此就加入到当前事务中来。
@Transactional
public void updateSchool(){
schoolMapper.updateByPrimaryKeySelective(school);
studentService.updateStudent();
System.out.println(1/0);
}
@Transactional
public void updateStudent(){
Student student = new Student();
student.setSid(1);
student.setAge(25);
studentMapper.updateByPrimaryKeySelective(student);
}
updateSchool回滚,updateStudent回滚。【两个方法共用同一个事务,两个方法一起提交或者回滚。】
public void updateSchool(){
schoolMapper.updateByPrimaryKeySelective(school);
studentService.updateStudent();
System.out.println(1/0);
}
@Transactional
public void updateStudent(){
Student student = new Student();
student.setSid(1);
student.setAge(25);
//更新sid为1的学生年龄为25
studentMapper.updateByPrimaryKeySelective(student);
}
updateSchool更新成功,updateStudent更新成功,因为÷0异常没有事务。
REQUIRES_NEW
它会开启一个新的事务。如果一个事务已经存在,则先将这个存在的事务挂起。
举个例子
@Transactional(propagation = Propagation.REQUIRED)
public void methodA() {
methodB();
// do something
}
@Transactional(propagation = Propagation.REQUIRES_NEW )
public void methodB() {
// do something
}
单独调用methodB方法时,因为当前上下文不存在事务,所以会开启一个新的事务。
调用methodA方法时,因为当前上下文不存在事务,所以会开启一个新的事务。当执行到methodB时,methodB发现当前上下文有事务,将事务A挂起,用自己的事务。
public void updateSchool(){
schoolMapper.updateByPrimaryKeySelective(school);
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更新成功,updateStudent回滚(÷0和更新学生信息在同一个事务中)。
@Transactional
public void updateSchool(){
schoolMapper.updateByPrimaryKeySelective(school);
studentService.updateStudent();
System.out.println(1/0);
}
@Transactional(propagation = Propagation.REQUIRES_NEW)
public void updateStudent(){
Student student = new Student();
student.setSid(1);
student.setAge(25);
studentMapper.updateByPrimaryKeySelective(student);
}
updateSchool回滚,updateStudent更新成功。
SUPPORTS
如果存在一个事务,支持当前事务。如果没有事务,则非事务的执行。
举个例子
@Transactional(propagation = Propagation.REQUIRED)
public void methodA() {
methodB();
// do something
}
// 事务属性为SUPPORTS
@Transactional(propagation = Propagation.SUPPORTS)
public void methodB() {
// do something
}
单纯的调用methodB时,methodB方法是非事务的执行的。当调用methdA时,methodB则加入了methodA的事务中,事务地执行。
@Transactional
public void updateSchool(){
schoolMapper.updateByPrimaryKeySelective(school);
studentService.updateStudent();
System.out.println(1/0);
}
@Transactional(propagation = Propagation.SUPPORTS)
public void updateStudent(){
Student student = new Student();
student.setSid(1);
student.setAge(25);
studentMapper.updateByPrimaryKeySelective(student);
}
updateSchool回滚,updateStudent回滚。
public void updateSchool(){
schoolMapper.updateByPrimaryKeySelective(school);
studentService.updateStudent();
System.out.println(1/0);
}
@Transactional(propagation = Propagation.SUPPORTS)
public void updateStudent(){
Student student = new Student();
student.setSid(1);
student.setAge(25);
studentMapper.updateByPrimaryKeySelective(student);
}
updateSchool更新成功,updateStudent更新成功。
NOT_SUPPORTED
PROPAGATION_NOT_SUPPORTED 总是非事务地执行,并挂起任何存在的事务。
举个例子
public void updateSchool(){
schoolMapper.updateByPrimaryKeySelective(school);
studentService.updateStudent();
}
@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更新成功,updateStudent更新成功。
@Transactional
public void updateSchool(){
schoolMapper.updateByPrimaryKeySelective(school);
studentService.updateStudent();
}
@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回滚,updateStudent更新成功。【无事务执行,如果当前存在事务,把当前事务挂起】
MANDATORY
如果已经存在一个事务,支持当前事务。如果没有一个活动的事务,则抛出异常。
举个例子
@Transactional(propagation = Propagation.REQUIRED)
public void methodA() {
methodB();
// do something
}
// 事务属性为MANDATORY
@Transactional(propagation = Propagation.MANDATORY)
public void methodB() {
// do something
}
当单独调用methodB时,因为当前没有一个活动的事务,则会抛出异常throw new IllegalTransactionStateException(“Transaction propagation ‘mandatory’ but no existing transaction found”);
当调用methodA时,methodB则加入到methodA的事务中,事务地执行。
@Transactional
public void updateSchool(){
schoolMapper.updateByPrimaryKeySelective(school);
studentService.updateStudent();
System.out.println(1/0);
}
@Transactional(propagation = Propagation.MANDATORY)
public void updateStudent(){
Student student = new Student();
student.setSid(1);
student.setAge(25);
studentMapper.updateByPrimaryKeySelective(student);
}
updateSchool回滚,updateStudent回滚。
public void updateSchool(){
schoolMapper.updateByPrimaryKeySelective(school);
studentService.updateStudent();
}
@Transactional(propagation = Propagation.MANDATORY)
public void updateStudent(){
Student student = new Student();
student.setSid(1);
student.setAge(25);
studentMapper.updateByPrimaryKeySelective(student);
}
updateSchool更新成功,updateStudent抛出异常。
NEVER
总是非事务地执行,如果存在一个活动事务,则抛出异常。
举个例子
public void updateSchool(){
schoolMapper.updateByPrimaryKeySelective(school);
studentService.updateStudent();
}
@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更新成功,updateStudent更新成功。
@Transactional
public void updateSchool(){
schoolMapper.updateByPrimaryKeySelective(school);
studentService.updateStudent();
}
@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回滚,updateStudent直接报错。
NESTED
举个例子
@Transactional(propagation = Propagation.REQUIRED)
methodA(){
doSomeThingA();
methodB();
doSomeThingB();
}
@Transactional(propagation = Propagation.NEWSTED)
methodB(){
……
}
如果单独调用methodB方法,则按REQUIRED属性执行。
通过methodA调用methodB的时候,methodA创建一个事务A,
如果methodB方法调用失败,则methodB回滚,后续代码正常执行。
如果methodB方法调用成功,doSomeThingB()异常,则methodA和methodB一起回滚。
嵌套事务一个非常重要的概念就是内层事务依赖于外层事务。外层事务失败时,会回滚内层事务所做的动作。而内层事务操作失败并不会引起外层事务的回滚。
PROPAGATION_NESTED 与PROPAGATION_REQUIRES_NEW的区别
PROPAGATION_REQUIRES_NEW:内层事务与外层事务就像两个独立的事务一样,一旦内层事务进行了提交后,外层事务不能对其进行回滚。两个事务互不影响。
PROPAGATION_NESTED :嵌套事务,外层事务的回滚可以引起内层事务的回滚。而内层事务的异常并不会导致外层事务的回滚。
【 外部事务提交, 嵌套事务提交,外部事务回滚,嵌套事务回滚;但是内部事务异常不会引起外部事务回滚。】
传播机制形象举例:https://blog.csdn.net/weixin_44771989/article/details/123967275
https://blog.csdn.net/soonfly/article/details/70305683