← 返回首页 📚 实战课程
📑 本篇章节导航 (共5章,点击直达)
一、理论篇:分布式事务核心概念(30%)二、实战篇:Seata + RocketMQ(40%)三、面试模拟篇(20%)四、练习篇(10%)方案选型决策树

P4-03 分布式事务实战

适用对象:5年经验Java开发者,目标薪资18-22K
课时:约3.5小时 | 理论30% + 实战40% + 面试20% + 练习10%

一、理论篇:分布式事务核心概念(30%)

1.1 为什么需要分布式事务

单体应用中,数据库事务通过ACID保证一致性。微服务架构下,一个业务操作跨多个服务,每个服务有独立的数据库,本地事务无法保证全局一致性。


订单服务 ──→ 库存服务 ──→ 支付服务
  DB-1         DB-2         DB-3

订单创建成功 + 库存扣减失败 = 数据不一致

CAP定理:分布式系统无法同时满足一致性(C)、可用性(A)、分区容错(P),只能三选二。分布式事务本质上是在AP和CP之间做选择。

BASE理论: Basically Available(基本可用)、Soft State(软状态)、Eventually Consistent(最终一致性)。

1.2 四种分布式事务方案

2PC(两阶段提交)


           ┌──→ 参与者1(prepare → commit/rollback)
协调者 ──→├──→ 参与者2(prepare → commit/rollback)
           └──→ 参与者3(prepare → commit/rollback)

阶段一:协调者问所有参与者"准备好了吗?" → 所有参与者锁定资源
阶段二:全部OK则commit,任何一个No则rollback

优点:强一致性
缺点:同步阻塞、单点故障(协调者宕机)、性能差

TCC(Try-Confirm-Cancel)


Try阶段:预留资源(冻结库存、冻结金额)
   ↓
全部Try成功 → Confirm阶段:确认扣减(实际扣减冻结的库存/金额)
   ↓
任一Try失败 → Cancel阶段:释放预留资源(解冻库存/金额)

优点:无锁,性能好
缺点:业务侵入性强,需要写三个方法

SAGA模式


正向流程:   T1 → T2 → T3 → T4(顺序执行)
                ↓ 某步失败
补偿流程:   C1 ← C2 ← C3(反向补偿)

优点:无锁、长事务适用、业务侵入性中等
缺点:缺乏隔离性,可能脏读

可靠消息最终一致性


订单服务 → 发送半消息 → MQ → 库存服务消费
    ↓                          ↓
执行本地事务              执行库存扣减
    ↓                          ↓
提交/回滚消息             成功→ACK / 失败→重试

优点:性能最好、异步解耦
缺点:只能保证最终一致性、实现较复杂

1.3 方案选型对比

方案一致性性能侵入性适用场景
2PC强一致差低数据库层面的XA事务
TCC强一致好高资金类核心业务
SAGA最终一致好中长流程业务编排
可靠消息最终一致最好中非核心链路

二、实战篇:Seata + RocketMQ(40%)

2.1 Seata AT模式原理

AT模式(Auto Transaction)是Seata默认模式,对业务无侵入:


阶段一(Business + Branch Register):
  1. 拦截SQL,解析SQL语义
  2. 查询修改前数据(Before Image)
  3. 执行业务SQL
  4. 查询修改后数据(After Image)
  5. 生成回滚日志(undo_log),保存Before/After Image
  6. 注册分支事务,提交本地事务

阶段二(Commit / Rollback):
  Commit:异步删除undo_log(因为一阶段已提交)
  Rollback:读取undo_log,生成反向补偿SQL执行

2.2 项目依赖


<dependencies>
    <!-- Seata -->
    <dependency>
        <groupId>com.alibaba.cloud</groupId>
        <artifactId>spring-cloud-starter-alibaba-seata</artifactId>
        <version>2022.0.0.0</version>
    </dependency>
    <!-- RocketMQ -->
    <dependency>
        <groupId>org.apache.rocketmq</groupId>
        <artifactId>rocketmq-spring-boot-starter</artifactId>
        <version>2.3.0</version>
    </dependency>
</dependencies>

2.3 Seata配置


# application.yml(每个参与方都需要配置)
seata:
  enabled: true
  application-id: order-service
  tx-service-group: my-tx-group
  service:
    vgroup-mapping:
      my-tx-group: default
  registry:
    type: nacos
    nacos:
      server-addr: 127.0.0.1:8848
      namespace: seata
      group: DEFAULT_GROUP
  config:
    type: nacos
    nacos:
      server-addr: 127.0.0.1:8848
      namespace: seata

2.4 undo_log表(每个参与方数据库都要建)


