Oct 23 2020

微服务架构下的分布式事务解决方案：Saga模式与TCC模式技术选型指南

作者： 绝缘体..   发布： 2020-10-23 16:45   分类： 未分类   阅读：   抢沙发  
 
更多

微服务架构下的分布式事务解决方案：Saga模式与TCC模式技术选型指南

引言

随着微服务架构的普及，分布式系统的复杂性也随之增加。在单体应用中，数据库事务可以轻松保证数据的一致性，但在微服务架构下，一个业务操作可能涉及多个服务的调用，传统的ACID事务已无法满足需求。这就催生了分布式事务的出现，其中Saga模式和TCC模式成为了主流的解决方案。

本文将深入分析这两种模式的实现原理、优缺点以及适用场景，并结合实际代码示例，为企业在技术选型时提供权威参考。

分布式事务的挑战

数据一致性问题

在微服务架构中，每个服务都有自己的数据库，当一个业务流程需要跨多个服务操作时，如何保证数据的一致性成为了一个核心挑战。传统的本地事务无法跨越服务边界，这就需要引入分布式事务机制。

CAP定理的约束

根据CAP定理，在分布式系统中，一致性（Consistency）、可用性（Availability）和分区容错性（Partition tolerance）三者不可兼得。在微服务架构下，网络分区是不可避免的，因此需要在一致性和可用性之间做出权衡。

Saga模式详解

基本概念

Saga模式是一种长事务解决方案，它将一个长事务拆分为多个短事务，每个短事务都有对应的补偿事务。当某个短事务执行失败时，通过执行之前短事务的补偿事务来保证事务的最终一致性。

实现方式

Saga模式有两种主要的实现方式：

1. 事件驱动Saga（Choreography）

在事件驱动的Saga中，每个服务在完成自己的事务后，会发布事件通知其他服务。这种方式去中心化，但复杂度较高。

// 订单服务
@Service
public class OrderService {
    
    @Autowired
    private OrderRepository orderRepository;
    
    @Transactional
    public void createOrder(Order order) {
        // 创建订单
        order.setStatus(OrderStatus.PENDING);
        orderRepository.save(order);
        
        // 发布订单创建事件
        eventPublisher.publish(new OrderCreatedEvent(order.getId(), order.getAmount()));
    }
    
    @EventListener
    @Transactional
    public void handlePaymentSuccess(PaymentSuccessEvent event) {
        Order order = orderRepository.findById(event.getOrderId());
        order.setStatus(OrderStatus.PAID);
        orderRepository.save(order);
        
        // 发布订单支付成功事件
        eventPublisher.publish(new OrderPaidEvent(order.getId()));
    }
    
    @EventListener
    @Transactional
    public void handleInventoryReserved(InventoryReservedEvent event) {
        Order order = orderRepository.findById(event.getOrderId());
        order.setStatus(OrderStatus.CONFIRMED);
        orderRepository.save(order);
    }
    
    // 补偿操作
    @EventListener
    @Transactional
    public void handleOrderCancel(OrderCancelEvent event) {
        Order order = orderRepository.findById(event.getOrderId());
        if (order.getStatus() == OrderStatus.PAID) {
            // 发布退款事件
            eventPublisher.publish(new RefundEvent(order.getId(), order.getAmount()));
        }
        order.setStatus(OrderStatus.CANCELLED);
        orderRepository.save(order);
    }
}

2. 编排Saga（Orchestration）

在编排Saga中，有一个专门的协调器（Saga Orchestrator）来控制整个事务流程，决定何时执行哪个服务的事务。

// Saga协调器
@Component
public class OrderSagaOrchestrator {
    
    @Autowired
    private OrderServiceClient orderService;
    
    @Autowired
    private PaymentServiceClient paymentService;
    
    @Autowired
    private InventoryServiceClient inventoryService;
    
    public void executeOrderSaga(String orderId, BigDecimal amount) {
        try {
            // 步骤1：创建订单
            orderService.createOrder(orderId, amount);
            
            // 步骤2：处理支付
            paymentService.processPayment(orderId, amount);
            
            // 步骤3：预留库存
            inventoryService.reserveInventory(orderId);
            
            // 完成Saga
            orderService.confirmOrder(orderId);
            
        } catch (Exception e) {
            // 执行补偿操作
            compensate(orderId);
            throw e;
        }
    }
    
