Spring 中的事务传播行为

Posted on | In

关于 Spring 事务，平时开发过程中都会有接触到，但是对这块知识的详细总结却很少，所以本文总结了下 Spring 事务的传播行为。

搜索微信公众号【 Jet与编程 】体验更多有趣功能和文章哦。

背景介绍

Spring 框架应该是每一个人 javaer 都必须接触和学习的技术，Spring 公司所提供的各种框架是 Java 开发行业可参考的重要标准之一。

Spring 中有 7 种类型的事务传播行为。事务传播行为是 Spring 框架提供的一种事务管理方式，它是 Spring 框架之中非常重要的一个技术点，毕竟事务关系到应用程序和数据库的交互，而数据更是互联网行业最为重要的资源。

平时开发过程中事务都会有使用，但是没有真正地总结过，尤其是事务中嵌套事务的场景，此篇基础知识文在此做一个简单的学习总结，

事务

事务的特征

特性 说明
原子性 一个事务中所有对数据库的操作是一个不可分割的操作序列，要么全做要么全不做
一致性 数据不会因为事务的执行而遭到破坏
隔离性 一个事物的执行，不受其他事务的干扰，即并发执行的事物之间互不干扰
持久性 一个事物一旦提交，它对数据库的改变就是永久的

事务的隔离级别

隔离级别 说明
read_uncommitted 读未提交，一个事务可以感知或者操作另外一个未提交的事务，可能会出现脏读、不可重复读、幻读
read_committed 读已提交，一个事务只能感知或者操作另一个已经提交的事务，可能会出现不可重复读、幻读
repeatable_read 可重复读，能够避免脏读，不可重复读，不能避免幻读
serializable 串行化，隔离级别最高，消耗资源最低，代价最高，能够防止脏读， 不可重复读，幻读。

mysql 默认的事务隔离级别是 repeatable_read

Spring 事务的传播行为

传播行为 说明
① Propagation.REQUIRED（默认） 如果当前存在事务，则加入该事务，如果当前不存在事务，则创建一个新的事务。
② Propagation.SUPPORTS 如果当前存在事务，则加入该事务；如果当前不存在事务，则以非事务的方式继续运行。
③ Propagation.MANDATORY 如果当前存在事务，则加入该事务；如果当前不存在事务，则抛出异常。
④ Propagation.REQUIRES_NEW 重新创建一个新的事务，如果当前存在事务，延缓当前的事务。
⑤ Propagation.NOT_SUPPORTED 以非事务的方式运行，如果当前存在事务，暂停当前的事务。
⑥ Propagation.NEVER 以非事务的方式运行，如果当前存在事务，则抛出异常。
⑦ Propagation.NESTED 如果没有，就新建一个事务；如果有，就在当前事务中嵌套其他事务。

代码演示

准备动作：新建一个 spring 项目，数据库脚本见：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;

-- ----------------------------
-- Table structure for customer
-- ----------------------------
DROP TABLE IF EXISTS `customer`;
CREATE TABLE `customer` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `name` varchar(255) COLLATE utf8mb4_bin DEFAULT NULL,
  `remark` varchar(255) COLLATE utf8mb4_bin DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_bin;

-- ----------------------------
-- Records of customer
-- ----------------------------
BEGIN;
INSERT INTO `customer` VALUES (1, 'A', 'a');
INSERT INTO `customer` VALUES (2, 'B', 'b');
INSERT INTO `customer` VALUES (3, 'C', 'c');
COMMIT;

SET FOREIGN_KEY_CHECKS = 1;

测试步骤为：方法 A 中调用方法 B 和 方法 C，三个方法各自操作数据库中的一条数据，然后方法 A、B、C 组合添加事务
伪代码为：

1
2
3
4
function A(){ // 方法 A
    functionB(); // 方法 B
    functionC(); // 方法 C
}

① Propagation.REQUIRED（默认）

  • 步骤：
1
2
3
4
5
@Transactional
function A(){ // 有事务
    functionB(); // 无事务，代码正常
    functionC(); // 无事务，代码抛异常
}
  • 结果：

数据库中无数据

  • 说明：

方法 B 和方法 C 虽然没有自己的事务，但是外层的方法 A 是有事务的，由于默认的事务传播机制，所以方法 B 和 C 都加入到了 A 的事务之中，所以当 C 报错时，B 也随着回滚了。

② Propagation.SUPPORTS

  • 步骤：
1
2
3
4
function A(){ // 无事务
    functionB(); // 有事务，代码正常，事务为：@Transactional(propagation = Propagation.SUPPORTS)
    functionC(); // 有事务，代码抛异常，事务为：@Transactional(propagation = Propagation.SUPPORTS)
}
  • 结果：

数据库中有两条数据

  • 说明：

