订单系统实战 — 从下单到完成的完整链路

// ========== OrderStatus.java ==========
// 定义订单状态枚举
public enum OrderStatus {
    PENDING_PAYMENT(1, "待支付"),
    PAID(2, "已支付"),
    SHIPPED(3, "已发货"),
    COMPLETED(4, "已完成"),
    CANCELLED(5, "已取消"),
    REFUNDING(6, "退款中"),
    REFUNDED(7, "已退款");
}

// ========== OrderStateMachine.java ==========
// 用Map记录合法转换规则
private static final Map<OrderStatus, Set<OrderStatus>> TRANSITIONS = new HashMap<>();

static {
    TRANSITIONS.put(PENDING_PAYMENT, Set.of(PAID, CANCELLED));
    TRANSITIONS.put(PAID, Set.of(SHIPPED, REFUNDING));
    TRANSITIONS.put(SHIPPED, Set.of(COMPLETED, REFUNDING));
    TRANSITIONS.put(REFUNDING, Set.of(REFUNDED));
    // 终态：已完成/已取消/已退款 → 空Set，不能再变
    TRANSITIONS.put(COMPLETED, Set.of());
    TRANSITIONS.put(CANCELLED, Set.of());
    TRANSITIONS.put(REFUNDED, Set.of());
}

// 校验状态转换是否合法
public static void validate(OrderStatus from, OrderStatus to) {
    Set<OrderStatus> allowed = TRANSITIONS.get(from);
    if (allowed == null || !allowed.contains(to)) {
        throw new IllegalStateException("不允许从[" + from + "]转换到[" + to + "]");
    }
}

// ========== OrderService.java ==========
public void payOrder(String orderId) {
    Order order = orderRepository.findById(orderId);
    OrderStateMachine.validate(order.getStatus(), PAID); // 先校验
    order.setStatus(PAID);                                       // 再修改
    orderRepository.save(order);
}

-- ========== deduct_stock.lua ==========
-- 原子预扣库存：检查→扣减→记录，全在Redis单线程内完成
local current = tonumber(redis.call('GET', KEYS[1]))
if current == nil then return -1 end          -- key不存在
if current < tonumber(ARGV[1]) then return 0 end  -- 库存不足

redis.call('DECRBY', KEYS[1], ARGV[1])            -- 扣减
redis.call('HSET', 'stock:hold:'..ARGV[2],           -- 记录预扣
    'sku_id', string.match(KEYS[1], 'sku_(.+)'),
    'quantity', ARGV[1])
redis.call('EXPIRE', 'stock:hold:'..ARGV[2], 1800)   -- 30分钟过期
return 1                                        -- 成功

// ========== InventoryService.java ==========
public boolean preDeductStock(String skuId, int qty, String orderId) {
    Long result = redisTemplate.execute(deductStockScript,
        Collections.singletonList("stock:sku_" + skuId),
        String.valueOf(qty), orderId);
    return result != null && result == 1;
}

// 支付成功 → 确认扣减（删预扣记录，DB正式扣减）
public void confirmDeduct(String orderId) { ... }

// 超时/取消 → 释放预扣（Redis库存加回去）
public void releasePreDeduct(String orderId) { ... }

// 发送延迟消息（下单时调用）
public void sendDelayMessage(String orderId) {
    // delayLevel=16 → 30分钟后投递
    rocketMQTemplate.syncSend("order-timeout-topic",
        MessageBuilder.withPayload(orderId).build(),
        3000, 16);
}

// 消费延迟消息（30分钟后收到）
@RocketMQMessageListener(topic = "order-timeout-topic", consumerGroup = "order-timeout-group")
public class OrderTimeoutListener implements RocketMQListener<String> {
    @Override
    public void onMessage(String orderId) {
        Order order = orderService.getById(orderId);
        // 再次检查：如果已支付就不取消了
        if (order != null && order.getStatus() == PENDING_PAYMENT) {
            orderService.cancelOrder(orderId);
        }
    }
}

// ========== Token机制：防前端重复提交 ==========
@GetMapping("/order/token")
public Result<String> getOrderToken() {
    String token = UUID.randomUUID().toString();
    redisTemplate.opsForValue().set("order:token:" + token, "1", 10, TimeUnit.MINUTES);
    return Result.success(token);
}

@PostMapping("/order/create")
public Result createOrder(@RequestHeader("X-Order-Token") String token) {
    // 原子删除：返回0说明token已被消费过 = 重复提交
    Long deleted = redisTemplate.delete("order:token:" + token);
    if (deleted == null || deleted == 0) throw new BusinessException("请勿重复提交");
    // ...创建订单
}

// ========== Redis去重：防支付回调重复 ==========
public void handlePaymentCallback(PaymentCallbackDTO callback) {
    String key = "pay:callback:" + callback.getOutTradeNo();
    Boolean isFirst = redisTemplate.opsForValue().setIfAbsent(key, "1", 24, TimeUnit.HOURS);
    if (!isFirst) return; // 已处理过，忽略
    orderService.payOrder(callback.getOutTradeNo(), ...);
}

-- ========== 数据库唯一索引：最终兜底 ==========
CREATE TABLE t_order (
    order_no VARCHAR(64) UNIQUE NOT NULL,  -- 唯一索引
    ...
);
// catch DuplicateKeyException → 返回已有订单

// 加一个注解就能搞定全局事务
@GlobalTransactional(timeoutMills = 60000, name = "create-order")
public String createOrder(CreateOrderDTO dto) {
    // 操作1：创建订单
    orderMapper.insert(order);

    // 操作2：扣减库存（Feign远程调用库存服务）
    Result r1 = inventoryClient.deductStock(dto.getSkuId(), dto.getQuantity());
    if (!r1.isSuccess()) throw new BusinessException("库存不足");

    // 操作3：扣减优惠券（Feign远程调用优惠券服务）
    Result r2 = couponClient.useCoupon(dto.getCouponId(), dto.getUserId());
    if (!r2.isSuccess()) throw new BusinessException("优惠券不可用");

    // 任何一步抛异常 → Seata自动回滚所有操作
}

// ========== 乐观锁：更新时检查version ==========
@Update("UPDATE t_order SET status=#{status}, version=version+1 " +
        "WHERE id=#{id} AND version=#{version}")
int updateWithVersion(@Param("id") Long id, @Param("status") int s, @Param("version") int v);

public void shipOrder(Long orderId) {
    Order order = orderMapper.selectById(orderId);
    int rows = orderMapper.updateWithVersion(orderId, SHIPPED.getCode(), order.getVersion());
    if (rows == 0) throw new BusinessException("订单已被修改，请刷新重试");
}

// ========== 悲观锁：SELECT FOR UPDATE ==========
@Select("SELECT * FROM t_order WHERE id = #{id} FOR UPDATE")
Order selectForUpdate(@Param("id") Long id);

@Transactional
public void payOrder(String orderId) {
    Order order = orderMapper.selectForUpdate(orderId); // 加排他锁
    // 其他事务必须等到这个事务提交后才能读取这行
    order.setStatus(PAID);
    orderMapper.updateById(order);
}