    private void compensate(String orderId) {
        try {
            // 撤销库存预留
            inventoryService.releaseInventory(orderId);
        } catch (Exception e) {
            log.error("Failed to compensate inventory", e);
        }
        
        try {
            // 处理退款
            paymentService.refund(orderId);
        } catch (Exception e) {
            log.error("Failed to compensate payment", e);
        }
        
        try {
            // 取消订单
            orderService.cancelOrder(orderId);
        } catch (Exception e) {
            log.error("Failed to compensate order", e);
        }
    }
}

状态管理

Saga模式需要维护事务的状态，通常使用状态机来管理。

public enum SagaState {
    STARTED,
    ORDER_CREATED,
    PAYMENT_PROCESSED,
    INVENTORY_RESERVED,
    COMPLETED,
    COMPENSATING,
    FAILED
}

@Entity
public class SagaInstance {
    @Id
    private String sagaId;
    
    @Enumerated(EnumType.STRING)
    private SagaState state;
    
    private String currentStep;
    
    @ElementCollection
    private List<String> executedSteps = new ArrayList<>();
    
    @ElementCollection
    private List<String> compensationSteps = new ArrayList<>();
    
    // getters and setters
}

TCC模式详解

基本概念

TCC（Try-Confirm-Cancel）模式是一种业务层面的分布式事务解决方案。它要求每个业务服务提供三个操作：

  • Try：尝试执行业务，预留必要的资源
  • Confirm：确认执行，真正提交业务
  • Cancel：取消执行，释放预留的资源

实现原理

// TCC接口定义
public interface TccAction {
    /**
     * Try阶段：预留资源
     */
    boolean prepare(BusinessActionContext actionContext);
    
    /**
     * Confirm阶段：确认提交
     */
    boolean commit(BusinessActionContext actionContext);
    
    /**
     * Cancel阶段：回滚操作
     */
    boolean rollback(BusinessActionContext actionContext);
}

// 转账服务实现
@Service
public class TransferTccAction implements TccAction {
    
    @Autowired
    private AccountService accountService;
    
    @Override
    @TccTransaction(confirmMethod = "confirmTransfer", cancelMethod = "cancelTransfer")
    public boolean prepare(BusinessActionContext actionContext) {
        String fromAccount = (String) actionContext.getActionContext("fromAccount");
        String toAccount = (String) actionContext.getActionContext("toAccount");
        BigDecimal amount = (BigDecimal) actionContext.getActionContext("amount");
        
        // 预留转账资源
        return accountService.reserveTransfer(fromAccount, toAccount, amount);
    }
    
    public boolean confirmTransfer(BusinessActionContext actionContext) {
        String fromAccount = (String) actionContext.getActionContext("fromAccount");
        String toAccount = (String) actionContext.getActionContext("toAccount");
        BigDecimal amount = (BigDecimal) actionContext.getActionContext("amount");
        
        // 确认转账
        return accountService.confirmTransfer(fromAccount, toAccount, amount);
    }
    
    public boolean cancelTransfer(BusinessActionContext actionContext) {
        String fromAccount = (String) actionContext.getActionContext("fromAccount");
        String toAccount = (String) actionContext.getActionContext("toAccount");
        BigDecimal amount = (BigDecimal) actionContext.getActionContext("amount");
        
        // 取消转账
        return accountService.cancelTransfer(fromAccount, toAccount, amount);
    }
}

账户服务的具体实现

@Service
public class AccountServiceImpl implements AccountService {
    
    @Autowired
    private AccountRepository accountRepository;
    
    @Override
    public boolean reserveTransfer(String fromAccount, String toAccount, BigDecimal amount) {
        try {
            Account from = accountRepository.findByAccountNumber(fromAccount);
            Account to = accountRepository.findByAccountNumber(toAccount);
            
            // 检查余额
            if (from.getBalance().compareTo(amount) < 0) {
                return false;
            }
            
            // 预留资金
            from.setReservedAmount(from.getReservedAmount().add(amount));
            from.setBalance(from.getBalance().subtract(amount));
            
            // 预留收款
            to.setReservedAmount(to.getReservedAmount().add(amount));
            
            accountRepository.save(from);
            accountRepository.save(to);
            
            return true;
        } catch (Exception e) {
            log.error("Failed to reserve transfer", e);
            return false;
        }
    }
    
