TCC 幂等性设计#

// Try 接口的幂等实现
@TwoPhaseBusinessAction(name = "stockTry")
public class StockTccAction implements BusinessAction {
    @Override
    public boolean tryExecute(StockDTO stockDTO) {
        String branchId = businessActionContext.getBranchId();
        String xid = businessActionContext.getXid();

        // 幂等检查：是否已经执行过 Try
        TccReserve existing = tccReserveMapper.selectByBranchId(branchId);
        if (existing != null) {
            // 已执行过，根据状态判断
            if (existing.getStatus() == ReserveStatus.CONFIRMED) {
                // Try 已确认（Confirm 已执行），返回成功
                return true;
            }
            if (existing.getStatus() == ReserveStatus.RESERVING) {
                // 预留中，正常处理
            }
        }

        // 执行预留操作
        try {
            // 冻结库存（预留）
            stockService.freezeStock(stockDTO.getSkuId(), stockDTO.getQuantity());
        } catch (InsufficientStockException e) {
            // 库存不足是业务异常，不是幂等失败
            return false;
        }

        // 记录预留状态（幂等保证）
        TccReserve reserve = new TccReserve();
        reserve.setBranchId(branchId);
        reserve.setXid(xid);
        reserve.setResourceType("stock");
        reserve.setResourceId(stockDTO.getSkuId());
        reserve.setReserveAmount(new BigDecimal(stockDTO.getQuantity()));
        reserve.setStatus(ReserveStatus.RESERVING);
        tccReserveMapper.insert(reserve);

        return true;
    }

    @Override
    public boolean confirm(StockDTO stockDTO) {
        // Confirm 逻辑见下一节
    }

    @Override
    public boolean cancel(StockDTO stockDTO) {
        // Cancel 逻辑见第4节
    }
}

// Confirm 接口的幂等实现
@Override
public boolean confirm(StockDTO stockDTO) {
    String branchId = businessActionContext.getBranchId();

    // 幂等检查：根据分支事务ID查询状态
    TccReserve reserve = tccReserveMapper.selectByBranchId(branchId);
    if (reserve == null) {
        // 记录不存在：Try 未执行或已取消
        // 由于幂等性设计，这种情况不应该发生
        log.warn("TCC reserve not found for branchId={}, treating as idempotent success", branchId);
        return true;
    }

    if (reserve.getStatus() == ReserveStatus.CONFIRMED) {
        // 已确认，直接返回成功（幂等）
        return true;
    }

    if (reserve.getStatus() == ReserveStatus.CANCELLED) {
        // 已取消，不应该执行 Confirm
        log.error("TCC confirm called on cancelled reserve, branchId={}", branchId);
        return false;
    }

    // 执行真正的扣减
    stockService.deductFrozenStock(
        reserve.getResourceId(),
        reserve.getReserveAmount().intValue()
    );

    // 更新状态为已确认
    reserve.setStatus(ReserveStatus.CONFIRMED);
    tccReserveMapper.updateById(reserve);

    return true;
}

// Cancel 接口的幂等实现
@Override
public boolean cancel(StockDTO stockDTO) {
    String branchId = businessActionContext.getBranchId();

    // 幂等检查
    TccReserve reserve = tccReserveMapper.selectByBranchId(branchId);
    if (reserve == null) {
        // 记录不存在：Try 未执行（空回滚）
        // 幂等处理：插入一条"空回滚记录"
        log.info("Empty rollback detected for branchId={}, recording cancel", branchId);
        recordEmptyCancel(branchId);
        return true;
    }

    if (reserve.getStatus() == ReserveStatus.CANCELLED) {
        // 已取消，直接返回成功（幂等）
        return true;
    }

    if (reserve.getStatus() == ReserveStatus.CONFIRMED) {
        // 已确认，不应该取消
        log.error("TCC cancel called on confirmed reserve, branchId={}", branchId);
        return false;
    }

    // 执行解冻
    stockService.unfreezeStock(
        reserve.getResourceId(),
        reserve.getReserveAmount().intValue()
    );

    // 更新状态为已取消
    reserve.setStatus(ReserveStatus.CANCELLED);
    tccReserveMapper.updateById(reserve);

    return true;
}

@Override
public boolean cancel(StockDTO stockDTO) {
    String branchId = businessActionContext.getBranchId();
    String xid = businessActionContext.getXid();

    // 第一步：检查全局事务状态（防悬挂）
    TccTransaction tx = tccTransactionMapper.selectByXid(xid);
    if (tx == null) {
        // 全局事务不存在：这是一个孤立调用，忽略
        log.warn("TCC transaction not found for xid={}, ignoring cancel", xid);
        return true;
    }

    if (tx.getStatus() == TccStatus.CONFIRMED) {
        // Try 已确认，不能 Cancel
        log.error("Cannot cancel confirmed transaction, xid={}", xid);
        return false;
    }

    if (tx.getStatus() == TccStatus.CANCELLED) {
        // 已取消，幂等返回
        return true;
    }

    // 状态是"尝试中"：需要检查 Try 是否已经完成
    TccReserve reserve = tccReserveMapper.selectByBranchId(branchId);
    if (reserve == null) {
        // Try 确实没执行过：空回滚
        recordEmptyCancel(branchId, xid);
        return true;
    }

    // Try 已执行但未确认：执行真正的 Cancel
    stockService.unfreezeStock(reserve.getResourceId(), ...);
    reserve.setStatus(ReserveStatus.CANCELLED);
    tccReserveMapper.updateById(reserve);

    // 更新全局事务状态
    tccTransactionMapper.updateStatus(xid, TccStatus.CANCELLED);
    return true;
}

// 状态机转换的原子保证
public boolean transitionState(String branchId, TccStatus from, TccStatus to) {
    // 原子更新：只有当前状态是 from 时才能转到 to
    int affected = tccReserveMapper.atomicTransition(branchId, from, to);
    return affected == 1;
}

// 使用
if (transitionState(branchId, RESERVING, CONFIRMED)) {
    // 状态转换成功，执行确认逻辑
    doConfirm();
} else {
    // 状态转换失败，可能是：
    // 1. 已经转换过了（幂等）
    // 2. 已经被取消了
    return true; // 幂等返回
}

try {
    tccReserveMapper.insert(reserve);
} catch (DuplicateKeyException e) {
    // 主键冲突：幂等返回
    return true;
}