-- 每个参与分布式事务的数据库都要建这张表
CREATE TABLE `undo_log` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT,
  `branch_id` bigint(20) NOT NULL,
  `xid` varchar(100) NOT NULL,
  `context` varchar(128) NOT NULL,
  `rollback_info` longblob NOT NULL,
  `log_status` int(11) NOT NULL,
  `log_created` datetime NOT NULL,
  `log_modified` datetime NOT NULL,
  `ext` varchar(100) DEFAULT NULL,
  PRIMARY KEY (`id`),
  UNIQUE KEY `ux_undo_log` (`xid`,`branch_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

2.5 订单-库存-支付分布式事务完整实现


// =================== 订单服务(事务发起方) ===================
@Service
@Slf4j
public class OrderTransactionService {

    @Autowired
    private OrderMapper orderMapper;
    @Autowired
    private InventoryClient inventoryClient;
    @Autowired
    private PaymentClient paymentClient;

    /**
     * 创建订单 - 分布式事务入口
     * @GlobalTransactional 开启全局事务
     */
    @GlobalTransactional(name = "create-order-tx", rollbackFor = Exception.class)
    public Order createOrder(CreateOrderRequest request) {
        log.info("====== 开始创建订单全局事务 ======");

        // Step 1: 创建订单(本地事务)
        Order order = new Order();
        order.setOrderNo(generateOrderNo());
        order.setUserId(request.getUserId());
        order.setProductId(request.getProductId());
        order.setQuantity(request.getQuantity());
        order.setAmount(request.getAmount());
        order.setStatus(OrderStatus.CREATED);
        orderMapper.insert(order);
        log.info("订单创建成功: orderNo={}", order.getOrderNo());

        // Step 2: 调用库存服务扣减库存(远程调用,Seata分支事务)
        InventoryDTO inventoryDTO = new InventoryDTO();
        inventoryDTO.setProductId(order.getProductId());
        inventoryDTO.setQuantity(order.getQuantity());
        inventoryDTO.setOrderNo(order.getOrderNo());
        Result<Void> inventoryResult = inventoryClient.deduct(inventoryDTO);
        if (!inventoryResult.isSuccess()) {
            throw new BusinessException("库存扣减失败: " 
                + inventoryResult.getMessage());
        }
        log.info("库存扣减成功: productId={}, quantity={}", 
            order.getProductId(), order.getQuantity());

        // Step 3: 调用支付服务冻结金额(远程调用,Seata分支事务)
        PaymentDTO paymentDTO = new PaymentDTO();
        paymentDTO.setUserId(order.getUserId());
        paymentDTO.setAmount(order.getAmount());
        paymentDTO.setOrderNo(order.getOrderNo());
        Result<Void> paymentResult = paymentClient.freeze(paymentDTO);
        if (!paymentResult.isSuccess()) {
            throw new BusinessException("金额冻结失败: " 
                + paymentResult.getMessage());
        }
        log.info("金额冻结成功: userId={}, amount={}", 
            order.getUserId(), order.getAmount());

        // 全部成功
        order.setStatus(OrderStatus.PAID);
        orderMapper.updateStatus(order.getOrderNo(), OrderStatus.PAID);
        log.info("====== 订单全局事务完成 ======");
        return order;
    }
}

// =================== 库存服务(事务参与方) ===================
@Service
@Slf4j
public class InventoryService {

    @Autowired
    private InventoryMapper inventoryMapper;

    /**
     * 扣减库存 - Seata AT模式分支事务
     * 无需额外注解,Seata自动管理
     */
    public void deduct(String productId, Integer quantity, String orderNo) {
        log.info("扣减库存: productId={}, quantity={}", productId, quantity);

        // 乐观锁扣减
        int rows = inventoryMapper.deductStock(productId, quantity);
        if (rows == 0) {
            throw new BusinessException("库存不足");
        }

        // 记录库存操作流水(用于对账)
        InventoryLog log = new InventoryLog();
        log.setOrderNo(orderNo);
        log.setProductId(productId);
        log.setQuantity(quantity);
        log.setType(InventoryLogType.DEDUCT);
        inventoryMapper.insertLog(log);
    }
}

// =================== 支付服务(事务参与方) ===================
@Service
@Slf4j
public class PaymentService {

    @Autowired
    private AccountMapper accountMapper;

    /**
     * 冻结金额 - Seata AT模式分支事务
     */
    public void freeze(Long userId, BigDecimal amount, String orderNo) {
        log.info("冻结金额: userId={}, amount={}", userId, amount);

        // 检查余额
        Account account = accountMapper.selectByUserId(userId);
        if (account.getAvailableAmount().compareTo(amount) < 0) {
            throw new BusinessException("余额不足");
        }

        // 冻结金额:可用余额减少,冻结金额增加
        accountMapper.freezeAmount(userId, amount);

        // 记录资金流水
        PaymentLog paymentLog = new PaymentLog();
        paymentLog.setOrderNo(orderNo);
        paymentLog.setUserId(userId);
        paymentLog.setAmount(amount);
        paymentLog.setType(PaymentLogType.FREEZE);
        accountMapper.insertPaymentLog(paymentLog);
    }
}

2.6 RocketMQ事务消息实现

适用于不需要强一致性,但需要最终一致性的场景。


// =================== 事务消息生产者 ===================
@Service
@Slf4j
public class OrderTransactionMessageProducer {

    @Autowired
    private RocketMQTemplate rocketMQTemplate;

    /**
     * 发送事务消息:创建订单 + 通知库存扣减
     */
    public void sendOrderTransactionMessage(Order order) {
        log.info("发送订单事务消息: orderNo={}", order.getOrderNo());

        // 使用RocketMQTemplate发送事务消息
        rocketMQTemplate.sendMessageInTransaction(
            "order-inventory-topic",
            MessageBuilder.withPayload(order)
                .setKeys(order.getOrderNo())
                .build(),
            order  // 传递给本地事务方法的参数
        );
    }
}

// =================== 事务消息监听器 ==================
@RocketMQTransactionListener
@Slf4j
public class OrderTransactionListener 
        implements RocketMQLocalTransactionListener {

    @Autowired
    private OrderService orderService;
    @Autowired
    private OrderMapper orderMapper;

    /**
     * 执行本地事务(半消息发送成功后回调)
     */
    @Override
    public RocketMQLocalTransactionState executeLocalTransaction(
            Message msg, Object arg) {
        Order order = (Order) arg;
        log.info("执行本地事务: orderNo={}", order.getOrderNo());

        try {
            // 执行本地事务:创建订单
            orderMapper.insert(order);
            log.info("本地事务执行成功,提交消息");
            return RocketMQLocalTransactionState.COMMIT;
        } catch (Exception e) {
            log.error("本地事务执行失败,回滚消息", e);
            return RocketMQLocalTransactionState.ROLLBACK;
        }
    }

    /**
     * 回查本地事务状态(MQ未收到commit/rollback时回调)
     */
    @Override
    public RocketMQLocalTransactionState checkLocalTransaction(
            Message msg) {
        String orderNo = (String) msg.getHeaders().get("KEYS");
        log.info("回查本地事务状态: orderNo={}", orderNo);

        Order order = orderMapper.selectByOrderNo(orderNo);
        if (order != null) {
            return RocketMQLocalTransactionState.COMMIT;
        }
        return RocketMQLocalTransactionState.ROLLBACK;
    }
}

// =================== 库存消费者(消费端) ===================
@Component
@RocketMQMessageListener(
    topic = "order-inventory-topic",
    consumerGroup = "inventory-consumer-group"
)
@Slf4j
public class InventoryMessageConsumer 
        implements RocketMQListener<Order> {

    @Autowired
    private InventoryService inventoryService;

    @Override
    public void onMessage(Order order) {
        log.info("收到订单消息,扣减库存: orderNo={}", order.getOrderNo());
        try {
            inventoryService.deduct(
                order.getProductId(), 
                order.getQuantity(),
                order.getOrderNo()
            );
        } catch (Exception e) {
            log.error("库存扣减失败,消息将重试: orderNo={}", 
                order.getOrderNo(), e);
            throw e; // 抛出异常触发重试
        }
    }
}

2.7 Seata AT vs TCC 的选择


// TCC模式实现(需要业务自行实现三个阶段)
@LocalTCC
public interface InventoryTccService {

    /**
     * Try: 冻结库存(预留资源)
     */
    @TwoPhaseBusinessAction(
        name = "inventory-deduct",
        commitMethod = "confirm",
        rollbackMethod = "cancel"
    )
    boolean prepare(BusinessActionContext context,
                    @BusinessActionContextParameter(paramName = "productId") 
                    String productId,
                    @BusinessActionContextParameter(paramName = "quantity") 
                    Integer quantity);

    /**
     * Confirm: 确认扣减
     */
    boolean confirm(BusinessActionContext context);

    /**
     * Cancel: 释放冻结库存
     */
    boolean cancel(BusinessActionContext context);
}

// TCC实现类
@Service
@Slf4j
public class InventoryTccServiceImpl implements InventoryTccService {

    @Autowired
    private InventoryMapper inventoryMapper;

    @Override
    public boolean prepare(BusinessActionContext context, 
            String productId, Integer quantity) {
        log.info("TCC Try: 冻结库存 productId={}, quantity={}", 
            productId, quantity);
        // 冻结库存:stock - quantity, frozen_stock + quantity
        int rows = inventoryMapper.freezeStock(productId, quantity);
        return rows > 0;
    }

    @Override
    public boolean confirm(BusinessActionContext context) {
        String productId = (String) context.getActionContext("productId");
        Integer quantity = (Integer) context.getActionContext("quantity");
        log.info("TCC Confirm: 确认扣减 productId={}, quantity={}", 
            productId, quantity);
        // 确认扣减:frozen_stock - quantity
        inventoryMapper.confirmDeduct(productId, quantity);
        return true;
    }

    @Override
    public boolean cancel(BusinessActionContext context) {
        String productId = (String) context.getActionContext("productId");
        Integer quantity = (Integer) context.getActionContext("quantity");
        log.info("TCC Cancel: 释放冻结 productId={}, quantity={}", 
            productId, quantity);
        // 释放冻结:stock + quantity, frozen_stock - quantity
        inventoryMapper.releaseFrozen(productId, quantity);
        return true;
    }
}

三、面试模拟篇(20%)

Q1:Seata AT模式的工作原理?

回答要点:

1. 一阶段:拦截业务SQL,记录修改前后的数据快照(Before Image / After Image),生成undo_log,连同业务SQL一起在本地事务提交

2. 二阶段提交:删除undo_log(异步,因为一阶段已提交了业务数据)

3. 二阶段回滚:读取undo_log中的Before Image,生成反向SQL补偿

关键问题:写隔离:

Q2:AT模式和TCC模式怎么选?

维度AT模式TCC模式
侵入性低(只加注解)高(需写Try/Confirm/Cancel)
性能中(需记录undo_log)高(无undo_log)
隔离性全局锁业务层面隔离
适用场景常规业务(90%场景)资金/库存等核心场景
数据库要求关系型数据库(依赖SQL解析)任意存储

原则:能用AT就用AT,涉及资金和库存且对性能要求极高时用TCC。

Q3:RocketMQ事务消息如何保证一致性?

流程:

1. 生产者发送半消息(对消费者不可见)

2. MQ确认收到后半消息后,回调本地事务方法

3. 本地事务成功 → 提交消息(消费者可见)

4. 本地事务失败 → 回滚消息(消费者永远看不到)

5. 如果MQ未收到commit/rollback(如网络断开),定期回查本地事务状态

关键代码:checkLocalTransaction方法是兜底,必须实现。


四、练习篇(10%)

练习1:SAGA模式实现

使用Seata SAGA状态机实现一个订单-库存-支付的长事务流程。


提示:
1. 定义状态机JSON(order-service.json)
2. 包含:创建订单 → 扣减库存 → 支付扣款
3. 每步定义对应的补偿操作
4. 使用Seata SagaStateMachineEngine执行

练习2:事务补偿机制

实现一个通用的本地消息表方案(不依赖RocketMQ事务消息)。


// 本地消息表结构
CREATE TABLE mq_local_message (
    id BIGINT PRIMARY KEY AUTO_INCREMENT,
    topic VARCHAR(64) NOT NULL,
    tag VARCHAR(64),
    message_key VARCHAR(64),
    message_body TEXT NOT NULL,
    status TINYINT DEFAULT 0,  -- 0待发送 1已发送 2已消费 3失败
    retry_count INT DEFAULT 0,
    max_retry INT DEFAULT 5,
    create_time DATETIME DEFAULT NOW(),
    next_retry_time DATETIME,
    INDEX idx_status_time(status, next_retry_time)
);
// 请实现定时扫描发送 + 消费确认的完整流程

练习3:分布式事务监控

设计一个分布式事务监控看板需要展示哪些指标。


要求列出至少8个监控指标和对应的告警阈值。

方案选型决策树


需要分布式事务?
├── 是否要求强一致?
│   ├── 是 → 核心资金链路?
│   │   ├── 是 → TCC(Seata TCC模式)
│   │   └── 否 → 2PC(Seata AT模式)
│   └── 否 → 最终一致性可接受?
│       ├── 是 → 有MQ基础设施?
│       │   ├── 是 → RocketMQ事务消息
│       │   └── 否 → 本地消息表
│       └── 需要补偿 → SAGA模式

上一篇:P4-02-秒杀系统完整实现
下一篇:P4-04-Spring-Cloud-Alibaba全家桶实战