    @Override
    public boolean confirmTransfer(String fromAccount, String toAccount, BigDecimal amount) {
        try {
            Account from = accountRepository.findByAccountNumber(fromAccount);
            Account to = accountRepository.findByAccountNumber(toAccount);
            
            // 确认转账
            from.setReservedAmount(from.getReservedAmount().subtract(amount));
            to.setReservedAmount(to.getReservedAmount().subtract(amount));
            to.setBalance(to.getBalance().add(amount));
            
            accountRepository.save(from);
            accountRepository.save(to);
            
            return true;
        } catch (Exception e) {
            log.error("Failed to confirm transfer", e);
            return false;
        }
    }
    
    @Override
    public boolean cancelTransfer(String fromAccount, String toAccount, BigDecimal amount) {
        try {
            Account from = accountRepository.findByAccountNumber(fromAccount);
            Account to = accountRepository.findByAccountNumber(toAccount);
            
            // 取消转账
            from.setReservedAmount(from.getReservedAmount().subtract(amount));
            from.setBalance(from.getBalance().add(amount));
            
            to.setReservedAmount(to.getReservedAmount().subtract(amount));
            
            accountRepository.save(from);
            accountRepository.save(to);
            
            return true;
        } catch (Exception e) {
            log.error("Failed to cancel transfer", e);
            return false;
        }
    }
}

消息队列补偿模式

基本原理

消息队列补偿模式通过消息队列来保证事务的最终一致性。当业务操作成功后，发送消息到队列，消费者接收到消息后执行相应的操作。

@Service
public class OrderProcessingService {
    
    @Autowired
    private RabbitTemplate rabbitTemplate;
    
    @Transactional
    public void processOrder(Order order) {
        // 创建订单
        orderRepository.save(order);
        
        // 发送订单创建消息
        OrderCreatedMessage message = new OrderCreatedMessage();
        message.setOrderId(order.getId());
        message.setAmount(order.getAmount());
        message.setCustomerId(order.getCustomerId());
        
        rabbitTemplate.convertAndSend("order.created", message);
    }
    
    @RabbitListener(queues = "order.created")
    @Transactional
    public void handleOrderCreated(OrderCreatedMessage message) {
        try {
            // 处理支付
            paymentService.processPayment(message.getOrderId(), message.getAmount());
            
            // 发送支付成功消息
            PaymentSuccessMessage paymentMessage = new PaymentSuccessMessage();
            paymentMessage.setOrderId(message.getOrderId());
            rabbitTemplate.convertAndSend("payment.success", paymentMessage);
            
        } catch (Exception e) {
            log.error("Failed to process order: " + message.getOrderId(), e);
            // 发送补偿消息
            OrderCancelMessage cancelMessage = new OrderCancelMessage();
            cancelMessage.setOrderId(message.getOrderId());
            rabbitTemplate.convertAndSend("order.cancel", cancelMessage);
        }
    }
    
    @RabbitListener(queues = "payment.success")
    @Transactional
    public void handlePaymentSuccess(PaymentSuccessMessage message) {
        try {
            // 预留库存
            inventoryService.reserveInventory(message.getOrderId());
            
            // 确认订单
            orderService.confirmOrder(message.getOrderId());
            
        } catch (Exception e) {
            log.error("Failed to handle payment success: " + message.getOrderId(), e);
            // 发送补偿消息
            PaymentCancelMessage cancelMessage = new PaymentCancelMessage();
            cancelMessage.setOrderId(message.getOrderId());
            rabbitTemplate.convertAndSend("payment.cancel", cancelMessage);
        }
    }
}

模式对比分析

一致性保证

模式 一致性级别 实现复杂度 性能影响
Saga 最终一致性 中等 中等
TCC 强一致性 高 低
消息队列 最终一致性 低 低

适用场景

