场景
以最经典的「扣钱(库 A)+ 加积分(库 B)」为例,所有方案都围绕这个场景讲:
- 业务需求:用户支付后,库 A(资金库)扣 100 元,库 B(积分库)加 100 积分,要么都成,要么都败。
- 问题:两个库独立,本地事务管不住。
方案 1:最大努力通知(最终一致性)
(互联网 90% 场景用这个,最简单、性能最高)
核心思路
先做核心操作(扣钱),再异步通知非核心操作(加积分),失败了重试,最终保证一致。
具体实现步骤

// 1. 扣钱 + 写本地消息表(同一个本地事务)
@Transactional(rollbackFor = Exception.class)
public void pay() {
// 步骤1:扣钱(库A)
fundMapper.deductMoney(userId, 100);
// 步骤2:写本地消息表(关键!和扣钱在一个事务里)
messageMapper.insert(new Message(
id: UUID.randomUUID(),
businessType: "ADD_POINT",
content: "{userId:100, point:100}",
status: "PENDING" // 待处理
));
}
// 2. 异步消费消息(定时任务/线程池)
@Scheduled(fixedRate = 5000) // 每5秒执行一次
public void processPendingMessage() {
// 步骤1:查所有待处理消息
List<Message> pendingMsg = messageMapper.listByStatus("PENDING");
for (Message msg : pendingMsg) {
try {
// 步骤2:调用积分服务加积分(库B)
boolean success = pointService.addPoint(msg.getContent());
if (success) {
// 步骤3:更新消息状态为已完成
messageMapper.updateStatus(msg.getId(), "SUCCESS");
} else {
// 步骤4:失败则重试(记录重试次数)
messageMapper.increaseRetryCount(msg.getId());
if (msg.getRetryCount() >= 3) {
messageMapper.updateStatus(msg.getId(), "FAIL");
// 告警通知人工
alarmService.send("加积分失败,用户ID:100");
}
}
} catch (Exception e) {
// 异常也重试
messageMapper.increaseRetryCount(msg.getId());
}
}
}
关键细节
- 本地消息表必须和扣钱操作在同一个本地事务(要么都写成功,要么都回滚);
- 重试策略:用「指数退避」(10s→30s→60s),避免高频重试压垮积分服务;
- 最终一致性:可能扣钱后 10 秒积分才加上,业务上能接受即可。
方案 2:TCC 模式(金融核心场景用)
核心思路
把一个操作拆成「预留→确认→取消」3 步,全程手动控制每个库的事务。
具体实现步骤

// 1. TCC事务管理器(核心)
@TccTransaction // 自定义注解,拦截TCC方法
public void payWithTcc() {
// Try阶段:预留资源
boolean fundTry = fundTccService.tryDeduct(userId, 100); // 库A冻结100元
boolean pointTry = pointTccService.tryAdd(userId, 100); // 库B预留100积分
if (!fundTry || !pointTry) {
// Cancel阶段:回滚预留资源
fundTccService.cancelDeduct(userId, 100);
pointTccService.cancelAdd(userId, 100);
throw new RuntimeException("支付失败");
}
// Confirm阶段:确认执行
boolean fundConfirm = fundTccService.confirmDeduct(userId, 100); // 真正扣钱
boolean pointConfirm = pointTccService.confirmAdd(userId, 100); // 真正加积分
if (!fundConfirm || !pointConfirm) {
// 确认失败,执行Cancel
fundTccService.cancelDeduct(userId, 100);
pointTccService.cancelAdd(userId, 100);
throw new RuntimeException("支付失败");
}
}
// 2. 资金库TCC实现
public class FundTccService {
// Try:冻结金额(库A)
public boolean tryDeduct(Long userId, Integer amount) {
return fundMapper.freezeMoney(userId, amount) > 0;
}
// Confirm:真正扣钱(库A)
public boolean confirmDeduct(Long userId, Integer amount) {
return fundMapper.confirmDeduct(userId, amount) > 0;
}
// Cancel:解冻冻结金额(库A)
public boolean cancelDeduct(Long userId, Integer amount) {
return fundMapper.unfreezeMoney(userId, amount) > 0;
}
}
// 3. 积分库TCC实现(逻辑和资金库一致)
public class PointTccService {
public boolean tryAdd(Long userId, Integer point) { … } // 预留积分
public boolean confirmAdd(Long userId, Integer point) { … } // 真正加积分
public boolean cancelAdd(Long userId, Integer point) { … } // 取消预留
}
关键细节
- Try 阶段:只预留资源,不真正执行业务(比如冻结金额,不是直接扣);
- Confirm/Cancel:必须是「幂等」的(重复调用结果一样),比如用订单号做唯一键;
- 金融场景用:因为是「强一致」,但代码入侵大(每个业务要写 3 个方法)。
方案 3:SAGA 模式(长事务 / 多系统场景)
核心思路
把大事务拆成多个小事务,每个小事务失败时执行「补偿逻辑」。
具体实现步骤

