#接口幂等性设计

// 基于唯一键的幂等实现
@Service
public class OrderService {

    @Autowired
    private OrderDAO orderDAO;

    @Transactional
    public void createOrder(CreateOrderRequest request) {
        // 业务校验
        validateRequest(request);

        // 构建订单（使用业务唯一键作为订单号）
        Order order = new Order();
        order.setOrderId(request.getOrderId());  // 业务唯一键
        order.setUserId(request.getUserId());
        order.setAmount(request.getAmount());
        order.setStatus(OrderStatus.PENDING);
        order.setCreateTime(new Date());

        try {
            orderDAO.insert(order);
        } catch (DuplicateKeyException e) {
            // 唯一键冲突，说明订单已存在，直接返回
            log.info("订单已存在，orderId={}", request.getOrderId());
            return;
        }

        // 后续业务处理
        doAfterOrderCreated(order);
    }
}

// Token服务
@Service
public class TokenService {

    @Autowired
    private RedisTemplate<String, String> redisTemplate;

    private static final String TOKEN_PREFIX = "submit:token:";
    private static final long TOKEN_EXPIRE = 5 * 60;  // 5分钟过期

    // 生成Token
    public String generateToken() {
        String token = UUID.randomUUID().toString().replace("-", "");
        redisTemplate.opsForValue().set(TOKEN_PREFIX + token, "1", TOKEN_EXPIRE, TimeUnit.SECONDS);
        return token;
    }

    // 校验并删除Token（原子操作）
    public boolean validateAndRemoveToken(String token) {
        String key = TOKEN_PREFIX + token;
        // Redis SETNX + EXPIRE 的原子操作
        Boolean result = redisTemplate.delete(key);
        return Boolean.TRUE.equals(result);
    }
}

// 业务接口
@RestController
public class SubmitController {

    @Autowired
    private TokenService tokenService;

    @Autowired
    private OrderService orderService;

    @PostMapping("/submit")
    public Result submit(@RequestBody @Validated SubmitRequest request,
                        @RequestHeader("Token") String token) {
        // 1. 校验Token
        if (!tokenService.validateAndRemoveToken(token)) {
            return Result.error("请勿重复提交");
        }

        // 2. 执行业务
        orderService.createOrder(request);

        return Result.success();
    }
}

// 订单状态枚举
public enum OrderStatus {
    PENDING(0, "待支付"),
    PAID(1, "已支付"),
    SHIPPED(2, "已发货"),
    COMPLETED(3, "已完成"),
    CANCELLED(4, "已取消");

    private final int value;
    private final String desc;

    OrderStatus(int value, String desc) {
        this.value = value;
        this.desc = desc;
    }

    // 状态流转规则
    public boolean canTransferTo(OrderStatus target) {
        return this.value < target.value;
    }
}

// 订单服务
@Service
public class OrderService {

    @Transactional
    public void payOrder(Long orderId, String payMethod) {
        Order order = orderDAO.selectById(orderId);

        // 幂等检查：只有待支付状态才能支付
        if (order.getStatus() != OrderStatus.PENDING) {
            log.info("订单状态不是待支付，无法支付，orderId={}, status={}",
                orderId, order.getStatus());
            return;  // 幂等返回
        }

        // 执行支付
        order.setStatus(OrderStatus.PAID);
        order.setPayMethod(payMethod);
        order.setPayTime(new Date());
        orderDAO.update(order);
    }

    @Transactional
    public void shipOrder(Long orderId) {
        Order order = orderDAO.selectById(orderId);

        // 幂等检查：只有已支付状态才能发货
        if (order.getStatus() != OrderStatus.PAID) {
            log.info("订单状态不是已支付，无法发货，orderId={}, status={}",
                orderId, order.getStatus());
            return;  // 幂等返回
        }

        // 执行发货
        order.setStatus(OrderStatus.SHIPPED);
        order.setShipTime(new Date());
        orderDAO.update(order);
    }
}

// 防重表
// CREATE TABLE idempotent_records (
//     id BIGINT PRIMARY KEY AUTO_INCREMENT,
//     idempotent_key VARCHAR(128) NOT NULL UNIQUE,
//     result TEXT,
//     status TINYINT NOT NULL DEFAULT 0,
//     create_time DATETIME,
//     expire_time DATETIME,
//     UNIQUE KEY uk_key (idempotent_key)
// );

@Service
public class IdempotentService {

    @Autowired
    private IdempotentDAO idempotentDAO;

    @Autowired
    private BusinessService businessService;

    @Transactional
    public Result executeWithIdempotent(String idempotentKey, BusinessRequest request) {
        // 1. 查询是否已处理
        IdempotentRecord record = idempotentDAO.selectByKey(idempotentKey);
        if (record != null) {
            // 已处理，返回原结果
            return JSON.parseObject(record.getResult(), Result.class);
        }

        // 2. 创建防重记录（进行中）
        IdempotentRecord newRecord = new IdempotentRecord();
        newRecord.setIdempotentKey(idempotentKey);
        newRecord.setStatus(0);  // 进行中
        newRecord.setCreateTime(new Date());
        newRecord.setExpireTime(DateUtils.addHours(new Date(), 1));
        idempotentDAO.insert(newRecord);

        try {
            // 3. 执行业务
            Result result = businessService.doBusiness(request);

            // 4. 更新防重记录（成功）
            idempotentDAO.updateSuccess(idempotentKey, JSON.toJSONString(result));
            return result;

        } catch (Exception e) {
            // 5. 更新防重记录（失败）
            idempotentDAO.updateFailed(idempotentKey);
            throw e;
        }
    }
}