Saga模式适用场景

  1. 长事务场景：业务流程复杂，涉及多个步骤
  2. 最终一致性可接受：业务允许短暂的数据不一致
  3. 服务间松耦合：服务间依赖关系较弱

TCC模式适用场景

  1. 强一致性要求：金融、支付等对数据一致性要求极高的场景
  2. 短事务场景：业务流程相对简单，执行时间较短
  3. 业务逻辑可控：能够改造业务逻辑以支持Try/Confirm/Cancel操作

消息队列模式适用场景

  1. 异步处理场景：业务流程可以异步执行
  2. 最终一致性可接受：允许一定延迟的数据同步
  3. 系统解耦：需要降低服务间耦合度

性能特点分析

响应时间

// 性能测试代码示例
@SpringBootTest
public class PerformanceTest {
    
    @Autowired
    private OrderService orderService;
    
    @Test
    public void testSagaPerformance() {
        long startTime = System.currentTimeMillis();
        
        // 执行1000次订单创建
        for (int i = 0; i < 1000; i++) {
            Order order = new Order();
            order.setAmount(new BigDecimal("100"));
            order.setCustomerId("customer_" + i);
            orderService.createOrder(order);
        }
        
        long endTime = System.currentTimeMillis();
        System.out.println("Saga模式耗时: " + (endTime - startTime) + "ms");
    }
    
    @Test
    public void testTccPerformance() {
        long startTime = System.currentTimeMillis();
        
        // 执行1000次转账操作
        for (int i = 0; i < 1000; i++) {
            transferService.transfer("account1", "account2", new BigDecimal("100"));
        }
        
        long endTime = System.currentTimeMillis();
        System.out.println("TCC模式耗时: " + (endTime - startTime) + "ms");
    }
}

并发处理能力

Saga模式和TCC模式在并发处理方面有不同的表现：

  • Saga模式：由于需要维护事务状态，高并发场景下可能存在状态管理的瓶颈
  • TCC模式：Try阶段的资源预留可能影响并发性能，但整体吞吐量较高
  • 消息队列模式：通过异步处理可以很好地支持高并发

最佳实践建议

Saga模式最佳实践

  1. 幂等性设计：确保每个步骤的操作都是幂等的
  2. 状态持久化：将Saga状态持久化到数据库，确保系统重启后能够恢复
  3. 超时处理：为每个步骤设置合理的超时时间
  4. 监控告警：建立完善的监控体系，及时发现和处理异常情况
// 幂等性处理示例
@Service
public class IdempotentOrderService {
    
    @Autowired
    private IdempotentRepository idempotentRepository;
    
    @Transactional
    public void createOrder(String requestId, Order order) {
        // 检查幂等性
        if (idempotentRepository.existsById(requestId)) {
            log.info("Request already processed: " + requestId);
            return;
        }
        
        try {
            // 执行业务逻辑
            orderRepository.save(order);
            
            // 记录幂等性标识
            IdempotentRecord record = new IdempotentRecord();
            record.setRequestId(requestId);
            record.setCreateTime(new Date());
            idempotentRepository.save(record);
            
        } catch (Exception e) {
            // 删除幂等性记录以便重试
            idempotentRepository.deleteById(requestId);
            throw e;
        }
    }
}

TCC模式最佳实践

  1. 资源预留策略：合理设计资源预留机制，避免资源浪费
  2. 超时回滚：为Try阶段设置超时机制，自动触发Cancel操作
  3. 异常处理：完善异常处理机制，确保在各种异常情况下都能正确回滚
  4. 性能优化：优化Try阶段的操作，减少对业务性能的影响

消息队列模式最佳实践

  1. 消息可靠性：确保消息不丢失，使用持久化队列
  2. 死信队列：为处理失败的消息设置死信队列
  3. 重试机制：实现合理的重试策略
  4. 顺序保证：对于需要顺序处理的业务，确保消息的顺序性
// 死信队列配置
@Configuration
public class RabbitMQConfig {
    
    @Bean
    public Queue orderCreatedQueue() {
        return QueueBuilder.durable("order.created")
                .withArgument("x-dead-letter-exchange", "dlx")
                .withArgument("x-dead-letter-routing-key", "order.created.dlq")
                .build();
    }
    