// SAGA事务编排器
public void payWithSaga() {
// 定义步骤和补偿逻辑
List<SagaStep> steps = new ArrayList<>();
// 步骤1:扣钱 + 补偿:退钱
steps.add(new SagaStep(
() -> fundService.deduct(userId, 100), // 扣钱(库A)
() -> fundService.refund(userId, 100) // 补偿:退钱(库A)
));
// 步骤2:加积分 + 补偿:减积分
steps.add(new SagaStep(
() -> pointService.add(userId, 100), // 加积分(库B)
() -> pointService.minus(userId, 100) // 补偿:减积分(库B)
));
// 执行SAGA流程
for (int i = 0; i < steps.size(); i++) {
SagaStep step = steps.get(i);
try {
// 执行当前步骤
step.execute();
} catch (Exception e) {
// 执行失败,反向执行已完成步骤的补偿
for (int j = i-1; j >= 0; j–) {
steps.get(j).compensate();
}
throw new RuntimeException("支付失败");
}
}
}
关键细节
- 补偿逻辑必须「可执行」:比如加积分失败,补偿是减积分(要保证减积分能成功);
- 适合多步骤长事务:比如订单流程(创建订单→扣库存→支付→发货),任意一步失败都能回滚。
方案 4:XA/2PC(两阶段提交,几乎不用)
核心思路
先让所有库 “预提交”,确认都能成功后,再统一提交;只要有一个库失败,全部回滚。
具体实现步骤

// XA事务(MyCat/ShardingSphere已封装,应用层只需调用)
public void payWithXA() {
// 1. 获取XA事务管理器
XADataSource xaFundDs = getXADataSource("fundDB"); // 库A
XADataSource xaPointDs = getXADataSource("pointDB"); // 库B
// 2. 开启XA事务
Xid xid = new XidImpl(UUID.randomUUID().toString().getBytes());
XAConnection fundConn = xaFundDs.getXAConnection();
XAConnection pointConn = xaPointDs.getXAConnection();
try {
// 阶段1:准备提交
fundConn.getXAResource().start(xid, XAResource.TMNOFLAGS);
fundConn.getConnection().prepareCall("UPDATE fund SET money=money-100 WHERE user_id=?", 100).execute();
fundConn.getXAResource().end(xid, XAResource.TMSUCCESS);
pointConn.getXAResource().start(xid, XAResource.TMNOFLAGS);
pointConn.getConnection().prepareCall("UPDATE point SET score=score+100 WHERE user_id=?", 100).execute();
pointConn.getXAResource().end(xid, XAResource.TMSUCCESS);
// 检查所有库准备状态
int fundPrepare = fundConn.getXAResource().prepare(xid);
int pointPrepare = pointConn.getXAResource().prepare(xid);
// 阶段2:正式提交/回滚
if (fundPrepare == XAResource.XA_OK && pointPrepare == XAResource.XA_OK) {
fundConn.getXAResource().commit(xid, false);
pointConn.getXAResource().commit(xid, false);
} else {
fundConn.getXAResource().rollback(xid);
pointConn.getXAResource().rollback(xid);
}
} catch (Exception e) {
fundConn.getXAResource().rollback(xid);
pointConn.getXAResource().rollback(xid);
}
}
关键细节
- 性能极差:准备阶段会锁住资源,直到提交完成,高并发下会卡死;
- 协调器单点问题:如果协调器挂了,库会一直锁住资源;
- 仅用于低并发、强一致场景(比如银行对账)。



