Java 后端 / 系统课时

理解 NESTED 与保存点

理解 NESTED 与保存点

本课解决一个常见误区:NESTED 不是开启第二个可独立提交的事务。你将用一个真正经过 Spring 事务代理的 JDBC 示例验证保存点回滚,并据此区分它与 REQUIRES_NEW 的事务边界和适用场景。

学习目标

  • 能解释 NESTED、保存点与外层物理事务之间的关系
  • 能用实际事务管理器和 JDBC 驱动验证保存点能力与局部回滚结果
  • 能根据提交独立性与资源语义区分 NESTED 和 REQUIRES_NEW

NESTED 的核心语义

当调用链已经存在事务时,Propagation.NESTED 的典型 JDBC 语义是在当前物理事务中创建保存点,而不是开启一个可独立提交的新事务。嵌套方法成功返回时不会单独提交;嵌套方法按回滚规则失败时,事务拦截器可以回滚到保存点,再把控制权交还给外层事务。

因此,NESTED 解决的是同一个物理事务中的局部回退。即使嵌套部分已经成功结束,只要外层事务最终回滚,其修改仍会一起回滚。反过来,如果调用时根本没有现有事务,NESTED 会像普通事务一样启动一个事务,此时也不存在“局部回滚到外层保存点”的意义。

NESTED 与保存点的事务关系

用真实代理调用验证局部回滚

下面让外层 OrderService 调用另一个 Spring Bean OrderAddonService。这样 enrichOrder() 会经过事务代理,NESTED 传播行为才有机会生效。示例还显式使用 DataSourceTransactionManager,并在执行前检查它是否允许嵌套事务、JDBC 驱动是否声明支持保存点。

示例假设项目已引入 spring-boot-starter-jdbc 与 H2 JDBC 驱动,并由 Spring Boot 创建内存数据源。

java
import java.sql.Connection;

import javax.sql.DataSource;

import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

@SpringBootApplication
@EnableTransactionManagement
public class NestedDemoApplication {

    public static void main(String[] args) {
        SpringApplication.run(NestedDemoApplication.class, args);
    }

    @Bean
    PlatformTransactionManager transactionManager(DataSource dataSource) {
        DataSourceTransactionManager manager =
                new DataSourceTransactionManager(dataSource);
        manager.setNestedTransactionAllowed(true);
        return manager;
    }

    @Bean
    OrderAddonService orderAddonService(JdbcTemplate jdbcTemplate) {
        return new OrderAddonService(jdbcTemplate);
    }

    @Bean
    OrderService orderService(
            JdbcTemplate jdbcTemplate,
            OrderAddonService addonService) {
        return new OrderService(jdbcTemplate, addonService);
    }

    @Bean
    CommandLineRunner demo(
            DataSource dataSource,
            JdbcTemplate jdbcTemplate,
            PlatformTransactionManager transactionManager,
            OrderService orderService) {
        return args -> {
            DataSourceTransactionManager manager =
                    (DataSourceTransactionManager) transactionManager;

            try (Connection connection = dataSource.getConnection()) {
                System.out.println(
                        "transactionManager=" + manager.getClass().getSimpleName());
                System.out.println(
                        "nestedTransactionAllowed=" + manager.isNestedTransactionAllowed());
                System.out.println(
                        "supportsSavepoints="
                                + connection.getMetaData().supportsSavepoints());
            }

            jdbcTemplate.execute(
                    "create table orders (id bigint primary key, status varchar(20))");
            jdbcTemplate.execute(
                    "create table order_addon (order_id bigint, note varchar(50))");

            orderService.createOrder(1001L);

            Integer orders = jdbcTemplate.queryForObject(
                    "select count(*) from orders", Integer.class);
            Integer addons = jdbcTemplate.queryForObject(
                    "select count(*) from order_addon", Integer.class);

            System.out.println("orders=" + orders);
            System.out.println("order_addon=" + addons);
        };
    }

    public static class OrderService {
        private final JdbcTemplate jdbcTemplate;
        private final OrderAddonService addonService;

        OrderService(
                JdbcTemplate jdbcTemplate,
                OrderAddonService addonService) {
            this.jdbcTemplate = jdbcTemplate;
            this.addonService = addonService;
        }

