Spring事务扩展点-TransactionSynchronization

什么是TransactionSynchronization

Spring 提供的 TransactionSynchronization 是一个非常重要的扩展点，它允许开发者参与到 Spring 管理的事务生命周期中的特定阶段，从而能够在事务开始前、事务结束（提交或回滚）前后执行自定义的操作。这个接口主要用来实现事务相关的同步行为，帮助开发者实现在事务边界上进行资源清理、刷新缓存、发送通知等操作。

以下是 TransactionSynchronization 接口的主要特征和方法：

1. 主要方法：

   • void afterCommit()：在事务成功提交后执行。
   • void afterCompletion(int status)：无论事务是否正常完成（提交或回滚），都会执行此方法。status 参数可以用于判断事务的最终状态。
   • void beforeCommit(boolean readOnly)：在事务准备提交前执行，readOnly 参数指示事务是否为只读事务。
   • void beforeCompletion()：在事务完成前（无论提交还是回滚）执行。

2. 注册同步器：
   开发者可以通过 TransactionSynchronizationManager 注册 TransactionSynchronization 实现类，这样在相应事务阶段，Spring 就会自动调用对应的方法。

3. 应用场景：

   • 资源清理：如关闭数据库连接、释放文件句柄等。
   • 同步缓存：在事务结束时更新缓存中的数据。
   • 事件通知：事务结束后触发其他服务的后续操作。
   • 日志记录：记录事务开始和结束的时间点及结果。

4. 与事务管理器配合：
   Spring 的事务管理器会在事务的生命周期中维护一个同步器列表，当事务开始、准备提交、完成时，会按照顺序依次调用所有已注册的同步器的方法。

5. Ordered 接口：
   若要控制同步器的执行顺序，可以实现 Ordered 接口，从而让 Spring 按照优先级顺序执行同步器。

怎么用？

使用Spring TransactionSynchronization 接口的伪代码示例，假设我们有一个需求：在事务提交后发送MQ消息，而在事务回滚时不发送消息。

import org.springframework.transaction.support.TransactionSynchronization;
import org.springframework.transaction.support.TransactionSynchronizationManager;

public class TransactionalMessageSender implements TransactionSynchronization {

    private final MessageProducer messageProducer;
    private final MyOrder order; // 假设这是需要在事务结束后发送消息的订单对象

    public TransactionalMessageSender(MessageProducer messageProducer, MyOrder order) {
        this.messageProducer = messageProducer;
        this.order = order;
    }

    @Override
    public void afterCommit() {
        // 事务成功提交后发送消息
        String messagePayload = buildMessagePayload(order);
        messageProducer.sendMessage(messagePayload);
        System.out.println("事务提交后，成功发送了订单变更消息");
    }

    @Override
    public void afterCompletion(int status) {
        // 根据事务完成状态进行不同的操作
        if (status == STATUS_COMMITTED) {
            // 此处代码实际上在afterCommit方法中已经处理，这里仅作演示
            // 在实际应用中可以根据需要在此处添加其他清理工作
        } else if (status == STATUS_ROLLED_BACK) {
            System.out.println("事务已回滚，取消发送订单变更消息");
        }
    }

    // 其他方法如beforeCommit和beforeCompletion在这里省略，根据实际需求决定是否实现

    // 注册该同步器到当前事务上下文中
    public static void registerToCurrentTransaction(MyOrder order, MessageProducer messageProducer) {
        TransactionSynchronizationManager.registerSynchronization(new TransactionalMessageSender(messageProducer, order));
    }

    // ... 其他辅助方法如buildMessagePayload等
}

在你的业务逻辑代码中，当需要在事务结束后发送消息时，可以如下方式注册 TransactionalMessageSender：

@Service
public class OrderService {

    private final MessageProducer messageProducer;

    public OrderService(MessageProducer messageProducer) {
        this.messageProducer = messageProducer;
    }

    @Transactional
    public void processOrder(Order order) {
        // 处理订单相关业务逻辑...

        // 在事务结束时发送消息
        TransactionalMessageSender.registerToCurrentTransaction(order, messageProducer);
    }
}

这样，在processOrder方法的事务成功提交后，会自动调用afterCommit方法发送消息；如果事务回滚，则不会调用afterCommit，而是调用afterCompletion方法，可以在此处进行相应的清理或取消发送消息操作。

一些弊端

1. 代码复杂度和耦合度上升：使用 TransactionSynchronization 会深度介入事务管理，可能导致代码结构复杂，增加耦合度。

2. 依赖性强：高度依赖Spring事务管理机制，更换框架时可能需要重写这部分逻辑。

3. 调试和错误处理难度：事务结束后的回调逻辑分布在多个方法中，出现问题时定位困难。

4. 并发控制复杂：如果有多个同步器需按特定顺序执行，需要额外处理排序逻辑。

5. 性能影响：如果同步器中有耗时操作，可能延迟事务结束时间，影响系统性能。