分布式事务新方案：Saga 与 TCC 在 Java 生态的融合实践

分布式事务是微服务架构中的核心挑战之一。随着微服务架构的普及，传统的两阶段提交（2PC）协议已无法满足现代应用对性能和可用性的要求。Saga模式和TCC（Try-Confirm-Cancel）模式作为两种重要的分布式事务解决方案，在Java生态中得到了广泛应用。本文将深入探讨这两种模式的原理、实现以及在实际项目中的融合实践。

分布式事务的挑战

在分布式系统中，事务跨越多个服务和数据源，传统的ACID事务模型面临以下挑战：

• 性能问题：分布式锁和协调开销大
• 可用性问题：单点故障影响整个系统
• 扩展性问题：难以水平扩展

Saga模式详解

基本原理

Saga模式将一个分布式事务分解为一系列本地事务，每个本地事务都有对应的补偿事务。如果某个步骤失败，Saga会执行之前所有成功步骤的补偿事务来回滚。

// Saga模式基础实现
public class SagaOrchestrator {
   
    private final List<SagaStep> steps;
    private final List<SagaStep> executedSteps;

    public void execute() {
   
        for (int i = 0; i < steps.size(); i++) {
   
            SagaStep step = steps.get(i);
            try {
   
                step.execute();
                executedSteps.add(step);
            } catch (Exception e) {
   
                rollbackExecutedSteps();
                throw new SagaExecutionException("Saga execution failed", e);
            }
        }
    }

    private void rollbackExecutedSteps() {
   
        Collections.reverse(executedSteps);
        for (SagaStep step : executedSteps) {
   
            step.compensate();
        }
    }
}

Saga模式实现策略

1. 编排式Saga

编排式Saga使用一个中央协调器来管理事务流程：

public class OrderSagaOrchestrator {
   
    private final OrderService orderService;
    private final PaymentService paymentService;
    private final InventoryService inventoryService;

    public void processOrder(OrderRequest request) {
   
        // 预留库存
        inventoryService.reserve(request.getProductId(), request.getQuantity());

        try {
   
            // 处理支付
            PaymentResult paymentResult = paymentService.charge(
                request.getCustomerId(), 
                request.getAmount()
            );

            // 创建订单
            Order order = orderService.createOrder(request);

            // 确认支付
            paymentService.confirm(paymentResult.getPaymentId());

            // 确认库存
            inventoryService.confirm(request.getProductId(), request.getQuantity());

        } catch (Exception e) {
   
            // 执行补偿操作
            handleCompensation(request);
            throw e;
        }
    }

    private void handleCompensation(OrderRequest request) {
   
        try {
   
            inventoryService.cancelReservation(request.getProductId(), request.getQuantity());
        } catch (Exception e) {
   
            // 记录补偿失败，可能需要人工介入
            log.error("Compensation failed for inventory reservation", e);
        }
    }
}

2. 参与者驱动式Saga

参与者驱动式Saga通过事件驱动的方式协调各个服务：

// 订单服务事件处理器
@Component
public class OrderSagaEventHandler {
   

    @EventListener
    public void handlePaymentConfirmed(PaymentConfirmedEvent event) {
   
        // 更新订单状态为已支付
        orderRepository.updateStatus(event.getOrderId(), OrderStatus.PAID);
    }

    @EventListener
    public void handlePaymentFailed(PaymentFailedEvent event) {
   
        // 取消订单
        orderRepository.updateStatus(event.getOrderId(), OrderStatus.CANCELLED);

        // 发布库存释放事件
        eventPublisher.publishEvent(new InventoryReleaseEvent(event.getOrderId()));
    }
}

Sage示例状态图

TCC模式详解

基本原理

TCC（Try-Confirm-Cancel）模式是一种基于补偿的分布式事务模式，包含三个阶段：

• Try：预留资源，检查业务规则
• Confirm：确认执行，真正使用资源
• Cancel：取消执行，释放预留资源
  

// TCC模式基础接口
public interface TccAction {
   
    boolean tryAction(String txId, Object... params);
    boolean confirmAction(String txId);
    boolean cancelAction(String txId);
}

TCC实现示例

// 库存TCC实现
public class InventoryTccAction implements TccAction {
   
    private final InventoryRepository inventoryRepository;
    private final ReservationRepository reservationRepository;

    @Override
    public boolean tryAction(String txId, Object... params) {
   
        String productId = (String) params[0];
        int quantity = (Integer) params[1];

        // 检查库存是否充足
        int available = inventoryRepository.getAvailableQuantity(productId);
        if (available < quantity) {
   
            return false; // 库存不足
        }

        // 预留库存
        reservationRepository.reserve(txId, productId, quantity);
        inventoryRepository.reserveQuantity(productId, quantity);

        return true;
    }

    @Override
    public boolean confirmAction(String txId) {
   
        Reservation reservation = reservationRepository.findByTxId(txId);
        if (reservation == null) {
   
            return false;
        }

        // 确认预留，减少可用库存
        inventoryRepository.confirmReservation(
            reservation.getProductId(), 
            reservation.getQuantity()
        );

        // 删除预留记录
        reservationRepository.deleteByTxId(txId);
        return true;
    }

