Spring事务传播性

背景介绍

Spring 框架应该是每一个人 javaer 都必须接触和学习的技术，Spring 公司所提供的各种框架是 Java 开发行业可参考的重要标准之一。
Spring 中有 7 种类型的事务传播行为。事务传播行为是 Spring 框架提供的一种事务管理方式。

public enum Propagation {
    /**
     * 需要事务，默认传播性行为。
     * 如果当前存在事务，就沿用当前事务，否则新建一个事务运行子方法
     */
    REQUIRED(0),
    /**
     * 支持事务，如果当前存在事务，就沿用当前事务，
     * 如果不存在，则继续采用无事务的方式运行子方法
     */
    SUPPORTS(1),
    /**
     * 必须使用事务，如果当前没有事务，抛出异常
     * 如果存在当前事务,就沿用当前事务
     */
    MANDATORY(2),
    /**
     * 无论当前事务是否存在，都会创建新事务允许方法
     * 这样新事务就可以拥有新的锁和隔离级别等特性，与当前事务相互独立
     */
    REQUIRES_NEW(3),
    /**
     * 不支持事务，当前存在事务时，将挂起事务，运行方法
     */
    NOT_SUPPORTED(4),
    /**
     * 不支持事务，如果当前方法存在事务，将抛出异常，否则继续使用无事务机制运行
     */
    NEVER(5),
    /**
     * 在当前方法调用子方法时，如果子方法发生异常
     * 只回滚子方法执行过的SQL，而不回滚当前方法的事务
     */
    NESTED(6);
    ......
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

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

function A(){ // 方法 A,增加一条数据a
    functionB(); // 方法 B,增加一条数据b
    functionC(); // 方法 C,添加一条数据c
}
1
2
3
4

1. Propagation.REQUIRED（默认）

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

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

2. Propagation.SUPPORTS

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

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

3. Propagation.MANDATORY

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

结果：不仅数据库中无数据，而且运行时报错
说明：Propagation.MANDATORY 的意思是当前有事务则加入，没有事务则抛出异常。所以上述代码在运行时抛出了 IllegalTransactionStateException 异常。

4. Propagation.REQUIRES_NEW

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

结果： 数据库中仅有方法 B 的一条数据。
说明： Propagation.REQUIRES_NEW 的意思是不支持当前事务，当前存在事务时，将挂起事务，而且新建一个自己的事务运行方法，结合上述代码案例来看，首先 B 和 C 都是有各自的事务的，所以在 C 抛出异常后，C 会回滚，而 B 则会正常插入一条数据，毕竟两者的事务的独立的，但是此时 A 也是有事务的，并且 A 的事务是在 B 和 C 之后再执行的，所以当 C 抛出异常之后，A 自然而然也就捕获到了，那么 A 的事务也会回滚，所以数据库中 A 插入的数据也被回滚掉了。

5. Propagation.NOT_SUPPORTED

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

结果：
数据库中有 B 和 C 两条数据。

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

6. Propagation.NEVER

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

结果：
数据库中无数据，并且运行时报错

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

7. Propagation.NESTED

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

结果：数据库中有两条数据

说明：
Propagation.NESTED 的意思是如果外层没有事务，则内层会添加一个，而如果外层有事务，则内层会嵌套一层事务，即内层是有两层事务的。C方法报错回滚时只会回滚自己的语句，不会影响上层的事务。

示例

问题:在一个批量任务执行的过程中，调用多个子任务时，如果有一些子任务发生异常，只是回滚那些出现异常的任务，而不是整个批量任务，请问在Spring中事务需要如何配置才能实现这一功能呢？

方法：更改子任务的隔离级别为----PROPAGATION_NESTED；