适用对象:5年经验Java开发者,目标薪资18-22K
课时:约3.5小时 | 理论30% + 实战40% + 面试20% + 练习10%
单体应用中,数据库事务通过ACID保证一致性。微服务架构下,一个业务操作跨多个服务,每个服务有独立的数据库,本地事务无法保证全局一致性。
订单服务 ──→ 库存服务 ──→ 支付服务
DB-1 DB-2 DB-3
订单创建成功 + 库存扣减失败 = 数据不一致
CAP定理:分布式系统无法同时满足一致性(C)、可用性(A)、分区容错(P),只能三选二。分布式事务本质上是在AP和CP之间做选择。
BASE理论: Basically Available(基本可用)、Soft State(软状态)、Eventually Consistent(最终一致性)。
┌──→ 参与者1(prepare → commit/rollback)
协调者 ──→├──→ 参与者2(prepare → commit/rollback)
└──→ 参与者3(prepare → commit/rollback)
阶段一:协调者问所有参与者"准备好了吗?" → 所有参与者锁定资源
阶段二:全部OK则commit,任何一个No则rollback
优点:强一致性
缺点:同步阻塞、单点故障(协调者宕机)、性能差
Try阶段:预留资源(冻结库存、冻结金额)
↓
全部Try成功 → Confirm阶段:确认扣减(实际扣减冻结的库存/金额)
↓
任一Try失败 → Cancel阶段:释放预留资源(解冻库存/金额)
优点:无锁,性能好
缺点:业务侵入性强,需要写三个方法
正向流程: T1 → T2 → T3 → T4(顺序执行)
↓ 某步失败
补偿流程: C1 ← C2 ← C3(反向补偿)
优点:无锁、长事务适用、业务侵入性中等
缺点:缺乏隔离性,可能脏读
订单服务 → 发送半消息 → MQ → 库存服务消费
↓ ↓
执行本地事务 执行库存扣减
↓ ↓
提交/回滚消息 成功→ACK / 失败→重试
优点:性能最好、异步解耦
缺点:只能保证最终一致性、实现较复杂
| 方案 | 一致性 | 性能 | 侵入性 | 适用场景 |
|---|---|---|---|---|
| 2PC | 强一致 | 差 | 低 | 数据库层面的XA事务 |
| TCC | 强一致 | 好 | 高 | 资金类核心业务 |
| SAGA | 最终一致 | 好 | 中 | 长流程业务编排 |
| 可靠消息 | 最终一致 | 最好 | 中 | 非核心链路 |
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执行
<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>
# 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
-- 每个参与分布式事务的数据库都要建这张表
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;
// =================== 订单服务(事务发起方) ===================
@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);
}
}
适用于不需要强一致性,但需要最终一致性的场景。
// =================== 事务消息生产者 ===================
@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; // 抛出异常触发重试
}
}
}
// 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;
}
}
回答要点:
1. 一阶段:拦截业务SQL,记录修改前后的数据快照(Before Image / After Image),生成undo_log,连同业务SQL一起在本地事务提交
2. 二阶段提交:删除undo_log(异步,因为一阶段已提交了业务数据)
3. 二阶段回滚:读取undo_log中的Before Image,生成反向SQL补偿
关键问题:写隔离:
| 维度 | AT模式 | TCC模式 |
|---|---|---|
| 侵入性 | 低(只加注解) | 高(需写Try/Confirm/Cancel) |
| 性能 | 中(需记录undo_log) | 高(无undo_log) |
| 隔离性 | 全局锁 | 业务层面隔离 |
| 适用场景 | 常规业务(90%场景) | 资金/库存等核心场景 |
| 数据库要求 | 关系型数据库(依赖SQL解析) | 任意存储 |
原则:能用AT就用AT,涉及资金和库存且对性能要求极高时用TCC。
流程:
1. 生产者发送半消息(对消费者不可见)
2. MQ确认收到后半消息后,回调本地事务方法
3. 本地事务成功 → 提交消息(消费者可见)
4. 本地事务失败 → 回滚消息(消费者永远看不到)
5. 如果MQ未收到commit/rollback(如网络断开),定期回查本地事务状态
关键代码:checkLocalTransaction方法是兜底,必须实现。
使用Seata SAGA状态机实现一个订单-库存-支付的长事务流程。
提示:
1. 定义状态机JSON(order-service.json)
2. 包含:创建订单 → 扣减库存 → 支付扣款
3. 每步定义对应的补偿操作
4. 使用Seata SagaStateMachineEngine执行
实现一个通用的本地消息表方案(不依赖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)
);
// 请实现定时扫描发送 + 消费确认的完整流程
设计一个分布式事务监控看板需要展示哪些指标。
要求列出至少8个监控指标和对应的告警阈值。
需要分布式事务?
├── 是否要求强一致?
│ ├── 是 → 核心资金链路?
│ │ ├── 是 → TCC(Seata TCC模式)
│ │ └── 否 → 2PC(Seata AT模式)
│ └── 否 → 最终一致性可接受?
│ ├── 是 → 有MQ基础设施?
│ │ ├── 是 → RocketMQ事务消息
│ │ └── 否 → 本地消息表
│ └── 需要补偿 → SAGA模式
上一篇:P4-02-秒杀系统完整实现
下一篇:P4-04-Spring-Cloud-Alibaba全家桶实战