@Service
public class OrderCancelService {
    @Autowired
    private OrderRepository orderRepository;
    @Scheduled(fixedRate = 60 * 1000) // 每分鐘執(zhí)行一次
    public void cancelUnpaidOrders() {
        Date thirtyMinutesAgo = new Date(System.currentTimeMillis() - 30 * 60 * 1000);
        List<Order> unpaidOrders = orderRepository.findByStatusAndCreateTimeBefore(OrderStatus.UNPAID, thirtyMinutesAgo);
        for (Order order : unpaidOrders) {
            // 執(zhí)行取消邏輯
            order.setStatus(OrderStatus.CANCELED);
            // 釋放庫(kù)存等操作
            releaseStock(order);
            // 發(fā)送通知
            sendCancelNotification(order);
            orderRepository.save(order);
        }
    }
    private void releaseStock(Order order) {
        // 具體庫(kù)存釋放邏輯
    }
    private void sendCancelNotification(Order order) {
        // 發(fā)送短信、APP通知等邏輯
    }
}

public class OrderService {
    private Timer timer = new Timer("OrderCancelTimer");
    public void createOrder(Order order) {
        // 保存訂單到數(shù)據(jù)庫(kù)
        saveOrder(order);
        // 安排取消任務(wù)
        scheduleCancelTask(order);
    }
    private void scheduleCancelTask(Order order) {
        long delay = 30 * 60 * 1000; // 30分鐘
        TimerTask task = new TimerTask() {
            @Override
            public void run() {
                // 檢查訂單狀態(tài)，防止重復(fù)取消或已支付的情況
                Order existingOrder = getOrderById(order.getId());
                if (existingOrder.getStatus() == OrderStatus.UNPAID) {
                    cancelOrder(existingOrder);
                }
            }
        };
        timer.schedule(task, delay);
    }
    private void cancelOrder(Order order) {
        // 執(zhí)行取消邏輯，更新數(shù)據(jù)庫(kù)等
    }
}

// 配置類(lèi)
@Configuration
public class RabbitMQConfig {
    // 死信源隊(duì)列
    public static final String DEAD_LETTER_QUEUE = "dead_letter_queue";
    // 死信交換器
    public static final String DEAD_LETTER_EXCHANGE = "dead_letter_exchange";
    // 死信路由鍵
    public static final String DEAD_LETTER_ROUTING_KEY = "dead_letter_routing_key";
    // 真正的死信隊(duì)列
    public static final String REAL_DEAD_LETTER_QUEUE = "real_dead_letter_queue";
    @Bean
    public Queue deadLetterQueue() {
        Map<String, Object> arguments = new HashMap<>();
        // 設(shè)置隊(duì)列過(guò)期時(shí)間30分鐘
        arguments.put("x-message-ttl", 30 * 60 * 1000);
        // 設(shè)置死信交換器
        arguments.put("x-dead-letter-exchange", DEAD_LETTER_EXCHANGE);
        // 設(shè)置死信路由鍵
        arguments.put("x-dead-letter-routing-key", DEAD_LETTER_ROUTING_KEY);
        return new Queue(DEAD_LETTER_QUEUE, true, false, false, arguments);
    }
    @Bean
    public Exchange deadLetterExchange() {
        return ExchangeBuilder.directExchange(DEAD_LETTER_EXCHANGE).durable(true).build();
    }
    @Bean
    public Queue realDeadLetterQueue() {
        return new Queue(REAL_DEAD_LETTER_QUEUE, true);
    }
    @Bean
    public Binding binding() {
        return BindingBuilder.bind(realDeadLetterQueue()).to(deadLetterExchange()).with(DEAD_LETTER_ROUTING_KEY).noargs();
    }
}
// 生產(chǎn)者，訂單創(chuàng)建時(shí)發(fā)送消息到死信源隊(duì)列
@Service
public class OrderProducer {
    @Autowired
    private RabbitTemplate rabbitTemplate;
    public void sendOrderToDeadLetterQueue(Order order) {
        // 將訂單信息轉(zhuǎn)換為JSON
        String orderJson = JSON.toJSONString(order);
        rabbitTemplate.convertAndSend(RabbitMQConfig.DEAD_LETTER_EXCHANGE, RabbitMQConfig.DEAD_LETTER_ROUTING_KEY, orderJson);
    }
}
// 消費(fèi)者，監(jiān)聽(tīng)真正的死信隊(duì)列
@Service
public class OrderConsumer {
    @RabbitListener(queues = RabbitMQConfig.REAL_DEAD_LETTER_QUEUE)
    public void handleDeadLetterMessage(String orderJson) {
        Order order = JSON.parseObject(orderJson, Order.class);
        // 執(zhí)行訂單取消邏輯
        cancelOrder(order);
    }
}

