幂等设计

-- 创建唯一索引
ALTER TABLE t_order ADD UNIQUE INDEX uk_biz_id (biz_id);

public Order createOrder(OrderDTO dto) {
    try {
        Order order = new Order();
        order.setBizId(dto.getBizId());
        orderMapper.insert(order);
        return order;
    } catch (DuplicateKeyException e) {
        // 重复请求，查询已有记录返回
        return orderMapper.selectByBizId(dto.getBizId());
    }
}

-- SQL 写法：利用状态条件更新
UPDATE t_order SET status = '已支付'
WHERE id = 123 AND status = '待支付';

// Java 实现：检查受影响行数
int affected = orderMapper.updateStatus(orderId, "PENDING", "PAID");
if (affected == 0) {
    // 状态已变化，查询当前状态
    Order order = orderMapper.selectById(orderId);
    if ("PAID".equals(order.getStatus())) {
        return order; // 已支付，直接返回
    }
    throw new BizException("订单状态异常");
}

-- 带版本号的更新
UPDATE t_account SET balance = balance - 100, version = version + 1
WHERE id = 1 AND version = 5;
-- 如果受影响行数为 0，说明版本已变化，需重试

// 1. 获取 Token
@GetMapping("/token")
public String getToken() {
    String token = UUID.randomUUID().toString();
    redisTemplate.opsForValue().set(
        "idempotent:" + token, "1", 10, TimeUnit.MINUTES);
    return token;
}

// 2. 提交时验证 Token（使用 Lua 脚本保证原子性）
String luaScript = "if redis.call('get', KEYS[1]) then " +
    "return redis.call('del', KEYS[1]) else return 0 end";
Long result = redisTemplate.execute(
    new DefaultRedisScript<>(luaScript, Long.class),
    Collections.singletonList("idempotent:" + token));
if (result == 0) {
    throw new BizException("请勿重复提交");
}

public PaymentResult processPayment(PaymentRequest request) {
    String lockKey = "payment:" + request.getBizId();
    RLock lock = redissonClient.getLock(lockKey);
    try {
        // 尝试获取锁，等待 5 秒，锁过期 30 秒
        if (!lock.tryLock(5, 30, TimeUnit.SECONDS)) {
            throw new BizException("系统繁忙，请稍后重试");
        }
        // 双重检查
        PaymentRecord record = paymentMapper.selectByBizId(request.getBizId());
        if (record != null) {
            return PaymentResult.alreadyProcessed(record);
        }
        // 执行业务操作
        return doPayment(request);
    } finally {
        if (lock.isHeldByCurrentThread()) {
            lock.unlock();
        }
    }
}

// ❌ 错误：先SELECT再INSERT，不是原子操作
if (!exists(idempotentKey)) {      // 请求A和B同时查到不存在
    insert(idempotentKey);         // A和B都插入成功
    doBusiness();                  // 业务逻辑执行两次！
}

// ✅ 正确：直接INSERT，依靠唯一约束
try {
    insert(idempotentKey);         // 原子操作
    doBusiness();
} catch (DuplicateKeyException e) {
    return; // 重复请求，直接返回
}

try {
    return joinPoint.proceed();  // 执行业务逻辑
} catch (Exception e) {
    if (isSystemException(e)) {
        redisTemplate.delete(idempotentKey);  // 系统异常，删除幂等号
    }
    throw e;  // 业务异常保留幂等号
}

String key = "pay_callback:" + orderId;
Boolean success = redisTemplate.opsForValue()
    .setIfAbsent(key, "1", 5, TimeUnit.MINUTES);
if (Boolean.FALSE.equals(success)) {
    // 已有并发请求在处理，直接返回
    return "SUCCESS";
}

Order order = orderMapper.selectById(orderId);
if ("PAID".equals(order.getStatus())) {
    return "SUCCESS"; // 已处理，直接返回
}

try {
    PaymentFlow flow = new PaymentFlow();
    flow.setFlowId(bankFlowId); // 银行流水号
    flow.setOrderId(orderId);
    flowMapper.insert(flow);
} catch (DuplicateKeyException e) {
    // 重复回调，查询已有记录返回
    return "SUCCESS";
}

int affected = accountMapper.addBalance(
    userId, amount, currentVersion);
if (affected == 0) {
    throw new BizException("账户更新冲突，请重试");
}

@Transactional
public String handlePaymentCallback(PaymentCallbackDTO dto) {
    String orderId = dto.getOrderId();

    // 1. 前置快速拒绝
    String lockKey = "pay_callback:" + orderId;
    Boolean locked = redisTemplate.opsForValue()
        .setIfAbsent(lockKey, "1", 5, TimeUnit.MINUTES);
    if (Boolean.FALSE.equals(locked)) {
        return "SUCCESS";
    }

    // 2. 业务校验
    Order order = orderMapper.selectById(orderId);
    if ("PAID".equals(order.getStatus())) {
        return "SUCCESS";
    }

    // 3. 数据库兜底
    try {
        PaymentFlow flow = new PaymentFlow();
        flow.setFlowId(dto.getBankFlowId());
        flow.setOrderId(orderId);
        flowMapper.insert(flow);
    } catch (DuplicateKeyException e) {
        return "SUCCESS";
    }

    // 4. 执行业务逻辑
    accountService.addBalance(order.getUserId(), order.getAmount());
    orderMapper.updateStatus(orderId, "PAID");
    return "SUCCESS";
}

-- 状态机驱动的业务动作
UPDATE t_order SET status = '支付成功'
WHERE id = 123 AND status = '待支付';

// 正确：返回成功
{ "code": 0, "message": "订单已存在，创建成功" }

// 错误：返回异常
{ "code": 500, "message": "DUPLICATE_ORDER" }

if (result.isSuccess()) {
    next(); // 继续后续流程
} else {
    handleError(); // 处理错误
}