Java实现订单超时自动取消的完整设计方案

SELECT order_id FROM orders 
WHERE order_status = 'PENDING_PAY'  -- 待支付状态
  AND create_time + timeout <= UNIX_TIMESTAMP(NOW())  -- 已超时
LIMIT 1000;  -- 分批处理，避免一次处理太多订单

// RocketMQ发送定时消息示例（Java）
public void sendDelayMsg(String orderId, long timeoutSeconds) {
    Message msg = new Message("order_timeout_topic",  // 主题
                              "cancel_tag",           // 标签
                              orderId.getBytes());    // 消息体（订单ID）
    // 设置定时时间：timeoutSeconds秒后投递（RocketMQ支持自定义毫秒级延迟）
    msg.setDelayTimeMs(timeoutSeconds * 1000);
    // 发送消息（开启事务，确保“订单创建成功”和“消息发送成功”原子性）
    rocketMQTemplate.send(msg);
}

@RocketMQMessageListener(topic = "order_timeout_topic", consumerGroup = "cancel_consumer_group")
public class OrderCancelConsumer implements RocketMQListener<String> {
    @Autowired
    private OrderService orderService;
    
    @Override
    public void onMessage(String orderId) {
        // 1. 查订单当前状态（必须加锁，防止并发支付）
        OrderDO order = orderService.getOrderWithLock(orderId);
        if (order == null || !"PENDING_PAY".equals(order.getStatus())) {
            return; // 订单不存在或已支付，不取消
        }
        
        // 2. 执行取消逻辑（状态修改+资源回补）
        boolean cancelSuccess = orderService.cancelOrder(order);
        if (!cancelSuccess) {
            // 3. 取消失败，发送重试消息（延迟5分钟后重试）
            sendDelayMsg(orderId, 300);
        }
    }
}

config set notify-keyspace-events Ex

// Redisson监听Redis过期事件示例
public void listenRedisExpireEvent() {
    RPatternTopic topic = redissonClient.getPatternTopic("__keyevent@0__:expired");
    topic.addListener(String.class, (channel, orderId) -> {
        // 判断是否为订单超时Key（避免监听无关Key）
        if (orderId.startsWith("order:timeout:")) {
            String realOrderId = orderId.replace("order:timeout:", "");
            // 执行取消逻辑（同延迟队列消费逻辑）
            orderService.handleTimeoutCancel(realOrderId);
        }
    });
}

public void handleTimeoutCancel(String orderId) {
    OrderDO order = orderService.getOrder(orderId);
    if (order == null) return;
    // 二次校验：当前时间是否真的超过订单超时时间（避免Redis回调延迟导致误判）
    long currentTime = System.currentTimeMillis() / 1000;
    long timeoutTime = order.getCreateTime() + order.getTimeoutSeconds();
    if (currentTime < timeoutTime || !"PENDING_PAY".equals(order.getStatus())) {
        return;
    }
    // 执行取消逻辑
    orderService.cancelOrder(order);
}

// 用数据库行锁锁定订单（SELECT ... FOR UPDATE）
@Transactional
public OrderDO getOrderWithLock(String orderId) {
    return orderMapper.selectByOrderIdForUpdate(orderId);
}
// 校验逻辑
public boolean checkCanCancel(OrderDO order) {
    // 1. 订单状态必须是“待支付/待接单”等可取消状态
    if (!Arrays.asList("PENDING_PAY", "PENDING_ACCEPT").contains(order.getStatus())) {
        log.info("订单{}状态为{}，不可取消", order.getOrderId(), order.getStatus());
        return false;
    }
    // 2. 订单确实已超时（二次校验，避免定时任务/Redis回调延迟）
    long currentTime = System.currentTimeMillis() / 1000;
    long timeoutTime = order.getCreateTime() + order.getTimeoutSeconds();
    if (currentTime < timeoutTime) {
        log.info("订单{}未超时（当前时间{}，超时时间{}），不可取消", 
                 order.getOrderId(), currentTime, timeoutTime);
        return false;
    }
    return true;
}

@Transactional
public boolean cancelOrder(OrderDO order) {
    // 1. 再次校验（防止事务等待期间状态变化）
    if (!checkCanCancel(order)) {
        return false;
    }
    
    // 2. 修改订单状态为“已取消”
    int updateCount = orderMapper.updateStatus(order.getOrderId(), "CANCELED", "TIMEOUT");
    if (updateCount != 1) {
        log.error("订单{}修改状态失败，影响行数{}", order.getOrderId(), updateCount);
        throw new RuntimeException("订单状态修改失败"); // 触发事务回滚
    }
    
    // 3. 回补关联资源（库存、优惠券、座位等）
    try {
        // 回补库存
        inventoryService.releaseInventory(order.getSkuId(), order.getQuantity());
        // 回补优惠券（如果下单时锁定了优惠券）
        if (order.getCouponId() != null) {
            couponService.unlockCoupon(order.getUserId(), order.getCouponId());
        }
        // 回补座位/房间（票务/酒店订单）
        if (order.getOrderType().equals("TICKET")) {
            ticketService.unlockSeat(order.getSeatId());
        }
    } catch (Exception e) {
        log.error("订单{}资源回补失败", order.getOrderId(), e);
        throw new RuntimeException("资源回补失败"); // 触发事务回滚，订单状态恢复为待支付
    }
    
    // 4. 记录取消日志（用于问题排查）
    orderLogService.recordLog(order.getOrderId(), "ORDER_CANCELED", "订单超时自动取消");
    
    return true;
}

public void sendCancelNotice(OrderDO order) {
    // 1. 短信通知（核心渠道，确保用户能收到）
    smsService.send(order.getPhone(), String.format(
        "【XX平台】您的订单%s因超时未支付已自动取消，库存已释放，可重新下单。", 
        order.getOrderId()
    ));
    
    // 2. APP推送（针对已安装APP的用户）
    pushService.send(order.getUserId(), "订单取消通知", 
        String.format("订单%s已自动取消，原因：超时未支付", order.getOrderId()));
    
    // 3. 站内信（补充渠道）
    messageService.sendInboxMsg(order.getUserId(), "订单取消", 
        String.format("订单%s于%s因超时未支付自动取消，如有疑问请联系客服。", 
        order.getOrderId(), new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date())));
}