@Transactional注解: 多个事务嵌套时，独立事务处理方式

在讲解@Transactional注解的多个事务嵌套时的独立事务处理方式之前，我们先来了解一下@Transactional注解的作用。@Transactional注解是Spring框架中用于声明事务的注解，它可以应用在方法或类级别上。当应用在方法上时，该方法将被包装在一个事务中，当应用在类级别上时，该类中的所有方法都将被包装在一个事务中。

独立事务处理方式

当多个事务嵌套时，独立事务处理方式允许每个事务独立地进行提交或回滚，而不受外部事务的影响。这种方式可以通过在方法上使用@Transactional(propagation = Propagation.REQUIRES_NEW)来实现。下面是一个示例说明：

@Service
public class TransactionalService {

    @Autowired
    private UserRepository userRepository;

    @Transactional
    public void outerTransaction() {
        // 执行一些业务逻辑

        innerTransaction(); // 调用内部事务方法
    }

    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void innerTransaction() {
        // 执行一些业务逻辑

        userRepository.save(new User(\"John\")); // 在内部事务中保存用户
    }
}

在上面的示例中，outerTransaction()方法和innerTransaction()方法都被@Transactional注解修饰。outerTransaction()方法是外部事务方法，innerTransaction()方法是内部事务方法。当outerTransaction()方法被调用时，它会执行一些业务逻辑，然后调用innerTransaction()方法。由于innerTransaction()方法使用了@Transactional(propagation = Propagation.REQUIRES_NEW)注解，它将在一个独立的事务中执行。

这意味着，当innerTransaction()方法被调用时，它将开启一个新的事务，独立于外部事务。如果内部事务成功执行并提交，而外部事务后续发生异常导致回滚，内部事务的提交操作不会被回滚，而是独立地进行提交。

示例说明

让我们通过两个示例来进一步说明独立事务处理方式。

示例一

假设我们有一个订单服务，其中包含两个方法：createOrder()和updateOrderStatus()。createOrder()方法用于创建订单，updateOrderStatus()方法用于更新订单状态。

@Service
public class OrderService {

    @Autowired
    private OrderRepository orderRepository;

    @Transactional
    public void createOrder(Order order) {
        // 创建订单逻辑

        orderRepository.save(order);
    }

    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void updateOrderStatus(Long orderId, String status) {
        // 更新订单状态逻辑

        Order order = orderRepository.findById(orderId);
        order.setStatus(status);
        orderRepository.save(order);
    }
}

在上面的示例中，createOrder()方法和updateOrderStatus()方法都被@Transactional注解修饰。当createOrder()方法被调用时，它会开启一个事务，并将订单保存到数据库中。接着，它调用updateOrderStatus()方法来更新订单状态。由于updateOrderStatus()方法使用了@Transactional(propagation = Propagation.REQUIRES_NEW)注解，它将在一个独立的事务中执行。

这意味着，如果在updateOrderStatus()方法中发生异常导致回滚，createOrder()方法中的事务不会受到影响，订单的创建操作不会被回滚。

示例二

假设我们有一个银行转账服务，其中包含两个方法：transferFunds()和updateAccountBalance()。transferFunds()方法用于转账，updateAccountBalance()方法用于更新账户余额。

@Service
public class TransferService {

    @Autowired
    private AccountRepository accountRepository;

    @Transactional
    public void transferFunds(Long fromAccountId, Long toAccountId, BigDecimal amount) {
        // 转账逻辑

        updateAccountBalance(fromAccountId, amount.negate()); // 从转出账户扣除金额
        updateAccountBalance(toAccountId, amount); // 向转入账户增加金额
    }

    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void updateAccountBalance(Long accountId, BigDecimal amount) {
        // 更新账户余额逻辑

        Account account = accountRepository.findById(accountId);
        account.setBalance(account.getBalance().add(amount));
        accountRepository.save(account);
    }
}

在上面的示例中，transferFunds()方法和updateAccountBalance()方法都被@Transactional注解修饰。当transferFunds()方法被调用时，它会开启一个事务，并执行转账逻辑。接着，它调用updateAccountBalance()方法两次来更新转出账户和转入账户的余额。由于updateAccountBalance()方法使用了@Transactional(propagation = Propagation.REQUIRES_NEW)注解，它将在两个独立的事务中执行。

这意味着，如果在第二次调用updateAccountBalance()方法时发生异常导致回滚，第一次调用updateAccountBalance()方法的事务不会受到影响，转出账户的余额更新操作不会被回滚。

总结起来，独立事务处理方式允许每个事务独立地进行提交或回滚，不受外部事务的影响。这种方式可以通过在方法上使用@Transactional(propagation = Propagation.REQUIRES_NEW)来实现。