知序
返回
保存草稿
发布
H1
H2
H3
1
2
3
Excalidraw 图
AI 写作
AI 优化
目录
输入内容后显示目录
Markdown
# 08 - 分布式事务模式 ## 概述 在微服务架构中,传统的 2PC/XA 方案存在性能和扩展性问题。本章介绍更适合微服务的柔性事务方案。 ## TCC 模式 ### TCC 基本概念 TCC(Try-Confirm-Cancel)是一种补偿型事务模式,将事务分为三个阶段:  *图:TCC 的 Try、Confirm、Cancel 三阶段职责* ``` ┌─────────────────────────────────────────────────────────────┐ │ TCC 三阶段 │ ├─────────────────────────────────────────────────────────────┤ │ │ │ Try(尝试) │ │ - 预留业务资源 │ │ - 检查业务规则 │ │ - 不执行真正的业务操作 │ │ │ │ Confirm(确认) │ │ - 确认执行业务操作 │ │ - 使用 Try 阶段预留的资源 │ │ - 要求幂等 │ │ │ │ Cancel(取消) │ │ - 取消 Try 阶段预留的资源 │ │ - 释放资源 │ │ - 要求幂等 │ │ │ └─────────────────────────────────────────────────────────────┘ ``` ### TCC 流程图  *图:TCC 正常 Confirm 与 Try B 失败后 Cancel* ``` 正常流程: ┌─────────┐ ┌─────────────────────────────────┐ │ 事务协调器│ │ 参与服务 │ │ │ │ Service A Service B │ └────┬────┘ └───────┬───────────┬─────────────┘ │ │ │ │────── Try A ─────────────────→ │ │ │←───── Success ─────────────────│ │ │ │ │ │────── Try B ────────────────────────────→ │ │←───── Success ────────────────────────────│ │ │ │ │ 所有 Try 成功 │ │ │ │ │ │────── Confirm A ─────────────→ │ │ │←───── Success ─────────────────│ │ │ │ │ │────── Confirm B ────────────────────────→ │ │←───── Success ────────────────────────────│ │ │ │ ▼ 事务完成 │ │ 异常流程(Try B 失败): │────── Try A ─────────────────→ │ │ │←───── Success ─────────────────│ │ │ │ │ │────── Try B ────────────────────────────→ │ │←───── Failure ────────────────────────────│ │ │ │ │ Try B 失败,需要回滚 │ │ │ │ │ │────── Cancel A ───────────────→ │ │ │←───── Success ─────────────────│ │ │ │ │ ▼ 事务回滚 │ │ ```  ### TCC 实现示例 ```java // TCC 接口定义 public interface AccountTccService { // Try: 冻结金额 @TwoPhaseBusinessAction(name = "deductBalance", commitMethod = "confirm", rollbackMethod = "cancel") boolean tryDeduct(BusinessActionContext context, @BusinessActionContextParameter(paramName = "accountId") String accountId, @BusinessActionContextParameter(paramName = "amount") BigDecimal amount); // Confirm: 扣减冻结金额 boolean confirm(BusinessActionContext context); // Cancel: 解冻金额 boolean cancel(BusinessActionContext context); } // TCC 实现 @Service public class AccountTccServiceImpl implements AccountTccService { @Autowired private AccountMapper accountMapper; @Override public boolean tryDeduct(BusinessActionContext context, String accountId, BigDecimal amount) { // 1. 检查余额是否充足 Account account = accountMapper.findById(accountId); if (account.getBalance().compareTo(amount) < 0) { return false; } // 2. 冻结金额(预留资源) accountMapper.freezeAmount(accountId, amount); // 3. 记录 TCC 上下文,用于 Confirm/Cancel context.addActionContext("accountId", accountId); context.addActionContext("amount", amount); return true; } @Override public boolean confirm(BusinessActionContext context) { String accountId = (String) context.getActionContext("accountId"); BigDecimal amount = (BigDecimal) context.getActionContext("amount"); // 幂等检查 if (isConfirmed(context.getXid())) { return true; } // 从冻结金额中扣除 accountMapper.deductFrozenAmount(accountId, amount); // 记录已确认 markConfirmed(context.getXid()); return true; } @Override public boolean cancel(BusinessActionContext context) { String accountId = (String) context.getActionContext("accountId"); BigDecimal amount = (BigDecimal) context.getActionContext("amount"); // 幂等检查 if (isCancelled(context.getXid())) { return true; } // 解冻金额 accountMapper.unfreezeAmount(accountId, amount); // 记录已取消 markCancelled(context.getXid()); return true; } } // 账户表设计 /* CREATE TABLE account ( id VARCHAR(32) PRIMARY KEY, balance DECIMAL(18,2) NOT NULL, -- 可用余额 frozen_amount DECIMAL(18,2) DEFAULT 0 -- 冻结金额 ); */ ``` ### TCC 的问题与解决 | 问题 | 解决方案 | |------|----------| | **空回滚** | Try 未执行但收到 Cancel,需检查并忽略 | | **幂等性** | Confirm/Cancel 可能重复调用,需幂等处理 | | **悬挂** | Cancel 先于 Try 到达,需防止后续 Try 执行 | | **业务侵入** | 需要改造业务代码,增加 Try/Confirm/Cancel | ```java // 防止空回滚和悬挂 public class TccGuard { private Map<String, TccStatus> statusMap = new ConcurrentHashMap<>(); public boolean beforeTry(String xid) { TccStatus status = statusMap.get(xid); if (status != null && status == TccStatus.CANCELLED) { // 已经 Cancel,不能再 Try(防止悬挂) return false; } statusMap.put(xid, TccStatus.TRYING); return true; } public boolean beforeCancel(String xid) { TccStatus status = statusMap.get(xid); if (status == null) { // Try 未执行,记录 Cancel(处理空回滚) statusMap.put(xid, TccStatus.CANCELLED); return false; // 不需要执行 Cancel 逻辑 } return true; } } ``` ## Saga 模式 ### Saga 基本概念 Saga 是一种长事务解决方案,将长事务拆分为多个本地事务,通过补偿机制保证最终一致性。  *图:Saga 正向操作 T1…Tn 与补偿操作 C1…Cn* ``` ┌─────────────────────────────────────────────────────────────┐ │ Saga 模式 │ ├─────────────────────────────────────────────────────────────┤ │ │ │ 正向操作:T1 → T2 → T3 → ... → Tn │ │ │ │ 补偿操作:C1 ← C2 ← C3 ← ... ← Cn │ │ │ │ 如果 Ti 失败,执行 C(i-1) → C(i-2) → ... → C1 │ │ │ └─────────────────────────────────────────────────────────────┘ ``` ### Saga 执行模式  *图:Saga 编排(事件驱动)与编配(中心协调器)* ``` 1. 编排模式(Choreography) - 无中心协调器 - 服务之间通过事件通信 - 每个服务监听事件并执行操作 ┌─────────┐ Event ┌─────────┐ Event ┌─────────┐ │Service A│ ──────────→ │Service B│ ──────────→ │Service C│ │ T1 │ │ T2 │ │ T3 │ └─────────┘ └─────────┘ └─────────┘ ↑ ↑ │ │ Compensate │ Compensate │ └───────────────────────┴───────────────────────┘ (如果失败) 2. 编配模式(Orchestration) - 有中心协调器(Saga Orchestrator) - 协调器负责调用各服务 - 逻辑集中,易于理解 ┌─────────────────┐ │ Saga Orchestrator│ └────────┬────────┘ │ ┌───────────────────┼───────────────────┐ │ │ │ ▼ ▼ ▼ ┌─────────┐ ┌─────────┐ ┌─────────┐ │Service A│ │Service B│ │Service C│ │ T1/C1 │ │ T2/C2 │ │ T3/C3 │ └─────────┘ └─────────┘ └─────────┘ ```  ### Saga 编排模式实现 ```java // 基于消息的 Saga 编排 @Service public class OrderService { @Autowired private RabbitTemplate rabbitTemplate; @Transactional public void createOrder(Order order) { // T1: 创建订单 orderRepository.save(order); // 发布事件,触发下一步 rabbitTemplate.convertAndSend("saga.exchange", "order.created", new OrderCreatedEvent(order.getId(), order.getAmount())); } // 补偿操作 @RabbitListener(queues = "order.compensate") public void compensate(OrderCompensateEvent event) { // C1: 取消订单 Order order = orderRepository.findById(event.getOrderId()); order.setStatus("CANCELLED"); orderRepository.save(order); } } @Service public class PaymentService { @RabbitListener(queues = "order.created") public void handleOrderCreated(OrderCreatedEvent event) { try { // T2: 扣款 paymentRepository.deduct(event.getAmount()); // 发布成功事件 rabbitTemplate.convertAndSend("saga.exchange", "payment.completed", new PaymentCompletedEvent(event.getOrderId())); } catch (Exception e) { // 发布失败事件,触发补偿 rabbitTemplate.convertAndSend("saga.exchange", "payment.failed", new PaymentFailedEvent(event.getOrderId())); } } // 补偿操作 @RabbitListener(queues = "payment.compensate") public void compensate(PaymentCompensateEvent event) { // C2: 退款 paymentRepository.refund(event.getAmount()); // 触发上游补偿 rabbitTemplate.convertAndSend("saga.exchange", "order.compensate", new OrderCompensateEvent(event.getOrderId())); } } ``` ### Saga 编配模式实现 ```java // Saga 协调器 @Service public class OrderSagaOrchestrator { public void executeSaga(OrderSagaContext context) { try { // Step 1: 创建订单 orderService.createOrder(context.getOrder()); context.addCompletedStep("CREATE_ORDER"); // Step 2: 扣减库存 inventoryService.deductStock(context.getItems()); context.addCompletedStep("DEDUCT_STOCK"); // Step 3: 扣款 paymentService.deduct(context.getAmount()); context.addCompletedStep("DEDUCT_PAYMENT"); // Step 4: 发货 shippingService.createShipment(context.getOrder()); context.addCompletedStep("CREATE_SHIPMENT"); } catch (Exception e) { // 执行补偿 compensate(context); throw e; } } private void compensate(OrderSagaContext context) { List<String> completedSteps = context.getCompletedSteps(); // 反向执行补偿 for (int i = completedSteps.size() - 1; i >= 0; i--) { String step = completedSteps.get(i); switch (step) { case "CREATE_SHIPMENT": shippingService.cancelShipment(context.getOrderId()); break; case "DEDUCT_PAYMENT": paymentService.refund(context.getAmount()); break; case "DEDUCT_STOCK": inventoryService.restoreStock(context.getItems()); break; case "CREATE_ORDER": orderService.cancelOrder(context.getOrderId()); break; } } } } ```  ### Saga vs TCC | 对比项 | Saga | TCC | |--------|------|-----| | 隔离性 | 弱(无锁) | 较强(Try 预留资源) | | 实时性 | 先执行后补偿 | Try 阶段就检查 | | 侵入性 | 需要补偿逻辑 | 需要三个方法 | | 适用场景 | 长事务、跨系统 | 短事务、强一致性要求 | | 实现复杂度 | 相对简单 | 相对复杂 | ### 编排 vs 编配模式对比  *图:编排与编配的判断依据及 Saga 回滚过程* ``` Choreography(编排,去中心化) Orchestration(编配,中心化) ┌─────────┐ ┌─────────┐ ┌──────────────────┐ │ Service │→→│ Service │→→ │ Saga Coordinator │ │ A │ │ B │ └───┬────┬──────┬───┘ └───┬─────┘ └───┬─────┘ │ │ │ ↑ │ ▼ ▼ ▼ │ Event │ Service Service Service └─────────────┘ A B C 判断依据 决策 ├──────────────────────────────────────────────────────────────┤ │ 复杂度 简单 Saga 更轻量 复杂 Saga 更好跟踪 │ │ 不需要额外服务 协调器集中管理步骤 │ │ │ │ 可观测性 较难(事件散落各服务) 容易(协调器统一记录) │ │ │ │ 耦合度 服务间通过事件耦合 服务不关心其他服务 │ │ 添加/删除服务需改事件流 只需改协调器逻辑 │ │ │ │ 故障恢复 各服务自己监听补偿事件 协调器统一管理补偿顺序 │ │ │ │ 适用 微服务少(2-3个) 微服务多(5+) │ │ 简单线性流程 复杂分支/条件流程 │ └──────────────────────────────────────────────────────────────┘ Saga 执行过程可视化: 正常流程(4步Saga,编配模式): ┌──────────────┐ │ Coordinator │ └──┬──┬──┬──┬──┘ │ │ │ │ ▼ ▼ ▼ ▼ T1 T2 T3 T4 全部成功 ✓ 异常流程(T3 失败,回滚): ┌──────────────┐ │ Coordinator │ └──┬──┬──┬──┬──┘ │ │ │ │ ▼ ▼ ▼ ▼ T1 T2 T3✗ T4✗ T3 失败 ✓ ✓ │ │ │ │ C2 ←────┘ │ ← 执行 C2 补偿 ✓ │ │ C1 ←───────┘ ← 执行 C1 补偿 ✓ 最终:T1,T2 已回滚,数据恢复到初始状态 ✓ ``` ## 最终一致性 ### 本地消息表  *图:本地消息表:业务与消息同事务后投递* ``` 利用本地事务保证消息和业务操作的原子性 ┌─────────────────────────────────────────────────────────────┐ │ 生产者服务 │ │ ┌───────────────────────────────────────────────────────┐ │ │ │ 本地事务 │ │ │ │ 1. 执行业务操作 │ │ │ │ 2. 写入消息表(同一事务) │ │ │ └───────────────────────────────────────────────────────┘ │ │ │ │ │ 定时扫描消息表 │ │ │ │ │ ▼ │ │ 发送到消息队列 │ └─────────────────────────────────────────────────────────────┘ │ ▼ ┌─────────────────────────────────────────────────────────────┐ │ 消费者服务 │ │ │ │ │ 消费消息(幂等) │ │ │ │ │ 执行业务操作 │ └─────────────────────────────────────────────────────────────┘ ``` ```java // 本地消息表实现 @Service public class LocalMessageService { @Transactional public void createOrderWithMessage(Order order) { // 1. 保存订单(业务操作) orderRepository.save(order); // 2. 保存本地消息(同一事务) LocalMessage message = new LocalMessage(); message.setId(UUID.randomUUID().toString()); message.setTopic("order-created"); message.setPayload(JSON.toJSONString(order)); message.setStatus("PENDING"); message.setCreateTime(new Date()); localMessageRepository.save(message); } // 定时任务:扫描并发送消息 @Scheduled(fixedDelay = 5000) public void sendPendingMessages() { List<LocalMessage> messages = localMessageRepository .findByStatusAndRetryCountLessThan("PENDING", 5); for (LocalMessage msg : messages) { try { rabbitTemplate.convertAndSend(msg.getTopic(), msg.getPayload()); msg.setStatus("SENT"); } catch (Exception e) { msg.setRetryCount(msg.getRetryCount() + 1); } localMessageRepository.save(msg); } } } ``` ### 幂等性设计 ```java // 幂等消费实现 @Service public class IdempotentConsumer { @Autowired private StringRedisTemplate redis; private static final String IDEMPOTENT_PREFIX = "consumed:"; @RabbitListener(queues = "order.created") public void handleOrderCreated(Message message) { String messageId = message.getMessageProperties().getMessageId(); // 幂等检查 String key = IDEMPOTENT_PREFIX + messageId; Boolean success = redis.opsForValue() .setIfAbsent(key, "1", 7, TimeUnit.DAYS); if (!success) { // 消息已处理过 return; } try { // 执行业务逻辑 processOrder(message); } catch (Exception e) { // 处理失败,删除幂等标记,允许重试 redis.delete(key); throw e; } } } // 数据库幂等(唯一索引) @Service public class OrderService { public void processPayment(PaymentRequest request) { // 使用业务唯一键作为幂等键 String idempotentKey = request.getOrderId() + "_" + request.getPaymentType(); try { // 插入幂等记录 PaymentRecord record = new PaymentRecord(); record.setIdempotentKey(idempotentKey); record.setOrderId(request.getOrderId()); record.setAmount(request.getAmount()); paymentRecordRepository.save(record); // 执行支付 doPayment(request); } catch (DuplicateKeyException e) { // 重复请求,返回之前的结果 PaymentRecord existing = paymentRecordRepository .findByIdempotentKey(idempotentKey); return existing.getResult(); } } } ``` ### Outbox 模式  *图:Outbox 模式:业务表与 Outbox 表同事务后 CDC* ``` Outbox 模式是本地消息表的变体,更加标准化 ┌─────────────────────────────────────────────────────────────┐ │ 生产者服务 │ │ │ │ ┌───────────────────────────────────────────────────────┐ │ │ │ 本地事务 │ │ │ │ ┌─────────────┐ ┌─────────────┐ │ │ │ │ │ 业务表 │ │ Outbox 表 │ │ │ │ │ │ (orders) │ │ (outbox) │ │ │ │ │ └─────────────┘ └─────────────┘ │ │ │ └───────────────────────────────────────────────────────┘ │ │ │ │ CDC(Change Data Capture) │ │ 如 Debezium │ │ │ │ │ ▼ │ │ 消息队列 (Kafka) │ └─────────────────────────────────────────────────────────────┘ ```  ```java // Outbox 表设计 /* CREATE TABLE outbox ( id VARCHAR(36) PRIMARY KEY, aggregate_type VARCHAR(100) NOT NULL, aggregate_id VARCHAR(100) NOT NULL, type VARCHAR(100) NOT NULL, payload TEXT NOT NULL, created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ); */ // Outbox 事件发布 @Service public class OutboxService { @Transactional public void createOrder(Order order) { // 保存订单 orderRepository.save(order); // 写入 Outbox OutboxEvent event = new OutboxEvent(); event.setId(UUID.randomUUID().toString()); event.setAggregateType("Order"); event.setAggregateId(order.getId()); event.setType("OrderCreated"); event.setPayload(JSON.toJSONString(order)); outboxRepository.save(event); // CDC 工具会捕获 outbox 表的变更并发送到 Kafka } } ``` ## 实战案例 ### 电商下单流程  *图:完整下单链路:Saga 与本地消息表逐步落地* ``` 完整的分布式事务流程: 用户下单 ──→ 创建订单 ──→ 扣减库存 ──→ 扣款 ──→ 发货通知 │ │ │ │ ▼ ▼ ▼ ▼ 订单服务 库存服务 支付服务 物流服务 使用 Saga + 本地消息表: 1. 订单服务: - 创建订单(状态:待支付) - 写入本地消息:库存预扣事件 2. 库存服务: - 消费消息,预扣库存 - 写入本地消息:库存预扣成功事件 3. 支付服务: - 消费消息,执行扣款 - 写入本地消息:支付成功事件 4. 订单服务: - 消费支付成功消息 - 更新订单状态(已支付) - 写入本地消息:发货通知事件 5. 物流服务: - 消费发货通知,创建物流单 任何环节失败 → 触发补偿流程 ``` ## 本章小结 - **TCC**:Try-Confirm-Cancel,资源预留式的补偿事务 - **Saga**:长事务拆分 + 补偿,支持编排和编配两种模式 - **本地消息表**:利用本地事务保证消息可靠投递 - **幂等性**:分布式事务的基础要求 - **Outbox**:标准化的本地消息表方案 ## 思考题 1. TCC 中如何解决「空回滚」和「悬挂」问题? 2. Saga 编排模式和编配模式各有什么优缺点? 3. 本地消息表如何保证消息不丢失? ## QA ### Q1:TCC 中如何解决「空回滚」和「悬挂」问题? 这两个问题都要靠事务状态记录和幂等控制来解决。 空回滚指的是 `Try` 实际还没执行成功,系统却因为超时、网络抖动或上游失败先收到了 `Cancel`。如果这时直接做回滚,可能找不到预留资源,甚至把本来不存在的业务状态“回滚坏”。常见做法是: - 为每个全局事务记录 `xid` 和阶段状态; - `Cancel` 到达时先查事务记录; - 如果发现根本没有成功的 `Try` 记录,就把这次 `Cancel` 记成已取消或空回滚标记,然后直接返回成功; - `Cancel` 必须幂等,重复调用也只能得到同样结果。 悬挂指的是 `Cancel` 已经先执行了,后续迟到的 `Try` 又跑进来把资源冻结了,导致事务实际上已经结束,但资源却又被占住。解决方法通常是: - `Try` 执行前先检查当前 `xid` 是否已经存在取消标记; - 如果已经取消,则拒绝继续 `Try`; - `Try/Confirm/Cancel` 都要保证幂等; - 事务状态最好落库,而不是只放内存,避免服务重启后状态丢失。 总结一下,TCC 处理这类边界问题的关键是“先记状态,再执行业务”,再配合幂等、防重和阶段校验,确保乱序调用也不会把状态搞乱。 ### Q2:Saga 编排模式和编配模式各有什么优缺点? 编排模式(Choreography)的优点是服务之间通过事件自然协作,没有中心协调器,耦合相对分散,扩展新步骤也比较灵活;缺点是流程链路容易分散在多个服务里,依赖关系隐蔽,出问题时排查复杂,随着步骤增多会越来越难维护。 编配模式(Orchestration)的优点是流程由中心协调器统一控制,顺序清晰,补偿逻辑集中,监控和排障更容易;缺点是协调器本身会成为关键组件,设计不好会形成新的复杂中心,也会让部分业务流程更依赖协调器。 简单说,流程简单、事件天然驱动的场景适合编排模式;流程长、步骤多、需要强流程可观测性的场景更适合编配模式。 ### Q3:本地消息表如何保证消息不丢失? 本地消息表的核心思想是把“业务数据变更”和“待发送消息写入”放进同一个本地事务里。这样只要事务提交成功,业务数据和消息记录就一定同时落库,不会出现业务成功但消息完全没留下来的情况。 完整保障通常包括下面几层: 1. 业务操作和消息表写入同事务提交。 2. 发送端不直接依赖内存状态,而是定时扫描消息表,把 `PENDING` 消息投递到 MQ。 3. 投递成功后再把消息状态改成 `SENT` 或 `DONE`。 4. 投递失败要保留重试次数、下次重试时间和错误原因。 5. 消费端必须幂等,因为发送端可能重试,MQ 也可能重复投递。 6. 需要补充对账或死信处理,防止消息长期卡住没人处理。 所以它保证的不是“消息永远只发一次”,而是“消息至少能被可靠地补发出去”,再配合消费幂等,把最终结果收敛正确。这也是本地消息表和 Outbox 模式最核心的工程价值。 --- 下一篇:[09 - 分片与复制](./09-sharding-replication.md)
预览
发布文章
添加摘要让读者更快了解文章内容
取消
确认发布
AI 写作助手
输入一个主题,AI 将为你生成一篇 Markdown 博客文章
AI 正在写作中...
取消
开始生成
AI 优化助手
描述你的修改需求,AI 将在原文基础上进行补充或微调
AI 正在优化中...
取消
开始优化
画布
从已有图里选
✕
图名
保存后生成 /images/excalidraw/<图名>.svg(只能用字母、数字、短横线、下划线、点)
取消
保存并插入