Propagation.SUPPORTS 的意思是当前有事务则加入，没有则不添加事务，所以，由于 A 是没有事务的，那么 B 和 C 自然而然也就不加入事务中，而 C 中的报错了，那么自然而然也就不会进行数据回滚。

③ Propagation.MANDATORY

  • 步骤：
1
2
3
4
function A(){ // 无事务
    functionB(); // 有事务，代码正常，事务为：@Transactional(propagation = Propagation.MANDATORY)
    functionC(); // 有事务，代码抛异常，事务为：@Transactional(propagation = Propagation.SUPPORTS)
}
  • 结果：

不仅数据库中无数据，而且运行时报错：org.springframework.transaction.IllegalTransactionStateException: No existing transaction found for transaction marked with propagation 'mandatory'

  • 说明：

Propagation.MANDATORY 的意思是当前有事务则加入，没有事务则抛出异常。所以上述代码在运行时抛出了 IllegalTransactionStateException 异常。

④ Propagation.REQUIRES_NEW

  • 步骤：
1
2
3
4
5
6
function A(){ // 有事务
    insert one data;
    
    functionB(); // 有事务，代码正常，事务为：@Transactional(propagation = Propagation.REQUIRES_NEW)
    functionC(); // 有事务，代码抛异常，事务为：@Transactional(propagation = Propagation.REQUIRES_NEW)
}
  • 结果：

数据库中仅有方法 B 的一条数据。

  • 说明：

Propagation.REQUIRES_NEW 的意思是重新创建一个新的事务，如果当前存在事务，延缓当前的事务。
这个理解起来有点拗。结合上述代码案例来看，首先 B 和 C 都是有各自的事务的，所以在 C 抛出异常后，C 会回滚，而 B 则会正常插入一条数据，毕竟两者的事务的独立的，但是此时 A 也是有事务的，并且 A 的事务是在 B 和 C 之后再执行的，所以当 C 抛出异常之后，A 自然而然也就捕获到了，那么 A 的事务也会回滚，所以数据库中 A 插入的数据也被回滚掉了。

⑤ Propagation.NOT_SUPPORTED

  • 步骤：
1
2
3
4
function A(){ // 有事务
    functionB(); // 无事务，代码正常，添加注解：@Transactional(propagation = Propagation.NOT_SUPPORTED)
    functionC(); // 无事务，代码抛异常，添加注解：@Transactional(propagation = Propagation.NOT_SUPPORTED)
}
  • 结果：

数据库中有 B 和 C 两条数据。

  • 说明：

Propagation.NOT_SUPPORTED 的意思是当前代码以非事务的方式运行，就算有事务，而已暂停当前事务。
结合上面的伪代码来看，虽然 A 是有事务的，但是 B 和 c 的注解为 NOT_SUPPORTED，意思是我这个方法是不需要加入事务中的，所以 B 和 C 是没有加入 A 的事务中去的，所以哪怕 B 抛出异常，由于不参会事务，所以 B 和 C 的数据都是不会回滚的，所以数据库中就会有 B 和 C 两条数据。

⑥ Propagation.NEVER

  • 步骤：
1
2
3
4
function A(){ // 有事务
    functionB(); // 无事务，代码正常，添加注解：@Transactional(propagation = Propagation.NEVER)
    functionC(); // 无事务，代码抛异常，添加注解：@Transactional(propagation = Propagation.NEVER)
}
  • 结果：

数据库中无数据，并且运行时报错org.springframework.transaction.IllegalTransactionStateException: Existing transaction found for transaction marked with propagation 'never'

  • 说明：

Propagation.NEVER 的意思是以非事务的方式去运行，如果有事务，则抛出异常。
上述伪代码中，A 是有事务的，但是 B 和 C 添加了 NEVER 的事务，意思是别给我加事务，我拒绝，你要是给我加了事务我就给你抛异常。

⑦ Propagation.NESTED

  • 步骤：
1
2
3
4
5
6
7
8
function A(){ // 有事务
    insert one data;
    
    functionB(); // 有事务，代码正常，事务为：@Transactional(propagation = Propagation.NESTED)
    functionC(); // 有事务，代码抛异常，事务为：@Transactional(propagation = Propagation.NESTED)
    
    throw exception;
}
  • 结果：

结果就是没有结果，因为 JPA 是不支持这种循环嵌套事务的，所以在运行的时候就会抛出异常：
org.springframework.transaction.NestedTransactionNotSupportedException: JpaDialect does not support savepoints - check your JPA provider's capabilities

  • 说明：

Propagation.NESTED 的意思是如果外层没有事务，则内层会添加一个，而如果外层有事务，则内层会嵌套一层事务，即内层是有两层事务的。

其他

demo 的源码见：【GitHub 地址】

------ 本文结束 感谢阅读 ------
0%