        @Transactional
        public void createOrder(long orderId) {
            jdbcTemplate.update(
                    "insert into orders(id, status) values (?, ?)",
                    orderId,
                    "CREATED");

            try {
                // 调用另一个 Spring Bean,确保 NESTED 方法经过事务代理。
                addonService.enrichOrder(orderId);
            } catch (IllegalStateException ex) {
                System.out.println("附加操作回滚,订单主流程继续");
            }
        }
    }

    public static class OrderAddonService {
        private final JdbcTemplate jdbcTemplate;

        OrderAddonService(JdbcTemplate jdbcTemplate) {
            this.jdbcTemplate = jdbcTemplate;
        }

        @Transactional(propagation = Propagation.NESTED)
        public void enrichOrder(long orderId) {
            jdbcTemplate.update(
                    "insert into order_addon(order_id, note) values (?, ?)",
                    orderId,
                    "gift-wrap");

            // RuntimeException 让嵌套事务按默认规则回滚到保存点。
            throw new IllegalStateException("附加信息写入失败");
        }
    }
}

预期输出

text
transactionManager=DataSourceTransactionManager
nestedTransactionAllowed=true
supportsSavepoints=true
附加操作回滚,订单主流程继续
orders=1
order_addon=0

前三行先确认本例实际采用的事务管理器和驱动具备保存点前提;后两行数据结果再验证行为:外层 orders 写入提交,而保存点之后的 order_addon 写入被撤销。这里的关键不是“捕获异常就能继续”,而是异常先离开 enrichOrder(),让 NESTED 的事务拦截器完成回滚到保存点,之后才由外层捕获。

如果把 enrichOrder() 放回 OrderService 并用 this.enrichOrder() 自调用,默认代理模式下不会再次经过事务拦截器,NESTED 保存点就不会按这个调用点创建。这样的代码即使最终输出看似正常,也不能作为 NESTED 已生效的证据。

NESTED 与 REQUIRES_NEW 的区别

两者都可能出现“内部失败后外层继续”的现象,但不能仅凭这个现象选择传播级别。真正需要判断的是:内部工作是否仍属于外层最终提交,以及是否需要独立的物理事务边界。

对比项 NESTED REQUIRES_NEW
物理事务 已有外层事务时通常仍是同一个 挂起外层后开启独立事务
内部回滚 回滚到保存点 回滚整个新事务
内部提交 不能脱离外层独立提交 可以独立提交
外层最终回滚 嵌套修改也会回滚 已提交的新事务通常不受影响
JDBC 资源 通常复用外层连接 单数据源场景通常需要额外连接
典型用途 同一业务事务中的可容忍局部失败 必须与外层提交结果解耦的操作

若内部结果必须服从外层最终提交,同时希望某一段失败时只撤销该段,可以考虑 NESTED。若内部操作必须拥有独立提交结果,例如确实要求即使外层回滚也保留的记录,则更接近 REQUIRES_NEW。后者还要评估连接池容量,因为外层事务挂起期间通常仍占用原连接。

使用前确认支持边界

NESTED 是否可用取决于实际事务管理器和底层资源。对于 JDBC,DataSourceTransactionManager 可以借助 JDBC Savepoint 实现嵌套事务,但仍应检查 nestedTransactionAllowed 和驱动的保存点能力。若使用 JPA、JTA 或其他事务管理器,不能只看到 Propagation.NESTED 注解就假定行为完全相同,应针对实际事务栈做验证。

还要检查异常与回滚规则。只有嵌套调用真的触发保存点回滚,外层又明确处理该失败,并且外层事务没有因其他原因被标记为 rollback-only,才可能得到“局部失败、外层继续”的结果。被检查异常、手工设置 rollback-only 或更外层异常继续传播,都可能改变最终结果。

实际选择时可以依次回答三个问题:当前是否已有外层事务,实际事务技术栈能否可靠创建保存点,内部结果是否必须服从外层最终提交。只有这些条件与业务语义一致时,NESTED 才是清晰且可验证的选择。

按自己的节奏,确认真正理解。

目录与阅读设置

记录一个想法

理解 NESTED 与保存点

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通