Spring 事务传播行为七种解析#

@Service
public class TransferService {

    @Transactional
    public void transfer(String fromAccount, String toAccount, BigDecimal amount) {
        // 外层开启事务
        accountService.deduct(fromAccount, amount);      // ✅ 加入外层事务
        accountService.add(toAccount, amount);            // ✅ 加入外层事务
        notificationService.sendNotify(toAccount);         // ✅ 加入外层事务
    }
}

@Service
public class AccountService {

    @Transactional(propagation = Propagation.REQUIRED)
    public void deduct(String account, BigDecimal amount) {
        // 复用外层事务，任何一步失败全部回滚
        accountMapper.deduct(account, amount);
    }

    @Transactional(propagation = Propagation.REQUIRED)
    public void add(String account, BigDecimal amount) {
        accountMapper.add(account, amount);
    }
}

@Transactional
public void outerMethod() {
    // 外层开启事务
    innerMethod(); // REQUIRES_NEW，创建新的事务
}

public void noTransactionMethod() {
    // ⚠️ 外层无事务
    innerMethod(); // REQUIRED，自动创建新事务
}

@Transactional(propagation = Propagation.REQUIRED)
public void innerMethod() {
    // REQUIRED 保证它一定在事务中运行
}

@Service
public class OrderService {

    @Transactional
    public void createOrder(Order order) {
        // 1. 保存订单（主业务，失败要回滚）
        orderMapper.insert(order);

        // 2. 扣减库存
        stockService.reduce(order.getSkuId(), order.getQuantity());

        // 3. 发送通知（REQUIRES_NEW，独立事务）
        //    即使主事务回滚，消息也要发出去
        messageService.sendOrderCreated(order.getId());
    }
}

@Service
public class MessageService {

    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void sendOrderCreated(Long orderId) {
        // 独立事务，不受 OrderService 的事务影响
        // 如果主事务回滚，这条消息仍然会发送
        messageMapper.insert(orderId, "ORDER_CREATED");
    }
}

public void noTransactionOuter() {
    // ⚠️ 外层无事务
    reRequiresNewMethod(); // REQUIRES_NEW 会创建一个新的事务
}

@Transactional
public void batchImport(List<Record> records) {
    int count = 0;
    for (Record record : records) {
        try {
            importOne(record); // NESTED，每条记录一个保存点
            count++;
        } catch (Exception e) {
            // ⚠️ 只回滚到当前保存点，不影响已成功的记录
            log.warn("第{}条记录导入失败，继续处理", count + 1);
        }
    }
    log.info("成功导入 {} 条记录", count);
}

@Transactional(propagation = Propagation.NESTED)
public void importOne(Record record) {
    // 如果这里抛异常，只回滚这一条
    // 不会影响 batchImport 中已经成功导入的其他记录
    recordMapper.insert(record);
}

// REQUIRES_NEW 的执行流程（伪代码）
@Transactional
public void outer() {
    // 开启事务A
    System.out.println("事务A开始");
    inner_REQUIRES_NEW(); // ⚠️ 事务A被挂起
    // 事务A被恢复（inner提交后才恢复）
    System.out.println("事务A继续");
}

@Transactional(propagation = Propagation.REQUIRES_NEW)
public void inner_REQUIRES_NEW() {
    // 开启事务B（与事务A完全独立）
    System.out.println("事务B开始和提交");
    // 事务B提交后，事务A恢复
}

// 输出：事务A开始 → 事务B开始和提交 → 事务A继续
//      如果 inner 抛异常回滚，事务A继续执行（事务B已提交，不受影响）

// NESTED 的执行流程（伪代码）
@Transactional
public void outer() {
    // 开启事务A（也是事务B的事务，因为是嵌套）
    System.out.println("事务开始，Savepoint创建");
    inner_NESTED(); // 创建Savepoint
    // ⚠️ inner回滚到Savepoint，但外层事务不全部回滚
    System.out.println("外层继续执行");
}

@Transactional(propagation = Propagation.NESTED)
public void inner_NESTED() {
    // 与外层同一物理事务，但有Savepoint隔离
    System.out.println("嵌套事务执行");
    // 如果这里抛异常，只回滚到Savepoint
}

// 输出：事务开始，Savepoint创建 → 嵌套事务执行
//      如果 inner 抛异常，外层收到异常，但如果外层捕获了
//      外层仍然可以继续执行（因为只回滚到Savepoint）

@Transactional(propagation = Propagation.SUPPORTS)
public User getUser(Long id) {
    // 有外层事务时，加入事务（确保读一致性）
    // 无外层事务时，普通查询（允许脏读等）
    return userMapper.selectById(id);
}

@Transactional(propagation = Propagation.MANDATORY)
public void updateUser(User user) {
    // 确保调用者必须在事务中调用
    // 如果在非事务方法中被调用，直接抛异常
    userMapper.update(user);
}

// 使用方
@Transactional
public void serviceMethod() {
    updateUser(user); // ✅ 正常执行
}

public void nonTransactionMethod() {
    updateUser(user); // ⚠️ 抛 IllegalStateException
}

@Transactional
public void importDataFromThirdParty() {
    // 主业务在事务中
    processMainData();

    // 调用第三方接口，耗时很长
    // ⚠️ 如果这个在事务中运行，会长时间占用数据库连接
    //    导致其他请求超时
    // 用 NOT_SUPPORTED 挂起事务，避免长时间占用连接
    thirdPartyService.syncData(NOT_SUPPORTED);
}