import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Service;
import javax.transaction.Transactional;
import java.util.Date;
import java.util.List;

@Service
public class OrderCancelService {

    @Autowired
    private OrderRepository orderRepository;

    @Autowired
    private InventoryService inventoryService;

    // 每5分鐘執(zhí)行一次掃描任務(wù)
    @Scheduled(fixedRate = 5 * 60 * 1000) 
    @Transactional
    public void cancelOverdueOrders() {
        // 計(jì)算30分鐘前的時(shí)間點(diǎn)
        Date overdueTime = new Date(System.currentTimeMillis() - 30 * 60 * 1000);
        
        // 查詢所有未支付且創(chuàng)建時(shí)間超過30分鐘的訂單
        List<Order> overdueOrders = orderRepository.findByStatusAndCreateTimeBefore(
            OrderStatus.UNPAID, overdueTime);
        
        for (Order order : overdueOrders) {
            try {
                // 加鎖防止并發(fā)操作
                order = orderRepository.lockById(order.getId());
                
                // 再次檢查訂單狀態(tài)（樂觀鎖）
                if (order.getStatus() == OrderStatus.UNPAID) {
                    // 釋放庫存
                    inventoryService.releaseStock(order.getProductId(), order.getQuantity());
                    
                    // 更新訂單狀態(tài)為已取消
                    order.setStatus(OrderStatus.CANCELED);
                    orderRepository.save(order);
                    
                    // 記錄操作日志
                    log.info("訂單{}已超時(shí)取消", order.getId());
                }
            } catch (Exception e) {
                // 記錄異常日志，進(jìn)行補(bǔ)償處理
                log.error("取消訂單失敗: {}", order.getId(), e);
            }
        }
    }
}

import java.util.concurrent.DelayQueue;
import java.util.concurrent.Delayed;
import java.util.concurrent.TimeUnit;

// 訂單延遲對(duì)象，實(shí)現(xiàn)Delayed接口
class OrderDelayItem implements Delayed {
    private final String orderId;
    private final long expireTime; // 到期時(shí)間（毫秒）

    public OrderDelayItem(String orderId, long delayTime) {
        this.orderId = orderId;
        this.expireTime = System.currentTimeMillis() + delayTime;
    }

    // 獲取剩余延遲時(shí)間
    @Override
    public long getDelay(TimeUnit unit) {
        long diff = expireTime - System.currentTimeMillis();
        return unit.convert(diff, TimeUnit.MILLISECONDS);
    }

    // 比較元素順序，用于隊(duì)列排序
    @Override
    public int compareTo(Delayed other) {
        return Long.compare(this.expireTime, ((OrderDelayItem) other).expireTime);
    }

    public String getOrderId() {
        return orderId;
    }
}

// 訂單延遲處理服務(wù)
@Service
public class OrderDelayService {
    private final DelayQueue<OrderDelayItem> delayQueue = new DelayQueue<>();
    
    @Autowired
    private OrderService orderService;
    
    @PostConstruct
    public void init() {
        // 啟動(dòng)處理線程
        Thread processor = new Thread(() -> {
            while (!Thread.currentThread().isInterrupted()) {
                try {
                    // 從隊(duì)列中獲取到期的訂單
                    OrderDelayItem item = delayQueue.take();
                    
                    // 處理超時(shí)訂單
                    orderService.cancelOrder(item.getOrderId());
                    
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                    log.error("延遲隊(duì)列處理被中斷", e);
                } catch (Exception e) {
                    log.error("處理超時(shí)訂單失敗", e);
                }
            }
        });
        
        processor.setDaemon(true);
        processor.start();
    }
    
    // 添加訂單到延遲隊(duì)列
    public void addOrderToDelayQueue(String orderId, long delayTimeMillis) {
        delayQueue.put(new OrderDelayItem(orderId, delayTimeMillis));
    }
}

import org.springframework.data.redis.connection.Message;
import org.springframework.data.redis.connection.MessageListener;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;

// Redis過期鍵監(jiān)聽器
@Component
public class RedisKeyExpirationListener implements MessageListener {

    @Autowired
    private RedisTemplate<String, String> redisTemplate;
    
    @Autowired
    private OrderService orderService;

    // 監(jiān)聽Redis的過期事件頻道
    @Override
    public void onMessage(Message message, byte[] pattern) {
        // 獲取過期的Key（訂單ID）
        String orderId = message.toString();
        
        // 檢查訂單是否存在且未支付
        if (redisTemplate.hasKey("order_status:" + orderId)) {
            String status = redisTemplate.opsForValue().get("order_status:" + orderId);
            
            if ("UNPAID".equals(status)) {
                // 執(zhí)行訂單取消操作
                orderService.cancelOrder(orderId);
            }
        }
    }
}

// 訂單服務(wù)
@Service
public class OrderService {
    @Autowired
    private RedisTemplate<String, String> redisTemplate;
    
    // 創(chuàng)建訂單時(shí)，將訂單ID存入Redis并設(shè)置30分鐘過期
    public void createOrder(Order order) {
        // 保存訂單到數(shù)據(jù)庫
        orderRepository.save(order);
        
        // 將訂單狀態(tài)存入Redis，設(shè)置30分鐘過期
        redisTemplate.opsForValue().set(
            "order_status:" + order.getId(), 
            "UNPAID", 
            30, 
            TimeUnit.MINUTES
        );
    }
    