    @Override
    public boolean cancelAction(String txId) {
   
        Reservation reservation = reservationRepository.findByTxId(txId);
        if (reservation == null) {
   
            return false;
        }

        // 释放预留库存
        inventoryRepository.releaseReservation(
            reservation.getProductId(), 
            reservation.getQuantity()
        );

        // 删除预留记录
        reservationRepository.deleteByTxId(txId);
        return true;
    }
}

Saga与TCC的融合实践

混合架构设计

在实际应用中，可以将Saga和TCC模式结合使用，发挥各自优势：

public class HybridTransactionManager {
   
    private final SagaOrchestrator sagaOrchestrator;
    private final TccTransactionManager tccManager;

    public TransactionResult executeHybridTransaction(TransactionRequest request) {
   
        // 使用TCC处理核心业务
        String tccTxId = tccManager.begin();

        try {
   
            // 核心业务使用TCC
            boolean inventoryResult = tccManager.execute(
                "inventory", 
                tccTxId, 
                request.getProductId(), 
                request.getQuantity()
            );

            boolean paymentResult = tccManager.execute(
                "payment", 
                tccTxId, 
                request.getCustomerId(), 
                request.getAmount()
            );

            if (!inventoryResult || !paymentResult) {
   
                tccManager.cancel(tccTxId);
                return TransactionResult.FAILED;
            }

            // 非核心业务使用Saga
            sagaOrchestrator.executeAdditionalSteps(request, tccTxId);

            // 确认TCC事务
            tccManager.confirm(tccTxId);
            return TransactionResult.SUCCESS;

        } catch (Exception e) {
   
            tccManager.cancel(tccTxId);
            sagaOrchestrator.rollbackAdditionalSteps(request);
            return TransactionResult.FAILED;
        }
    }
}

事务状态管理

实现事务状态的持久化和恢复：

// 事务状态实体
public class TransactionState {
   
    private String txId;
    private TransactionStatus status;
    private List<StepState> stepStates;
    private Instant createdAt;
    private Instant lastModified;

    // Getters and setters
}

// 事务状态管理器
@Component
public class TransactionStateManager {
   
    private final TransactionStateRepository repository;

    public void saveState(TransactionState state) {
   
        repository.save(state);
    }

    public TransactionState loadState(String txId) {
   
        return repository.findById(txId);
    }

    public void updateStepStatus(String txId, int stepIndex, StepStatus status) {
   
        TransactionState state = loadState(txId);
        state.getStepStates().get(stepIndex).setStatus(status);
        saveState(state);
    }
}

Java生态中的实现框架

Seata框架

Seata是阿里巴巴开源的分布式事务解决方案，支持AT、TCC、SAGA等多种模式：

// Seata TCC实现
@GlobalTransactional
public void businessMethod() {
   
    // 业务逻辑
    tccService.prepare();
    // 其他业务操作
}

// Seata SAGA实现
SagaTemplate sagaTemplate = new SagaTemplate();
sagaTemplate.startExecution(sagaDefinition);

Apache ServiceComb Pack

Apache ServiceComb Pack提供了基于事件溯源的分布式事务解决方案：

// 使用ServiceComb Pack
@Compensable
public String doBusiness() {
   
    // 业务逻辑
    return "result";
}

@Compensation
public void compensateDoBusiness() {
   
    // 补偿逻辑
}

性能优化策略

异步处理

将补偿操作异步化以提高性能：

public class AsyncCompensationManager {
   
    private final ExecutorService compensationExecutor;

    public CompletableFuture<Void> asyncCompensate(List<CompensationStep> steps) {
   
        return CompletableFuture.runAsync(() -> {
   
            for (CompensationStep step : steps) {
   
                try {
   
                    step.execute();
                } catch (Exception e) {
   
                    handleCompensationFailure(step, e);
                }
            }
        }, compensationExecutor);
    }
}

重试机制

实现智能重试机制：

public class RetryableTransaction {
   
    private final RetryTemplate retryTemplate;

    public TransactionResult executeWithRetry(TransactionRequest request) {
   
        return retryTemplate.execute(context -> {
   
            return executeTransaction(request);
        });
    }
}

监控和运维

指标监控

建立全面的监控体系：

故障处理

实现故障自动恢复和人工干预机制：

@Component
public class TransactionRecoveryService {
   

    public void recoverFailedTransactions() {
   
        List<TransactionState> failedTransactions = 
            stateRepository.findByStatus(TransactionStatus.FAILED);

        for (TransactionState tx : failedTransactions) {
   
            try {
   
                retryFailedTransaction(tx);
            } catch (Exception e) {
   
                log.error("Recovery failed for transaction: " + tx.getTxId(), e);
                // 标记为需要人工处理
                markForManualIntervention(tx.getTxId());
            }
        }
    }
}

最佳实践

模式选择指南

设计原则

1. 最小化分布式事务范围：尽量将事务限制在最小必要范围内
2. 幂等性设计：确保补偿操作和确认操作是幂等的
3. 超时机制：为每个步骤设置合理的超时时间
4. 监控先行：在设计阶段就考虑监控和运维需求

总结

Saga和TCC模式各有优势，Saga模式适合处理长时间运行的复杂业务流程，而TCC模式在性能和一致性方面表现更佳。在实际项目中，可以根据具体业务需求选择合适的模式，或者采用混合架构将两种模式结合使用。通过合理的架构设计和完善的监控体系，可以构建稳定、高效的分布式事务解决方案。

参考文献

Seata文档