// Job類(lèi)
public class OrderCancelJob implements Job {
    @Autowired
    private OrderService orderService;
    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
        JobDataMap dataMap = context.getJobDetail().getJobDataMap();
        String orderId = dataMap.getString("orderId");
        orderService.cancelOrder(orderId);
    }
}
// 訂單創(chuàng)建時(shí)調(diào)度任務(wù)
public class OrderService {
    @Autowired
    private Scheduler scheduler;
    public void createOrder(Order order) {
        // 保存訂單
        saveOrder(order);
        // 調(diào)度取消任務(wù)
        scheduleCancelJob(order);
    }
    private void scheduleCancelJob(Order order) throws SchedulerException {
        // 創(chuàng)建JobDetail
        JobDetail jobDetail = JobBuilder.newJob(OrderCancelJob.class)
               .withIdentity("orderCancelJob_" + order.getId(), "orderCancelGroup")
               .usingJobData("orderId", order.getId().toString())
               .build();
        // 創(chuàng)建Trigger，30分鐘后觸發(fā)
        Trigger trigger = TriggerBuilder.newTrigger()
               .withIdentity("orderCancelTrigger_" + order.getId(), "orderCancelGroup")
               .startAt(new Date(System.currentTimeMillis() + 30 * 60 * 1000))
               .build();
        // 將Job和Trigger注冊(cè)到Scheduler
        scheduler.scheduleJob(jobDetail, trigger);
    }
}
// Quartz集群配置（application.properties）
# Quartz配置
quartz.job-store-type=jdbc
quartz.data-source=quartzDataSource
quartz.jdbc.driver=com.mysql.cj.jdbc.Driver
quartz.jdbc.url=jdbc:mysql://localhost:3306/quartz_db?useUnicode=true&characterEncoding=utf-8
quartz.jdbc.user=root
quartz.jdbc.password=123456
# 啟用集群
quartz.scheduler.instanceName=ClusterScheduler
quartz.scheduler.instanceId=AUTO
quartz.job-store-is-clustered=true

notify-keyspace-events Ex

// 訂單創(chuàng)建時(shí)存儲(chǔ)到Redis
@Service
public class OrderService {
    @Autowired
    private StringRedisTemplate stringRedisTemplate;
    public void createOrder(Order order) {
        // 保存訂單到數(shù)據(jù)庫(kù)
        saveOrderToDatabase(order);
        // 將訂單ID存儲(chǔ)到Redis，設(shè)置30分鐘過(guò)期
        stringRedisTemplate.opsForValue().set("order:unpaid:" + order.getId(), "1", 30, TimeUnit.MINUTES);
    }
}
// Redis監(jiān)聽(tīng)器
@Component
public class RedisKeyExpirationListener extends KeyExpirationEventMessageListener {
    private final ApplicationEventPublisher applicationEventPublisher;
    public RedisKeyExpirationListener(RedisMessageListenerContainer listenerContainer, ApplicationEventPublisher applicationEventPublisher) {
        super(listenerContainer);
        this.applicationEventPublisher = applicationEventPublisher;
    }
    @Override
    public void onMessage(Message message, byte[] pattern) {
        // 獲取過(guò)期的鍵
        String expiredKey = message.toString();
        if (expiredKey.startsWith("order:unpaid:")) {
            String orderId = expiredKey.split(":")[2];
            // 發(fā)布訂單過(guò)期事件
            applicationEventPublisher.publishEvent(new OrderExpiredEvent(this, orderId));
        }
    }
}
// 訂單過(guò)期事件處理
@Service
public class OrderExpiredEventHandler {
    @EventListener
    public void handleOrderExpiredEvent(OrderExpiredEvent event) {
        String orderId = event.getOrderId();
        // 查詢訂單狀態(tài)，防止已支付的情況
        Order order = getOrderFromDatabase(orderId);
        if (order.getStatus() == OrderStatus.UNPAID) {
            cancelOrder(order);
        }
    }
}