1.事务传播特性
目录
3.REQUIRED,REQUIRES_NEW,NESTED异同
2.实测
教员说过，实践是检验真理的唯一标准。
2.1 建表
mysql数据库
CREATE TABLE `student` (
`id` int(10) unsigned NOT NULL AUTO_INCREMENT,
`name` varchar(45) NOT NULL DEFAULT '',
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;
CREATE TABLE `teacher` (
`id` int(10) unsigned NOT NULL AUTO_INCREMENT,
`name` varchar(45) NOT NULL DEFAULT '',
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;2.2 创建 项目
TestService 调用 StudentService 和 TeacherService 中的代码。 验证事务的传播特性。
在单元测试中，调用 TestService 中的方法。
关键代码：
package com.dawei.transaction.service;
import com.dawei.transaction.mapper.StudentDao;
import com.dawei.transaction.pojo.Student;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
/**
* @author da wei
* @description
* @create 2021/7/15 11:07
*/
@Service
public class StudentServiceImpl implements StudentService {
@Autowired
StudentDao studentDao;
@Override
@Transactional(propagation = Propagation.REQUIRED)
public void addRequired(Student student) {
studentDao.insert(student);
}
@Override
@Transactional(propagation = Propagation.REQUIRES_NEW)
public void addRequiresNew(Student student) {
studentDao.insert(student);
}
@Override
@Transactional(propagation = Propagation.NESTED)
public void addNested(Student student) {
studentDao.insert(student);
}
}package com.dawei.transaction.service;
import com.dawei.transaction.mapper.TeacherDao;
import com.dawei.transaction.pojo.Teacher;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
/**
* @author da wei
*/
@Service
public class TeacherServiceImpl implements TeacherService {
@Autowired
TeacherDao teacherDao;
/**
* 虽然 @Transactional 注解可以作用于接口、接口方法、类以及类方法上，
* 但是 Spring 建议不要在接口或者接口方法上使用该注解，因为这只有在使用基于接口的代理时它才会生效。
* 代理模式有JDK代理 和 cglib代理
*/
@Override
@Transactional(propagation = Propagation.REQUIRED)
public void addRequired(Teacher teacher) {
teacherDao.insert(teacher);
}
@Override
@Transactional(propagation = Propagation.REQUIRED)
public void addRequiredException(Teacher teacher) {
teacherDao.insert(teacher);
//此处会抛出一个运行时异常
int i = 1 / 0;
}
@Override
@Transactional(propagation = Propagation.REQUIRES_NEW)
public void addRequiresNew(Teacher teacher) {
teacherDao.insert(teacher);
}
@Override
@Transactional(propagation = Propagation.REQUIRES_NEW)
public void addRequiresNewException(Teacher teacher) {
teacherDao.insert(teacher);
//此处会抛出一个运行时异常
int i = 1 / 0;
}
@Override
@Transactional(propagation = Propagation.NESTED)
public void addNested(Teacher teacher) {
teacherDao.insert(teacher);
}
@Override
@Transactional(propagation = Propagation.NESTED)
public void addNestedException(Teacher teacher) {
teacherDao.insert(teacher);
int i = 1 / 0;
}
}2.3测试结论
请查看注释。
package com.dawei.transaction.test;
import com.dawei.transaction.pojo.Student;
import com.dawei.transaction.pojo.Teacher;
import com.dawei.transaction.service.StudentService;
import com.dawei.transaction.service.TeacherService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
/**
* @author da wei
*/
@Service
public class TestServiceImpl implements TestService {
@Autowired
StudentService studentService;
@Autowired
TeacherService teacherService;
/*-----------------------------1. 测试 propagation = Propagation.REQUIRED---------------------------------------------------------------------------------*/
/**
* 1.1 外围没有开启事务
*/
//1.1.1 在单元测试中调用该方法。 测试结果： 外部未开启事务，两个添加方法在自己的事务中独立
//运行。外部的异常不影响内部两个方法的插入。
@Override
public void noTransactionExceptionRequiredRequired() {
Student student = new Student();
student.setName("学生1.1.1");
studentService.addRequired(student);
Teacher teacher = new Teacher();
teacher.setName("教师1.1.1");
teacherService.addRequired(teacher);
int i = 1 / 0;
}
//1.1.2 在单元测试中调用该方法。 测试结果：学生2 成功插入到数据库。 外围方法没有事务，两个
//插入的方法独自创建自己的事务，教师添加遇到异常 导致 回滚，学生添加成功。
@Override
public void noTransactionRequiredRequiredException() {
Student student = new Student();
student.setName("学生1.1.2");
studentService.addRequired(student);
Teacher teacher = new Teacher();
teacher.setName("教师1.1.2");
teacherService.addRequiredException(teacher);
}
//结论：通过上面两个方法我们证明了在外围方法未开启事务的情况下Propagation.REQUIRED修饰的内
//部方法会新开启自己的事务，且开启的事务相互独立，互不干扰。
/**
* 1.2 外围方法开启事务，这个是使用率比较高的场景。
*/
//1.2.1 在单元测试中调用该方法。 测试结果： 学生和教师均保存失败。 外围方法开启事务，内部方
//法加入外围方法事务，外围方法回滚，内部方法也要回滚。
@Override
@Transactional(propagation = Propagation.REQUIRED)
public void transactionExceptionRequiredRequired() {
Student student = new Student();
student.setName("学生1.2.1");
studentService.addRequired(student);
Teacher teacher = new Teacher();
teacher.setName("教师1.2.1");
teacherService.addRequired(teacher);
int i = 1 / 0;
}
//1.2.2 测试结果：全部插入失败。 外围方法开启事务，内部方法加入外围方法事务，内部方法抛出异
//常回滚，外围方法感知异常致使整体事务回滚。
@Override
@Transactional(propagation = Propagation.REQUIRED)
public void transactionRequiredRequiredException() {
Student student = new Student();
student.setName("学生1.2.2");
studentService.addRequired(student);
Teacher teacher = new Teacher();
teacher.setName("教师1.2.2");
teacherService.addRequiredException(teacher);
}
//1.2.3 全部保存失败。 外围方法开启事务，内部方法加入外围方法事务，内部方法抛出异常回滚，即
//使方法被catch不被外围方法感知，整个事务依然回滚。
//这里我特地测试了1.2.1中的方法，捕获 1/0 异常， 发现两个均能插入成功。 与上面对比，即 捕获
//普通方法 是不会使事务中止的。
@Override
@Transactional(propagation = Propagation.REQUIRED)
public void transactionRequiredRequiredExceptionTry() {
Student student = new Student();
student.setName("学生1.2.3");
studentService.addRequired(student);
Teacher teacher = new Teacher();
teacher.setName("教师1.2.3");
try {
teacherService.addRequiredException(teacher);
} catch (Exception e) {
System.out.println("出现异常");
}
}
//结论：以上试验结果我们证明在外围方法开启事务的情况下Propagation.REQUIRED修饰的内部方法会
//加入到外围方法的事务中，所有Propagation.REQUIRED修饰的内部方法和外围方法均属于同一事务，只要
//一个方法回滚，整个事务均回滚。
/*-----------------------------2. 测试 propagation = Propagation.REQUIRES_NEW--------------------------------------------------------------------------------*/
/**
* 2.1 外围方法没有开启事务。
*/
//2.1.1 测试结果 都保存成功。 外围方法没有事务，插入学生、教师方法都在自己的事务中独立运行,
//外围方法抛出异常回滚不会影响内部方法。
@Override
public void noTransactionExceptionRequiresNewRequiresNew() {
Student student = new Student();
student.setName("学生2.1.1");
studentService.addRequiresNew(student);
Teacher teacher = new Teacher();
teacher.setName("教师2.1.1");
teacherService.addRequiresNew(teacher);
int i = 1 / 0;
}
//2.1.2 仅有学生保存成功。外围方法没有开启事务，插入学生方法和插入教师方法分别开启自己的事
//务，插入教师方法抛出异常回滚，其他事务不受影响。
@Override
public void noTransactionRequiresNewRequiresNewException() {
Student student = new Student();
student.setName("学生2.1.2");
studentService.addRequiresNew(student);
Teacher teacher = new Teacher();
teacher.setName("教师2.1.2");
teacherService.addRequiresNewException(teacher);
}
//结论：通过这两个方法我们证明了在外围方法未开启事务的情况下Propagation.REQUIRES_NEW修饰的
//内部方法会新开启自己的事务，且开启的事务相互独立，互不干扰。
/**
* 2.2 外围方法开启事务。
*/
//2.2.1 学生插入失败，教师都插入成功。 外围方法开启事务，插入 学生2.2.1 方法和外围方法一个事
//务，插入 教师2.2.1-1方法、插入教师2.2.1-2方法分别在独立的新建事务中，外围方法抛出异常只回滚和
//外围方法同一事务的方法，故插入学生2.2.1的方法回滚。
@Override
@Transactional(propagation = Propagation.REQUIRED)
public void transactionExceptionRequiredRequiresNewRequiresNew() {
Student student = new Student();
student.setName("学生2.2.1");
studentService.addRequired(student);
Teacher teacher1 = new Teacher();
teacher1.setName("教师2.2.1-1");
teacherService.addRequiresNew(teacher1);
Teacher teacher2 = new Teacher();
teacher2.setName("教师2.2.1-2");
teacherService.addRequiresNew(teacher2);
int i = 1 / 0;
}
//2.2.2 仅有 教师2.2.2-1 插入成功。外围方法开启事务，插入“学生2.2.2“方法和外围方法一个事
//务，插入“教师2.2.2-1”方法、插入“教师2.2.2-2”方法分别在独立的新建事务中。插入“教师2.2.2-2”方法
//抛出异常，首先插入 “教师2.2.2-2”方法的事务被回滚，异常继续抛出被外围方法感知，外围方法事务亦被
//回滚，故插入“学生2.2.2”方法也被回滚。
@Override
@Transactional(propagation = Propagation.REQUIRED)
public void transactionRequiredRequiresNewRequiresNewException() {
Student student = new Student();
student.setName("学生2.2.2");
studentService.addRequired(student);
Teacher teacher1 = new Teacher();
teacher1.setName("教师2.2.2-1");
teacherService.addRequiresNew(teacher1);
Teacher teacher2 = new Teacher();
teacher2.setName("教师2.2.2-2");
teacherService.addRequiresNewException(teacher2);
}
//2.2.3 学生2.2.3 和 教师2.2.3-1 插入成功。
//外围方法开启事务，插入“学生2.2.3”方法和外围方法一个事务，插入“教师2.2.3-1”方法、插入“教师
//2.2.3-2”方法分别在独立的新建事务中。插入“教师2.2.3-2”方法抛出异常，首先插入“教师2.2.3-2”方法
//的事务被回滚，异常被catch不会被外围方法感知，外围方法事务不回滚，故插入“学生2.2.3”方法插入成功。
@Override
@Transactional(propagation = Propagation.REQUIRED)
public void transactionRequiredRequiresNewRequiresNewExceptionTry() {
Student student = new Student();
student.setName("学生2.2.3");
studentService.addRequired(student);
Teacher teacher1 = new Teacher();
teacher1.setName("教师2.2.3-1");
teacherService.addRequiresNew(teacher1);
Teacher teacher2 = new Teacher();
teacher2.setName("教师2.2.3-2");
try {
teacherService.addRequiresNewException(teacher2);
} catch (Exception e) {
System.out.println("异常");
}
}
//结论：在外围方法开启事务的情况下Propagation.REQUIRES_NEW修饰的内部方法依然会单独开启独立
//事务，且与外部方法事务也独立，内部方法之间、内部方法和外部方法事务均相互独立，互不干扰。
/*-----------------------------3. 测试 propagation = Propagation.NESTED--------------------------------------------------------------------------------*/
/**
* 3.1 外围方法没有开启事务。
*/
//3.1.1 两个都插入成功。 外围方法未开启事务，插入“学生3.1.1”、“教师3.1.1”方法在自己的事务中
//独立运行，外围方法异常不影响内部插入“学生3.1.1”、“教师3.1.1”方法独立的事务。
@Override
public void noTransactionExceptionNestedNested() {
Student student = new Student();
student.setName("学生3.1.1");
studentService.addNested(student);
Teacher teacher1 = new Teacher();
teacher1.setName("教师3.1.1");
teacherService.addNested(teacher1);
int i = 1 / 0;
}
//3.1.2 仅学生3.1.2插入成功。 外围方法没有事务，插入“学生3.1.2”、“教师3.1.2”方法都在自己
//的事务中独立运行,所以插入“教师3.1.2”方法抛出异常只会回滚插入“教师3.1.2”方法，插入“学生3.1.2”
//方法不受影响。
@Override
public void noTransactionNestedNestedException() {
Student student = new Student();
student.setName("学生3.1.2");
studentService.addNested(student);
Teacher teacher1 = new Teacher();
teacher1.setName("教师3.1.2");
teacherService.addNestedException(teacher1);
}
//结论：通过这两个方法我们证明了在外围方法未开启事务的情况下Propagation.NESTED和
//Propagation.REQUIRED作用相同，修饰的内部方法都会新开启自己的事务，且开启的事务相互独立，互不干扰。
/**
* 3.2 外围方法开启事务
*/
//3.2.1 都插入失败。 外围方法开启事务，内部事务为外围事务的子事务，外围方法回滚，内部方法也
//要回滚。
@Override
@Transactional
public void transactionExceptionNestedNested() {
Student student = new Student();
student.setName("学生3.2.1");
studentService.addNested(student);
Teacher teacher1 = new Teacher();
teacher1.setName("教师3.2.1");
teacherService.addNested(teacher1);
int i = 1 / 0;
}
//3.2.2 都插入失败。外围方法开启事务，内部事务为外围事务的子事务，内部方法抛出异常回滚，且外
//围方法感知异常致使整体事务回滚。
@Override
@Transactional
public void transactionNestedNestedException() {
Student student = new Student();
student.setName("学生3.2.2");
studentService.addNested(student);
Teacher teacher1 = new Teacher();
teacher1.setName("教师3.2.2");
teacherService.addNestedException(teacher1);
}
//3.2.3 仅学生3.2.3 插入成功。 外围方法开启事务，内部事务为外围事务的子事务，插入“教师
//3.2.3”内部方法抛出异常，可以单独对子事务回滚。
@Override
@Transactional
public void transactionNestedNestedExceptionTry() {
Student student = new Student();
student.setName("学生3.2.3");
studentService.addNested(student);
Teacher teacher1 = new Teacher();
teacher1.setName("教师3.2.3");
try {
teacherService.addNestedException(teacher1);
} catch (Exception e) {
System.out.println("exception");
}
//结论：以上试验结果我们证明在外围方法开启事务的情况下Propagation.NESTED修饰的内部方法
//属于外部事务的子事务，外围主事务回滚，子事务一定回滚，而内部子事务可以单独回滚而不影响外围主事
//务和其他子事务
}
}3.REQUIRED,REQUIRES_NEW,NESTED异同
由“1.2 ”和“3.2 ”对比，我们可知：NESTED和REQUIRED修饰的内部方法都属于外围方法事务，如果外围方法抛出异常，这两种方法的事务都会被回滚。但是REQUIRED是加入外围方法事务，所以和外围事务同属于一个事务，一旦REQUIRED事务抛出异常被回滚，外围方法事务也将被回滚。而NESTED是外围方法的子事务，有单独的保存点，所以NESTED方法抛出异常被回滚，不会影响到外围方法的事务。
由上面测试 “2.2 ”和“3.2 ”对比，我们可知：NESTED和REQUIRES_NEW都可以做到内部方法事务回滚而不影响外围方法事务。但是因为NESTED是嵌套事务，所以外围方法回滚之后，作为外围方法事务的子事务也会被回滚。而REQUIRES_NEW是通过开启新的事务实现的，内部事务和外围事务是两个事务，外围事务回滚不会影响内部事务。
完整源码地址：https://github.com/crossyourheart/TestTransactionPropagation.git
参考：https://blog.csdn.net/yuan520588/article/details/88919659
2461
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
