如何实现超时未支付订单的自动取消机制

// 使用Spring Scheduled示例
@Scheduled(fixedRate = 60 * 1000)
public void cancelExpiredOrders() {
    LocalDateTime threshold = LocalDateTime.now().minusMinutes(30);
    List<Order> unpaidOrders = orderRepository.findByStatusAndCreateTimeBefore(
        OrderStatus.UNPAID, threshold);
    
    unpaidOrders.forEach(order -> {
        order.cancel();
        orderRepository.save(order);
        inventoryService.releaseStock(order.getItems());
    });
}

# 使用RabbitMQ死信队列
channel.exchange_declare(exchange='order_delay', type='x-delayed-message',
                        arguments={'x-delayed-type': 'direct'})
channel.queue_declare(queue='order_queue', arguments={
    'x-dead-letter-exchange': 'order_expired',
    'x-message-ttl': 1800000  # 30分钟
})

def callback(ch, method, properties, body):
    order_id = json.loads(body)['id']
    cancel_order(order_id)

// 使用Redis Stream消费延迟消息
async function consumeExpiredOrders() {
    while(true) {
        const result = await redis.xread(
            'BLOCK', 0, 'STREAMS', 'order_stream', '$'
        );
        const [orderId, createTime] = result[0][1];
        if(Date.now() - createTime > 1800000) {
            await cancelOrder(orderId);
            await redis.xdel('order_stream', orderId);
        }
    }
}

// 基于时间轮的实现
type TimeWheel struct {
    slots       []map[string]Order
    currentPos  int
    tick        time.Duration
    slotNum     int
}

func (tw *TimeWheel) AddOrder(order Order) {
    delay := order.CreateTime.Add(30 * time.Minute).Sub(time.Now())
    cycles := int(delay/(tw.tick*time.Duration(tw.slotNum)))
    pos := (tw.currentPos + int(delay/tw.tick)) % tw.slotNum
    tw.slots[pos][order.ID] = order
}

func (tw *TimeWheel) Start() {
    ticker := time.NewTicker(tw.tick)
    for range ticker.C {
        for id, order := range tw.slots[tw.currentPos] {
            cancelOrder(order)
            delete(tw.slots[tw.currentPos], id)
        }
        tw.currentPos = (tw.currentPos + 1) % tw.slotNum
    }
}

// 分页批量处理示例
int pageSize = 100;
int page = 0;
do {
    Pageable pageable = PageRequest.of(page, pageSize);
    Page<Order> orders = orderRepository.findExpiredOrders(pageable);
    orders.getContent().forEach(this::processOrder);
    page++;
} while (!orders.isLast());

# Redis缓存预热
def preheat_cache():
    orders = Order.objects.filter(expire_time__lte=timezone.now()+timedelta(minutes=5))
    pipeline = redis.pipeline()
    for order in orders:
        pipeline.zadd('expiring_orders', {order.id: order.expire_time.timestamp()})
    pipeline.execute()

// 补偿任务示例
@Scheduled(cron = "0 0 3 * * ?")
public void checkUnprocessedOrders() {
    LocalDateTime checkStart = LocalDateTime.now().minusHours(3);
    List<Order> abnormalOrders = orderRepository.findAbnormalOrders(checkStart);
    // 发送报警并记录日志
    monitoringService.alert(abnormalOrders);
}