如何回滚JPA嵌套事务？当method5发生异常时需同时回滚method4的变更

先给你理清楚当前代码的核心问题：你给method4和method5都加了@Transactional(TxType.REQUIRES_NEW)，这个传播行为的意思是每个方法都会启动一个完全独立的新事务。method4执行完之后，它的事务会立刻提交到数据库，所以哪怕后面method5抛出异常，method4已经做的变更早就落地了，根本没法回滚。

要实现你要的效果——method5异常时把method4的变更也一起回滚，得调整事务的管理方式，下面给你两种实用的解决方案：

方案一：调整事务传播行为（最简单的方式） #

把method4和method5的事务传播类型改成默认的REQUIRED（可以直接去掉REQUIRES_NEW注解），这样它们会自动加入到method2的顶层事务里。当method5抛出异常时，整个顶层事务会触发回滚，method4的变更自然也会被撤销。

修改后的代码示例：

@Singleton
public class Case {
    @Inject
    CaseService caseService;

    @Transactional // 默认就是REQUIRED，开启顶层事务
    void method2(){
        var value = caseService.method4();
        caseService.method5(value);
        // 只要method5抛异常，这里的整个事务都会回滚
    }
}

@Singleton
public class CaseService {
    // 去掉REQUIRES_NEW，加入外层的method2事务
    public String method4(){
        // 这里的数据库操作属于method2的事务
        return "some";
    }

    // 同样去掉REQUIRES_NEW，共用外层事务
    public void method5(String value){
        // 模拟抛出异常，触发整个事务回滚
        throw new RuntimeException("执行出错了");
    }
}

⚠️ 注意：如果你的method4需要在单独被调用时也能独立提交事务，那这个方案就不适用，得看下面的编程式事务方案。

方案二：编程式事务手动控制（更灵活的方式） #

如果必须保留method4和method5在单独调用时的独立事务能力，那可以在method2里手动管理事务边界，把两个方法的操作纳入同一个事务中。

这里以Jakarta EE的UserTransaction为例，给你写个示例：

@Singleton
public class Case {
    @Inject
    CaseService caseService;
    @Inject
    UserTransaction ut;

    void method2(){
        try {
            ut.begin(); // 手动开启顶层事务

            // 调用不带事务注解的内部方法，避免开启新事务
            var value = caseService.method4WithoutTx(); 
            caseService.method5WithoutTx(value);

            ut.commit(); // 所有操作正常才提交
        } catch (Exception e) {
            try {
                ut.rollback(); // 任何异常都回滚整个事务
            } catch (Exception rollbackEx) {
                rollbackEx.printStackTrace();
            }
            throw new RuntimeException("事务执行失败", e);
        }
    }
}

@Singleton
public class CaseService {
    // 供单独调用的方法，保留REQUIRES_NEW
    @Transactional(Transactional.TxType.REQUIRES_NEW)
    public String method4(){
        return method4WithoutTx();
    }

    // 内部无事务的核心逻辑，供外层事务调用
    public String method4WithoutTx(){
        // 数据库操作逻辑
        return "some";
    }

    // 同样，单独调用时用这个带事务的方法
    @Transactional(Transactional.TxType.REQUIRES_NEW)
    public void method5(String value){
        method5WithoutTx(value);
    }

    // 无事务的核心逻辑
    public void method5WithoutTx(String value){
        // 模拟异常，触发回滚
        throw new RuntimeException("执行出错了");
    }
}

这种方式的好处是兼顾两种场景：单独调用method4或method5时，它们还是独立事务；在method2里调用时，就共用同一个事务，异常时一起回滚。

关键要点总结 #

• REQUIRES_NEW是强制开新事务，和外层事务完全隔离，执行完就提交，所以外层异常管不到它。
• 要让多个操作一起回滚，必须让它们处于同一个事务里，要么用声明式事务的REQUIRED传播，要么手动编程控制事务边界。
• 如果需要方法同时支持独立和嵌套事务，可以把核心逻辑拆成无事务的内部方法，再套一层带事务注解的对外方法。

内容的提问来源于stack exchange，提问作者2787184