    // 支付成功時(shí)，刪除Redis中的鍵
    public void payOrder(String orderId) {
        // 更新訂單狀態(tài)
        orderRepository.updateStatus(orderId, OrderStatus.PAID);
        
        // 刪除Redis中的鍵，避免觸發(fā)過期事件
        redisTemplate.delete("order_status:" + orderId);
    }
    
    // 取消訂單
    public void cancelOrder(String orderId) {
        // 檢查訂單狀態(tài)
        Order order = orderRepository.findById(orderId).orElse(null);
        if (order != null && order.getStatus() == OrderStatus.UNPAID) {
            // 釋放庫存等操作
            inventoryService.releaseStock(order.getProductId(), order.getQuantity());
            
            // 更新訂單狀態(tài)
            order.setStatus(OrderStatus.CANCELED);
            orderRepository.save(order);
        }
    }
}

import org.springframework.amqp.core.*;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Service;

@Service
public class OrderMQService {
    // 延遲隊(duì)列交換機(jī)
    public static final String DELAY_EXCHANGE = "order.delay.exchange";
    // 延遲隊(duì)列名稱
    public static final String DELAY_QUEUE = "order.delay.queue";
    // 死信交換機(jī)
    public static final String DEAD_LETTER_EXCHANGE = "order.deadletter.exchange";
    // 死信隊(duì)列（實(shí)際處理隊(duì)列）
    public static final String DEAD_LETTER_QUEUE = "order.deadletter.queue";
    // 路由鍵
    public static final String ROUTING_KEY = "order.cancel";

    @Autowired
    private RabbitTemplate rabbitTemplate;
    
    @Autowired
    private OrderService orderService;

    // 配置延遲隊(duì)列
    @Bean
    public DirectExchange delayExchange() {
        return new DirectExchange(DELAY_EXCHANGE);
    }

    // 配置死信隊(duì)列
    @Bean
    public DirectExchange deadLetterExchange() {
        return new DirectExchange(DEAD_LETTER_EXCHANGE);
    }

    // 配置延遲隊(duì)列，設(shè)置死信交換機(jī)
    @Bean
    public Queue delayQueue() {
        Map<String, Object> args = new HashMap<>();
        // 設(shè)置死信交換機(jī)
        args.put("x-dead-letter-exchange", DEAD_LETTER_EXCHANGE);
        // 設(shè)置死信路由鍵
        args.put("x-dead-letter-routing-key", ROUTING_KEY);
        return new Queue(DELAY_QUEUE, true, false, false, args);
    }

    // 配置死信隊(duì)列（實(shí)際處理隊(duì)列）
    @Bean
    public Queue deadLetterQueue() {
        return new Queue(DEAD_LETTER_QUEUE, true);
    }

    // 綁定延遲隊(duì)列到延遲交換機(jī)
    @Bean
    public Binding delayBinding() {
        return BindingBuilder.bind(delayQueue()).to(delayExchange()).with(ROUTING_KEY);
    }

    // 綁定死信隊(duì)列到死信交換機(jī)
    @Bean
    public Binding deadLetterBinding() {
        return BindingBuilder.bind(deadLetterQueue()).to(deadLetterExchange()).with(ROUTING_KEY);
    }

    // 發(fā)送訂單消息到延遲隊(duì)列
    public void sendOrderDelayMessage(String orderId, long delayTime) {
        rabbitTemplate.convertAndSend(DELAY_EXCHANGE, ROUTING_KEY, orderId, message -> {
            // 設(shè)置消息TTL（毫秒）
            message.getMessageProperties().setExpiration(String.valueOf(delayTime));
            return message;
        });
    }

    // 消費(fèi)死信隊(duì)列消息（處理超時(shí)訂單）
    @RabbitListener(queues = DEAD_LETTER_QUEUE)
    public void handleExpiredOrder(String orderId) {
        try {
            // 處理超時(shí)訂單
            orderService.cancelOrder(orderId);
        } catch (Exception e) {
            log.error("處理超時(shí)訂單失敗: {}", orderId, e);
            // 可添加重試機(jī)制或補(bǔ)償邏輯
        }
    }
}

import io.netty.util.HashedWheelTimer;
import io.netty.util.Timeout;
import io.netty.util.Timer;
import io.netty.util.TimerTask;
import java.util.concurrent.TimeUnit;

// 訂單超時(shí)處理服務(wù)
@Service
public class OrderTimeoutService {
    // 創(chuàng)建時(shí)間輪，每100毫秒滾動(dòng)一次，最多處理1024個(gè)槽
    private final Timer timer = new HashedWheelTimer(100, TimeUnit.MILLISECONDS, 1024);
    
    @Autowired
    private OrderService orderService;

    // 添加訂單超時(shí)任務(wù)
    public void addOrderTimeoutTask(String orderId, long delayTimeMillis) {
        timer.newTimeout(new TimerTask() {
            @Override
            public void run(Timeout timeout) throws Exception {
                try {
                    // 處理超時(shí)訂單
                    orderService.cancelOrder(orderId);
                } catch (Exception e) {
                    log.error("處理超時(shí)訂單失敗: {}", orderId, e);
                    
                    // 可添加重試機(jī)制
                    if (!timeout.isCancelled()) {
                        timeout.timer().newTimeout(this, 5, TimeUnit.SECONDS);
                    }
                }
            }
        }, delayTimeMillis, TimeUnit.MILLISECONDS);
    }
    
    // 訂單支付成功時(shí)，取消超時(shí)任務(wù)
    public void cancelTimeoutTask(String orderId) {
        // 實(shí)現(xiàn)略，需維護(hù)任務(wù)ID與訂單ID的映射關(guān)系
    }
}