    @Bean
    public Queue orderCreatedDLQ() {
        return QueueBuilder.durable("order.created.dlq").build();
    }
    
    @Bean
    public DirectExchange dlxExchange() {
        return new DirectExchange("dlx");
    }
}

技术选型指南

选择Saga模式的场景

// 适用Saga模式的业务场景示例
@Service
public class BookingSagaService {
    
    // 酒店预订 -> 航班预订 -> 租车预订
    // 每个步骤都有明确的补偿操作
    public void bookTravel(TravelBooking booking) {
        // 这种长流程、多步骤的业务适合使用Saga模式
    }
}

选择标准：

  • 业务流程包含3个以上步骤
  • 允许最终一致性
  • 需要完整的事务轨迹记录

选择TCC模式的场景

// 适用TCC模式的业务场景示例
@Service
public class PaymentTccService {
    
    // 转账、支付等金融业务需要强一致性
    public void transfer(String fromAccount, String toAccount, BigDecimal amount) {
        // 这类业务适合使用TCC模式
    }
}

选择标准：

  • 对数据一致性要求极高
  • 业务逻辑相对简单
  • 能够接受较高的实现复杂度

选择消息队列模式的场景

// 适用消息队列模式的业务场景示例
@Service
public class NotificationService {
    
    // 订单创建后发送邮件、短信通知
    // 这些操作可以异步执行
    public void sendNotification(Order order) {
        // 适合使用消息队列模式
    }
}

选择标准：

  • 业务流程可以异步执行
  • 对实时性要求不高
  • 需要系统解耦

总结

在微服务架构下，分布式事务的处理是一个复杂而重要的问题。Saga模式、TCC模式和消息队列补偿模式各有其特点和适用场景：

  • Saga模式适合长事务、最终一致性可接受的场景，实现相对简单但需要完善的补偿机制
  • TCC模式适合对一致性要求极高的金融类业务，实现复杂但能保证强一致性
  • 消息队列模式适合异步处理场景，实现简单且性能良好

在实际项目中，应该根据具体的业务需求、性能要求和技术团队能力来选择合适的分布式事务解决方案。同时，无论选择哪种模式，都需要考虑幂等性、异常处理、监控告警等最佳实践，确保系统的稳定性和可靠性。

随着技术的发展，Seata、Atomikos等分布式事务框架也在不断完善，为开发者提供了更多的选择。在技术选型时，应该综合考虑框架的成熟度、社区支持、性能表现等因素，选择最适合项目需求的解决方案。

本文来自极简博客，作者：魔法学徒喵，转载请注明原文链接：微服务架构下的分布式事务解决方案：Saga模式与TCC模式技术选型指南

打赏

本文固定链接: https://www.cxy163.net/archives/7910 | 绝缘体

该日志由 绝缘体.. 于 2020年10月23日 发表在 未分类 分类下， 你可以发表评论，并在保留原文地址及作者的情况下引用到你的网站或博客。
原创文章转载请注明: 微服务架构下的分布式事务解决方案：Saga模式与TCC模式技术选型指南 | 绝缘体
关键字: , , , ,
【上一篇】
【下一篇】

您可能还会对这些文章感兴趣！

  1. php出现的No input file specified
  2. 如何在 Laravel 代码中正确地使用数据库事务
  3. ServerLess与消息队列的集成
  4. Java中的设计模式：观察者模式
  5. 微服务分布式事务解决方案：Saga模式、TCC模式
  6. 数据库设计的冗余与一致性
  7. Yii2 queue的队列使用详解
  8. 程序开发中的数据交换与交换技术
  9. yii2 使用场景验证（临时验证）请求参数的使用（m
  10. 达梦数据库的事务回滚与恢复方法
  11. 微服务架构下的分布式事务解决方案：Saga模式、T
  12. yii2 队列的使用
  13. BIO中的同步阻塞IO操作详解
  14. JavaScript异步编程模式：回调、Promise和Asy
  15. js 按照队列顺序执行函数，保证当前执行的函数不会
  16. 微服务架构下的分布式事务解决方案：Seata与Sag

微服务架构下的分布式事务解决方案：Saga模式与TCC模式技术选型指南：等您坐沙发呢！

发表评论


快捷键：Ctrl+Enter