Spring事务面试总在自调用上翻车？4个场景把@Transactional、回滚和传播边界讲清

1. @Transactional 默认是 PROPAGATION_REQUIRED：没有外层事务就新建，有外层事务就加入。
2. Spring 默认用代理模式处理声明式事务，只有经过代理的外部调用才会触发事务拦截。
3. 同一个对象里用 this.xxx() 或隐式自调用，不会再次经过代理；因此内层方法上的 @Transactional 可能完全不生效。
4. 默认情况下，RuntimeException 和 Error 触发回滚，checked exception 不会自动触发回滚。1

场景一：同类自调用，注解为什么像失效了

@Service
public class OrderService {

public void submit(OrderRequest request) {
        createOrder(request); // 同一个对象内部调用
    }

@Transactional
    public void createOrder(OrderRequest request) {
        orderRepository.save(request);
        paymentRepository.createPending(request.orderId());
    }
}

外部对象拿到的是代理引用，外部调用可以触发事务拦截；同一个目标对象内部的 this.createOrder() 不经过代理，所以 createOrder() 上的 @Transactional 不会在这里创建事务。

怎么改，才不是只会背结论

@Transactional
public void submit(OrderRequest request) {
    createOrder(request);
}

@Service
public class OrderAppService {
    private final OrderTxService orderTxService;

public void submit(OrderRequest request) {
        orderTxService.createOrder(request); // 经过另一个 Bean 的代理
    }
}

@Service
public class OrderTxService {
    @Transactional
    public void createOrder(OrderRequest request) {
        orderRepository.save(request);
        paymentRepository.createPending(request.orderId());
    }
}

场景二：抛了异常，为什么数据库还提交了

@Transactional
public void uploadAndSave(File file) throws IOException {
    documentRepository.insert(file.name());
    storageClient.upload(file); // 抛 IOException
}

@Transactional(rollbackFor = IOException.class)
public void uploadAndSave(File file) throws IOException {
    documentRepository.insert(file.name());
    storageClient.upload(file);
}

• rollbackFor 表达的是业务上的回滚边界，不是把所有异常都机械改成回滚。
• 如果方法捕获异常后继续返回成功，事务拦截器看到的可能已经是正常返回；你要先决定失败是否应该让调用方感知，再决定是声明回滚规则、重新抛出异常，还是明确保存失败状态。

默认不是。Spring 默认回滚 RuntimeException 和 Error，checked exception 需要用 rollbackFor 等规则显式配置；最终要按业务原子性决定，而不是只按异常类名套模板。

场景三：内层失败被 catch 了，外层为什么仍然提交不了

@Service
public class OrderAppService {

@Transactional
    public void placeOrder(OrderRequest request) {
        orderRepository.save(request);

try {
            stockService.deduct(request.sku(), request.quantity());
        } catch (RuntimeException ex) {
            log.warn("库存扣减失败", ex);
            // 这里选择继续做其他事情
        }

auditRepository.save("尝试下单");
    }
}

@Service
public class StockService {

@Transactional // 默认 REQUIRED
    public void deduct(String sku, int quantity) {
        stockRepository.decrease(sku, quantity);
        throw new RuntimeException("库存校验失败");
    }
}

• 库存扣减失败就应该让下单失败：让异常继续向外抛，或者在外层按明确的失败状态结束，不要 catch 后伪装成成功。
• 库存失败只是可记录的旁路事件：把旁路记录拆到独立 Bean，再考虑独立事务；不要把「catch 住」误当成「事务恢复了」。
• 只想让外层继续，却仍然希望这次数据库操作提交：必须重新设计事务边界，不能靠同一物理事务里的异常捕获解决。

REQUIRED 不是每个方法各开一笔事务。内层加入外层后，内层的回滚标记会影响同一个物理事务；catch 住 Java 异常，不等于清除了 rollback-only。

场景四：REQUIRES_NEW 不是「嵌套事务」，还会多占资源

@Service
public class OrderAppService {
    private final AuditService auditService;

@Transactional
    public void placeOrder(OrderRequest request) {
        orderRepository.save(request);

try {
            paymentService.charge(request);
        } catch (RuntimeException ex) {
            auditService.record("支付失败", request.orderId());
            throw ex;
        }
    }
}

@Service
public class AuditService {

@Transactional(propagation = Propagation.REQUIRES_NEW)
    public void record(String event, long orderId) {
        auditRepository.save(event, orderId);
    }
}

面试追问，按这个顺序排查

1. 先看入口：调用者拿到的是代理，还是同一个对象里的 this 调用？如果没经过代理，先别讨论传播行为。
2. 再看物理事务：外层有没有事务？内层是默认 REQUIRED，还是明确要求 REQUIRES_NEW / NESTED？
3. 再看异常：抛出的是 checked exception 还是 RuntimeException？异常有没有被 catch？是否配置了 rollbackFor？
4. 最后看资源：独立事务是否需要第二个数据库连接？连接池容量和并发模型能不能承受？

我先确认调用是否经过 Spring 代理。若是同类自调用，@Transactional 和传播属性都可能不生效；若经过代理，再看当前是否已有物理事务。默认 REQUIRED 会加入外层，REQUIRES_NEW 会创建独立事务。最后核对异常类型、回滚规则和连接资源，不能只看到注解就断言一定回滚。

4 个自测问题

• Controller 调用一个未标注事务的方法，而这个方法在同类中调用 @Transactional 方法，事务到底从哪里开始？
• @Transactional 方法抛出 IOException，什么条件下数据库写入会回滚？
• 内层 REQUIRED 方法失败后被外层 catch，为什么外层提交时还可能抛 UnexpectedRollbackException？
• 审计必须独立保留时，为什么要拆成独立 Bean？REQUIRES_NEW 会带来什么连接池风险？

FAQ

@Transactional 写在 private 方法上可以吗？

外层和内层都写 @Transactional，是不是就有两层独立事务？

我把异常 catch 住，再手动返回失败对象，事务会回滚吗？

发布前自查清单

• 我能画出调用者、代理和目标对象之间的路径。
• 我能区分同类自调用与跨 Bean 调用。
• 我能说清 REQUIRED、REQUIRES_NEW、NESTED 对物理事务的影响。
• 我不会把 checked exception 默认回滚当成 Spring 的规则。
• 我能解释 rollback-only 为什么会让外层提交失败。
• 我能把独立事务和连接池资源放在同一个回答里。