51. Spring事务管理中的嵌套事务是如何实现的？

PangHu大约 3 分钟

嵌套事务是指在一个事务的上下文中，再开启一个新的子事务。在 Spring 中，通过 Propagation.NESTED 来实现嵌套事务。嵌套事务允许子事务独立于外层事务提交或回滚，如果子事务回滚，外层事务可以选择是否继续提交或整体回滚。

嵌套事务与 Propagation.REQUIRES_NEW 的区别在于，REQUIRES_NEW 总是开启一个全新的事务，且与外层事务完全隔离；而 NESTED 是在外层事务的上下文中创建一个保存点（savepoint），子事务回滚时可以回滚到这个保存点，而不影响整个外层事务。

Spring中如何实现嵌套事务？

在 Spring 中，可以通过 @Transactional 注解中的 propagation 属性设置为 Propagation.NESTED 来实现嵌套事务。

1. 配置嵌套事务

假设有两个服务类 ParentService 和 ChildService，其中 ChildService 在 ParentService 的事务上下文中执行。

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

@Service
public class ChildService {

    @Transactional(propagation = Propagation.NESTED)
    public void performNestedTask() {
        // 执行嵌套事务中的操作
        System.out.println("Executing nested transaction");

        // 模拟异常
        if (someConditionFails()) {
            throw new RuntimeException("Exception in nested transaction");
        }
    }

    private boolean someConditionFails() {
        return true;
    }
}

在这个 ChildService 中，performNestedTask() 方法被标记为 Propagation.NESTED，因此它将在调用时开启一个嵌套事务。

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
public class ParentService {

    @Autowired
    private ChildService childService;

    @Transactional
    public void performTask() {
        // 执行外层事务中的操作
        System.out.println("Executing parent transaction");

        // 调用嵌套事务的方法
        try {
            childService.performNestedTask();
        } catch (Exception e) {
            System.out.println("Exception caught in parent transaction");
        }

        // 后续操作
        System.out.println("Continuing parent transaction");
    }
}

在 ParentService 中，performTask() 方法是外层事务，调用了 ChildService 中的嵌套事务方法 performNestedTask()。

2. 嵌套事务的执行流程

当 ParentService.performTask() 被调用时，执行流程如下：

ParentService.performTask() 开启一个外层事务。
调用 childService.performNestedTask() 时，Spring 创建一个保存点（savepoint），开启嵌套事务。
如果 performNestedTask() 方法抛出异常（如 RuntimeException），则嵌套事务会回滚到保存点，外层事务可以选择继续执行或整体回滚。
如果外层事务（performTask）后续操作不抛出异常，则外层事务可以成功提交。

3. 嵌套事务与 `REQUIRES_NEW` 的区别

嵌套事务（NESTED）：子事务在外层事务的上下文中执行，回滚时只回滚到保存点，不会影响外层事务。如果外层事务回滚，子事务的所有操作也会被回滚。
新事务（REQUIRES_NEW）：子事务独立于外层事务执行，无论外层事务是否提交或回滚，子事务的提交或回滚都不受影响。

4. 示例：嵌套事务回滚场景

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

@Component
public class ExampleService {

    @Autowired
    private ChildService childService;

    @Transactional
    public void outerMethod() {
        System.out.println("Start outer transaction");

        // 调用嵌套事务
        try {
            childService.performNestedTask();
        } catch (Exception e) {
            System.out.println("Nested transaction rolled back");
        }

        System.out.println("End outer transaction");
    }
}

在这个示例中，如果 performNestedTask() 方法抛出异常，嵌套事务会回滚到保存点，而 outerMethod 中的外层事务会继续执行剩余代码，并决定是否提交或回滚。

5. 适用场景

嵌套事务适用于以下场景：

需要在同一事务中执行部分操作，并且希望在某些操作失败时可以回滚这部分操作而不影响整个事务的提交。
子事务的操作逻辑比较独立，但与外层事务密切相关。

总结

嵌套事务：使用 Propagation.NESTED 实现，允许在同一事务中创建子事务，当子事务失败时回滚到保存点，而不影响外层事务的其他操作。
实现：通过 @Transactional 注解设置 propagation = Propagation.NESTED 来实现嵌套事务。
与 REQUIRES_NEW 的区别：NESTED 的子事务与外层事务共享上下文，而 REQUIRES_NEW 开启一个全新的独立事务。

嵌套事务为事务管理提供了更细粒度的控制，使开发者能够在复杂的业务场景中更好地处理部分操作的失败和回滚。