场景四:
主调用方 没有事务,副调用方 REQUIRES_NEW
//@Transactional(propagation = Propagation.REQUIRED)
@Override
public void testPropagationTrans() {
stuService.saveParent();
stuService.saveChildren();
副调用方:
public void saveParent() {
Stu stu = new Stu();
stu.setName("parent");
stu.setAge(19);
stuMapper.insert(stu);
}
@Transactional(propagation = Propagation.REQUIRES_NEW)
public void saveChildren() {
saveChild1();
int a = 1 / 0;
saveChild2();
}
只有parent插入了数据库。
主调用方加上
@Transactional(propagation = Propagation.REQUIRED)
两个都没有插入数据库。
结论:
REQUIRES_NEW: 如果当前有事务,则挂起该事务,并且自己创建一个新的事务给自己使用;
* 如果当前没有事务,则同 REQUIRED
* 举例:领导有饭吃,我偏不要,我自己买了自己吃
场景五:
@Transactional(propagation = Propagation.REQUIRED)
@Override
public void testPropagationTrans() {
stuService.saveParent();
stuService.saveChildren();
public void saveParent() {
Stu stu = new Stu();
stu.setName("parent");
stu.setAge(19);
stuMapper.insert(stu);
}
@Transactional(propagation = Propagation.NOT_SUPPORTED)
public void saveChildren() {
saveChild1();
int a = 1 / 0;
saveChild2();
}
child-1 插入了数据库,parent没有插入数据库。
结论:主要也是用于查询语句场景。
* NOT_SUPPORTED: 如果当前有事务,则把事务挂起,自己不适用事务去运行数据库操作
* 举例:领导有饭吃,分一点给你,我太忙了,放一边,我不吃
如果主调用方去掉
@Transactional(propagation = Propagation.REQUIRED)
两个都插入了数据库。
场景六:
主调用方有事务
@Transactional(propagation = Propagation.REQUIRED)
@Override
public void testPropagationTrans() {
stuService.saveParent();
stuService.saveChildren();
被调用方:
public void saveParent() {
Stu stu = new Stu();
stu.setName("parent");
stu.setAge(19);
stuMapper.insert(stu);
}
@Transactional(propagation = Propagation.NEVER)
public void saveChildren() {
saveChild1();
int a = 1 / 0;
saveChild2();
}
报错了。
Existing transaction found for transaction marked with propagation 'never'
主导用法去掉
@Transactional(propagation = Propagation.REQUIRED)
两个都插入了数据库。parent和children1 。类似not support
结论:
* NEVER: 如果当前有事务存在,则抛出异常
* 举例:领导有饭给你吃,我不想吃,我热爱工作,我抛出异常
场景七:
NESTED: 如果当前有事务,则开启子事务(嵌套事务),嵌套事务是独立提交或者回滚;
* 如果当前没有事务,则同 REQUIRED。
下面以有事务来讲解。
但是如果主事务提交,则会携带子事务一起提交。
* 如果主事务回滚,则子事务会一起回滚。相反,子事务异常,则父事务可以回滚或不回滚。
* 举例:领导决策不对,老板怪罪,领导带着小弟一同受罪。小弟出了差错,领导可以推卸责任。
@Transactional(propagation = Propagation.REQUIRED)
@Override
public void testPropagationTrans() {
stuService.saveParent();
stuService.saveChildren();
int a = 1 / 0;
public void saveParent() {
Stu stu = new Stu();
stu.setName("parent");
stu.setAge(19);
stuMapper.insert(stu);
}
@Transactional(propagation = Propagation.NESTED)
public void saveChildren() {
saveChild1();
// int a = 1 / 0;
saveChild2();
}
不会有数据。主事务发生异常,子事务跟着一起回滚。
注意:上面的 1/0 在主方法里面了,不是副方法里面。
如果把副调用方里面修改为
@Transactional(propagation = Propagation.REQUIRES_NEW)
public void saveParent() {
Stu stu = new Stu();
stu.setName("parent");
stu.setAge(19);
stuMapper.insert(stu);
}
@Transactional(propagation = Propagation.REQUIRES_NEW)
public void saveChildren() {
saveChild1();
// int a = 1 / 0;
saveChild2();
}
1267 child-1 11
1268 child-2 22
都插入了数据库。
------------------------------------------
另外场景:子事务异常,则父事务可以回滚或不回滚。用try cath
* 如果主事务回滚,则子事务会一起回滚。相反,子事务异常,则父事务可以回滚或不回滚。
* 举例:领导决策不对,老板怪罪,领导带着小弟一同受罪。小弟出了差错,领导可以推卸责任。
开放1/0
public void saveParent() {
Stu stu = new Stu();
stu.setName("parent");
stu.setAge(19);
stuMapper.insert(stu);
}
@Transactional(propagation = Propagation.NESTED)
public void saveChildren() {
saveChild1();
int a = 1 / 0;
saveChild2();
}
主调用方:
@Transactional(propagation = Propagation.REQUIRED)
@Override
public void testPropagationTrans() {
stuService.saveParent();
stuService.saveChildren();
int a = 1 / 0;
结果,两个都没有插入数据库。
如果主调用方用try cath
@Transactional(propagation = Propagation.REQUIRED)
@Override
public void testPropagationTrans() {
stuService.saveParent();
/* stuService.saveChildren();
int a = 1 / 0;*/
try {
// save point
stuService.saveChildren();
} catch (Exception e) {
e.printStackTrace();
}
只有1271 parent 19插入了数据库。