带你吃透Spring事务7种传播行为 | Spring第45篇
带你吃透Spring事务7种传播行为 | Spring第45篇
本文详解Spring事务中的7种传播行为，还是比较重要的。
环境
- jdk1.8
- Spring 5.2.3.RELEASE
- mysql5.7
什么是事务传播行为？
事务的传播行为用来描述：系统中的一些方法交由spring来管理事务，当这些方法之间出现嵌套调用的时候，事务所表现出来的行为是什么样的？
比如下面2个类，Service1中的m1方法和Service2中的m2方法上面都有@Transactional注解，说明这2个方法由spring来控制事务。
但是注意m1中2行代码，先执行了一个insert，然后调用service2中的m2方法，service2中的m2方法也执行了一个insert。
那么大家觉得这2个insert会在一个事务中运行么？也就是说此时事务的表现行为是什么样的呢？这个就是spring事务的传播行为来控制的事情，不同的传播行为，表现会不一样，可能他们会在一个事务中执行，也可能不会在一个事务中执行，这就需要看传播行为的配置了。
@Component
public class Service1 {
@Autowired
private Service2 service2;
@Autowired
private JdbcTemplate jdbcTemplate;
@Transactional
public void m1() {
this.jdbcTemplate.update("INSERT into t1 values ('m1')");
this.service2.m2();
}
}
@Component
public class Service2 {
@Autowired
private JdbcTemplate jdbcTemplate;
@Transactional
public void m2() {
this.jdbcTemplate.update("INSERT into t1 values ('m2')");
}
}
如何配置事务传播行为？
通过@Transactional注解中的propagation属性来指定事务的传播行为：
Propagation propagation() default Propagation.REQUIRED;
Propagation是个枚举，有7种值，如下：
事务传播行为类型 | 说明 |
|---|---|
REQUIRED | 如果当前事务管理器中没有事务，就新建一个事务，如果已经存在一个事务中，加入到这个事务中。这是最常见的选择，是默认的传播行为。 |
SUPPORTS | 支持当前事务，如果当前事务管理器中没有事务，就以非事务方式执行。 |
MANDATORY | 使用当前的事务，如果当前事务管理器中没有事务，就抛出异常。 |
REQUIRES_NEW | 新建事务，如果当前事务管理器中存在事务，把当前事务挂起，然后会新建一个事务。 |
NOT_SUPPORTED | 以非事务方式执行操作，如果当前事务管理器中存在事务，就把当前事务挂起。 |
NEVER | 以非事务方式执行，如果当前事务管理器中存在事务，则抛出异常。 |
NESTED | 如果当前事务管理器中存在事务，则在嵌套事务内执行；如果当前事务管理器中没有事务，则执行与PROPAGATION_REQUIRED类似的操作。 |
注意：这7种传播行为有个前提，他们的事务管理器是同一个的时候，才会有上面描述中的表现行为。
下面通过案例对7中表现行为来做说明，在看案例之前，先来回顾几个知识点
1、Spring声明式事务处理事务的过程
spring声明式事务是通过事务拦截器TransactionInterceptor拦截目标方法，来实现事务管理的功能的，事务管理器处理过程大致如下：
1、获取事务管理器
2、通过事务管理器开启事务
try{
3、调用业务方法执行db操作
4、提交事务
}catch(RuntimeException | Error){
5、回滚事务
}
2、何时事务会回滚？
默认情况下，目标方法抛出RuntimeException或者Error的时候，事务会被回滚。
3、Spring事务管理器中的Connection和业务中操作db的Connection如何使用同一个的？
以DataSourceTransactionManager为事务管理器，操作db使用JdbcTemplate来说明一下。
创建DataSourceTransactionManager和JdbcTemplate的时候都需要指定dataSource，需要将他俩的dataSource指定为同一个对象。
当事务管理器开启事务的时候，会通过dataSource.getConnection()方法获取一个db连接connection，然后会将dataSource->connection丢到一个Map中，然后将map放到ThreadLocal中。
当JdbcTemplate执行sql的时候，以JdbcTemplate.dataSource去上面的ThreadLocal中查找，是否有可用的连接，如果有，就直接拿来用了，否则调用JdbcTemplate.dataSource.getConnection()方法获取一个连接来用。
所以spring中可以确保事务管理器中的Connection和JdbcTemplate中操作db的Connection是同一个，这样才能确保spring可以控制事务。
代码验证
准备db
DROP DATABASE IF EXISTS javacode2018;
CREATE DATABASE if NOT EXISTS javacode2018;
USE javacode2018;
DROP TABLE IF EXISTS user1;
CREATE TABLE user1(
id int PRIMARY KEY AUTO_INCREMENT,
name varchar(64) NOT NULL DEFAULT '' COMMENT '姓名'
);
DROP TABLE IF EXISTS user2;
CREATE TABLE user2(
id int PRIMARY KEY AUTO_INCREMENT,
name varchar(64) NOT NULL DEFAULT '' COMMENT '姓名'
);
spring配置类MainConfig6
准备JdbcTemplate和事务管理器。
package com.javacode2018.tx.demo6;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;
import javax.sql.DataSource;
@EnableTransactionManagement //开启spring事务管理功能
@Configuration //指定当前类是一个spring配置类
@ComponentScan //开启bean扫描注册
public class MainConfig6 {
//定义一个数据源
@Bean
public DataSource dataSource() {
org.apache.tomcat.jdbc.pool.DataSource dataSource = new org.apache.tomcat.jdbc.pool.DataSource();
dataSource.setDriverClassName("com.mysql.jdbc.Driver");
dataSource.setUrl("jdbc:mysql://localhost:3306/javacode2018?characterEncoding=UTF-8");
dataSource.setUsername("root");
dataSource.setPassword("root123");
dataSource.setInitialSize(5);
return dataSource;
}
//定义一个JdbcTemplate,用来执行db操作
@Bean
public JdbcTemplate jdbcTemplate(DataSource dataSource) {
return new JdbcTemplate(dataSource);
}
//定义我一个事务管理器
@Bean
public PlatformTransactionManager transactionManager(DataSource dataSource) {
return new DataSourceTransactionManager(dataSource);
}
}
来3个service
后面的案例中会在这3个service中使用spring的事务来演示效果。
User1Service
package com.javacode2018.tx.demo6;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Component;
@Component
public class User1Service {
@Autowired
private JdbcTemplate jdbcTemplate;
}
User2Service
package com.javacode2018.tx.demo6;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Component;
@Component
public class User2Service {
@Autowired
private JdbcTemplate jdbcTemplate;
}
TxService
package com.javacode2018.tx.demo6;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
@Component
public class TxService {
@Autowired
private User1Service user1Service;
@Autowired
private User2Service user2Service;
}
测试用例Demo6Test
before方法会在每个@Test标注的方法之前执行一次，这个方法主要用来做一些准备工作：启动spring容器、清理2个表中的数据；after方法会在每个@Test标注的方法执行完毕之后执行一次，我们在这个里面输出2个表的数据；方便查看的测试用例效果。
package com.javacode2018.tx.demo6;
import org.junit.Before;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
public class Demo6Test {
private TxService txService;
private JdbcTemplate jdbcTemplate;
//每个@Test用例执行之前先启动一下spring容器，并清理一下user1、user2中的数据
@Before
public void before() {
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MainConfig6.class);
txService = context.getBean(TxService.class);
jdbcTemplate = context.getBean(JdbcTemplate.class);
jdbcTemplate.update("truncate table user1");
jdbcTemplate.update("truncate table user2");
}
@After
public void after() {
System.out.println("user1表数据：" + jdbcTemplate.queryForList("SELECT * from user1"));
System.out.println("user2表数据：" + jdbcTemplate.queryForList("SELECT * from user2"));
}
}
1、REQUIRED
User1Service
添加1个方法，事务传播行为：REQUIRED
@Transactional(propagation = Propagation.REQUIRED)
public void required(String name) {
this.jdbcTemplate.update("insert into user1(name) VALUES (?)", name);
}
User2Service
添加2个方法，事务传播行为：REQUIRED，注意第2个方法内部最后一行会抛出一个异常。
@Transactional(propagation = Propagation.REQUIRED)
public void required(String name) {
this.jdbcTemplate.update("insert into user1(name) VALUES (?)", name);
}
@Transactional(propagation = Propagation.REQUIRED)
public void required_exception(String name) {
this.jdbcTemplate.update("insert into user1(name) VALUES (?)", name);
throw new RuntimeException();
}
场景1（1-1）
外围方法没有事务，外围方法内部调用2个REQUIRED级别的事务方法。
案例中都是在TxService的方法中去调用另外2个service，所以TxService中的方法统称外围方法，另外2个service中的方法称内部方法。
验证方法1
TxService添加
public void notransaction_exception_required_required() {
this.user1Service.required("张三");
this.user2Service.required("李四");
throw new RuntimeException();
}
测试用例，Demo6Test中添加
@Test
public void notransaction_exception_required_required() {
txService.notransaction_exception_required_required();
}
运行输出
user1表数据：[{id=1, name=张三}]
user2表数据：[{id=1, name=李四}]
验证方法2
TxService添加
public void notransaction_required_required_exception() {
this.user1Service.required("张三");
this.user2Service.required_exception("李四");
}
测试用例，Demo6Test中添加
@Test
public void notransaction_required_required_exception() {
txService.notransaction_required_required_exception();
}
运行输出
user1表数据：[{id=1, name=张三}]
user2表数据：[]
结果分析
验证方法序号 | 数据库结果 | 结果分析 |
|---|---|---|
1 | “张三”、“李四”均插入。 | 外围方法未开启事务，插入“张三”、“李四”方法在自己的事务中独立运行，外围方法异常不影响内部插入“张三”、“李四”方法独立的事务。 |
2 | “张三”插入，“李四”未插入。 | 外围方法没有事务，插入“张三”、“李四”方法都在自己的事务中独立运行，所以插入“李四”方法抛出异常只会回滚插入“李四”方法，插入“张三”方法不受影响。 |
结论
通过这两个方法我们证明了在外围方法未开启事务的情况下Propagation.REQUIRED修饰的内部方法会新开启自己的事务，且开启的事务相互独立，互不干扰。
场景2（1-2）
外围方法开启事务（Propagation.REQUIRED），这个使用频率特别高。
验证方法1
TxService添加
@Transactional(propagation = Propagation.REQUIRED)
public void transaction_exception_required_required() {
user1Service.required("张三");
user2Service.required("李四");
throw new RuntimeException();
}
测试用例，Demo6Test中添加
@Test
public void transaction_exception_required_required() {
txService.transaction_exception_required_required();
}
运行输出
user1表数据：[]
user2表数据：[]
验证方法2
TxService添加
@Transactional(propagation = Propagation.REQUIRED)
public void transaction_required_required_exception() {
user1Service.required("张三");
user2Service.required_exception("李四");
}
测试用例，Demo6Test中添加
@Test
public void transaction_required_required_exception() {
txService.transaction_required_required_exception();
}
运行输出
user1表数据：[]
user2表数据：[]
验证方法3
TxService添加
@Transactional(propagation = Propagation.REQUIRED)
public void transaction_required_required_exception_try() {
user1Service.required("张三");
try {
user2Service.required_exception("李四");
} catch (Exception e) {
System.out.println("方法回滚");
}
}
测试用例，Demo6Test中添加
@Test
public void transaction_required_required_exception_try() {
txService.transaction_required_required_exception_try();
}
运行输出
方法回滚
user1表数据：[]
user2表数据：[]
结果分析
验证方法序号 | 数据库结果 | 结果分析 |
|---|---|---|
1 | “张三”、“李四”均未插入。 | 外围方法开启事务，内部方法加入外围方法事务，外围方法回滚，内部方法也要回滚。 |
2 | “张三”、“李四”均未插入。 | 外围方法开启事务，内部方法加入外围方法事务，内部方法抛出异常回滚，外围方法感知异常致使整体事务回滚。 |
3 | “张三”、“李四”均未插入。 | 外围方法开启事务，内部方法加入外围方法事务，内部方法抛出异常回滚，即使方法被catch不被外围方法感知，整个事务依然回滚。 |
结论
以上试验结果我们证明在外围方法开启事务的情况下Propagation.REQUIRED修饰的内部方法会加入到外围方法的事务中，所有Propagation.REQUIRED修饰的内部方法和外围方法均属于同一事务，只要一个方法回滚，整个事务均回滚。
2、PROPAGATION_REQUIRES_NEW
User1Service
添加1个方法，事务传播行为：REQUIRES_NEW
@Transactional(propagation = Propagation.REQUIRES_NEW)
public void requires_new(String name) {
this.jdbcTemplate.update("insert into user1(name) VALUES (?)", name);
}
User2Service
添加2个方法，事务传播行为：REQUIRES_NEW，注意第2个方法内部最后一行会抛出一个异常。
@Transactional(propagation = Propagation.REQUIRES_NEW)
public void requires_new(String name) {
this.jdbcTemplate.update("insert into user2(name) VALUES (?)", name);
}
@Transactional(propagation = Propagation.REQUIRES_NEW)
public void requires_new_exception(String name) {
this.jdbcTemplate.update("insert into user2(name) VALUES (?)", name);
throw new RuntimeException();
}
场景1（2-1）
外围方法没有事务。
验证方法1
TxService添加
public void notransaction_exception_requiresNew_requiresNew(){
user1Service.requires_new("张三");
user2Service.requires_new("李四");
throw new RuntimeException();
}
Demo6Test中添加
@Test
public void notransaction_exception_requiresNew_requiresNew() {
txService.notransaction_exception_requiresNew_requiresNew();
}
运行输出
user1表数据：[{id=1, name=张三}]
user2表数据：[{id=1, name=李四}]
验证方法2
TxService添加
public void notransaction_requiresNew_requiresNew_exception(){
user1Service.requires_new("张三");
user2Service.requires_new_exception("李四");
}
测试用例，Demo6Test中添加
@Test
public void notransaction_requiresNew_requiresNew_exception() {
txService.notransaction_requiresNew_requiresNew_exception();
}
运行输出
user1表数据：[{id=1, name=张三}]
user2表数据：[]
结果分析
验证方法序号 | 数据库结果 | 结果分析 |
|---|---|---|
1 | “张三”插入，“李四”插入。 | 外围方法没有事务，插入“张三”、“李四”方法都在自己的事务中独立运行,外围方法抛出异常回滚不会影响内部方法。 |
2 | “张三”插入，“李四”未插入 | 外围方法没有开启事务，插入“张三”方法和插入“李四”方法分别开启自己的事务，插入“李四”方法抛出异常回滚，其他事务不受影响。 |
结论
通过这两个方法我们证明了在外围方法未开启事务的情况下Propagation.REQUIRES_NEW修饰的内部方法会新开启自己的事务，且开启的事务相互独立，互不干扰。
场景2（2-2）
外围方法开启事务。
验证方法1
TxService添加
@Transactional(propagation = Propagation.REQUIRED)
public void transaction_exception_required_requiresNew_requiresNew() {
user1Service.required("张三");
user2Service.requires_new("李四");
user2Service.requires_new("王五");
throw new RuntimeException();
}
测试用例，Demo6Test中添加
@Test
public void transaction_exception_required_requiresNew_requiresNew() {
txService.transaction_exception_required_requiresNew_requiresNew();
}
运行输出
user1表数据：[]
user2表数据：[{id=1, name=李四}, {id=2, name=王五}]
验证方法2
TxService添加
@Transactional(propagation = Propagation.REQUIRED)
public void transaction_required_requiresNew_requiresNew_exception() {
user1Service.required("张三");
user2Service.requires_new("李四");
user2Service.requires_new_exception("王五");
}
Demo6Test中添加
@Test
public void transaction_required_requiresNew_requiresNew_exception() {
txService.transaction_required_requiresNew_requiresNew_exception();
}
运行输出
user1表数据：[]
user2表数据：[{id=1, name=李四}]
验证方法3
TxService添加
@Transactional(propagation = Propagation.REQUIRED)
public void transaction_required_requiresNew_requiresNew_exception_try(){
user1Service.required("张三");
user2Service.requires_new("李四");
try {
user2Service.requires_new_exception("王五");
} catch (Exception e) {
System.out.println("回滚");
}
}
Demo6Test中添加
@Test
public void transaction_required_requiresNew_requiresNew_exception_try() {
txService.transaction_required_requiresNew_requiresNew_exception_try();
}
运行输出
回滚
user1表数据：[{id=1, name=张三}]
user2表数据：[{id=1, name=李四}]
结果分析
验证方法序号 | 数据库结果 | 结果分析 |
|---|---|---|
1 | “张三”未插入，“李四”插入，“王五”插入。 | 外围方法开启事务，插入“张三”方法和外围方法一个事务，插入“李四”方法、插入“王五”方法分别在独立的新建事务中，外围方法抛出异常只回滚和外围方法同一事务的方法，故插入“张三”的方法回滚。 |
2 | “张三”未插入，“李四”插入，“王五”未插入。 | 外围方法开启事务，插入“张三”方法和外围方法一个事务，插入“李四”方法、插入“王五”方法分别在独立的新建事务中。插入“王五”方法抛出异常，首先插入 “王五”方法的事务被回滚，异常继续抛出被外围方法感知，外围方法事务亦被回滚，故插入“张三”方法也被回滚。 |
3 | “张三”插入，“李四”插入，“王五”未插入。 | 外围方法开启事务，插入“张三”方法和外围方法一个事务，插入“李四”方法、插入“王五”方法分别在独立的新建事务中。插入“王五”方法抛出异常，首先插入“王五”方法的事务被回滚，异常被catch不会被外围方法感知，外围方法事务不回滚，故插入“张三”方法插入成功。 |
结论
在外围方法开启事务的情况下Propagation.REQUIRES_NEW修饰的内部方法依然会单独开启独立事务，且与外部方法事务也独立，内部方法之间、内部方法和外部方法事务均相互独立，互不干扰。
3、PROPAGATION_NESTED
User1Service
添加1个方法，事务传播行为：NESTED
@Transactional(propagation = Propagation.NESTED)
public void nested(String name) {
this.jdbcTemplate.update("insert into user1(name) VALUES (?)", name);
}
User2Service
添加2个方法，事务传播行为：NESTED，注意第2个方法内部最后一行会抛出一个异常。
@Transactional(propagation = Propagation.NESTED)
public void nested(String name) {
this.jdbcTemplate.update("insert into user2(name) VALUES (?)", name);
}
@Transactional(propagation = Propagation.NESTED)
public void nested_exception(String name) {
this.jdbcTemplate.update("insert into user2(name) VALUES (?)", name);
throw new RuntimeException();
}
场景1（3-1）
外围方法没有事务。
验证方法1
TxService添加
public void notransaction_exception_nested_nested(){
user1Service.nested("张三");
user2Service.nested("李四");
throw new RuntimeException();
}
Demo6Test中添加
@Test
public void notransaction_exception_nested_nested() {
txService.notransaction_exception_nested_nested();
}
运行输出
user1表数据：[{id=1, name=张三}]
user2表数据：[{id=1, name=李四}]
验证方法2
TxService添加
public void notransaction_nested_nested_exception(){
user1Service.nested("张三");
user2Service.nested_exception("李四");
}
测试用例，Demo6Test中添加
@Test
public void notransaction_nested_nested_exception() {
txService.notransaction_nested_nested_exception();
}
运行输出
user1表数据：[{id=1, name=张三}]
user2表数据：[]
结果分析
验证方法序号 | 数据库结果 | 结果分析 |
|---|---|---|
1 | “张三”、“李四”均插入。 | 外围方法未开启事务，插入“张三”、“李四”方法在自己的事务中独立运行，外围方法异常不影响内部插入“张三”、“李四”方法独立的事务。 |
2 | “张三”插入，“李四”未插入。 | 外围方法没有事务，插入“张三”、“李四”方法都在自己的事务中独立运行,所以插入“李四”方法抛出异常只会回滚插入“李四”方法，插入“张三”方法不受影响。 |
结论
通过这两个方法我们证明了在外围方法未开启事务的情况下Propagation.NESTED和Propagation.REQUIRED作用相同，修饰的内部方法都会新开启自己的事务，且开启的事务相互独立，互不干扰。
场景2（3-1）
外围方法开启事务。
验证方法1
TxService添加
@Transactional
public void transaction_exception_nested_nested(){
user1Service.nested("张三");
user2Service.nested("李四");
throw new RuntimeException();
}
测试用例，Demo6Test中添加
@Test
public void transaction_exception_nested_nested() {
txService.transaction_exception_nested_nested();
}
运行输出
user1表数据：[]
user2表数据：[]
验证方法2
TxService添加
@Transactional
public void transaction_nested_nested_exception(){
user1Service.nested("张三");
user2Service.nested_exception("李四");
}
Demo6Test中添加
@Test
public void transaction_nested_nested_exception() {
txService.transaction_nested_nested_exception();
}
运行输出
user1表数据：[]
user2表数据：[]
验证方法3
TxService添加
@Transactional
public void transaction_nested_nested_exception_try(){
user1Service.nested("张三");
try {
user2Service.nested_exception("李四");
} catch (Exception e) {
System.out.println("方法回滚");
}
}
Demo6Test中添加
@Test
public void transaction_nested_nested_exception_try() {
txService.transaction_nested_nested_exception_try();
}
运行输出
方法回滚
user1表数据：[{id=1, name=张三}]
user2表数据：[]
结果分析
验证方法序号 | 数据库结果 | 结果分析 |
|---|---|---|
1 | “张三”、“李四”均未插入。 | 外围方法开启事务，内部事务为外围事务的子事务，外围方法回滚，内部方法也要回滚。 |
2 | “张三”、“李四”均未插入。 | 外围方法开启事务，内部事务为外围事务的子事务，内部方法抛出异常回滚，且外围方法感知异常致使整体事务回滚。 |
3 | “张三”插入、“李四”未插入。 | 外围方法开启事务，内部事务为外围事务的子事务，插入“李四”内部方法抛出异常，可以单独对子事务回滚。 |
结论
以上试验结果我们证明在外围方法开启事务的情况下Propagation.NESTED修饰的内部方法属于外部事务的子事务，外围主事务回滚，子事务一定回滚，而内部子事务可以单独回滚而不影响外围主事务和其他子事务。
内部事务原理
以mysql为例，mysql中有个savepoint的功能，NESTED内部事务就是通过这个实现的。
REQUIRED,REQUIRES_NEW,NESTED比较
由“场景2（1-2）”和“场景2（3-2）”对比，我们可知：
REQUIRED和NESTED修饰的内部方法都属于外围方法事务，如果外围方法抛出异常，这两种方法的事务都会被回滚。但是REQUIRED是加入外围方法事务，所以和外围事务同属于一个事务，一旦REQUIRED事务抛出异常被回滚，外围方法事务也将被回滚。而NESTED是外围方法的子事务，有单独的保存点，所以NESTED方法抛出异常被回滚，不会影响到外围方法的事务。
由“场景2（2-2）”和“场景2（3-2）”对比，我们可知：