SpringBoot订单超时自动取消的三种主流实现方案

@EnableScheduling
@Component
@RequiredArgsConstructor
public class OrderCancelSchedule {

    private final OrderService orderService;

    /** 每 30s 跑一次，可根据数据量调整 */
    @Scheduled(fixedDelay = 30_000)
    public void cancelUnpaidOrders() {
        LocalDateTime expirePoint = LocalDateTime.now().minusMinutes(30);
        List<Long> ids = orderService.findUnpaidBefore(expirePoint);
        if (!ids.isEmpty()) {
            int affected = orderService.batchCancel(ids);
            log.info("自动取消订单 {} 条", affected);
        }
    }
}

CREATE INDEX idx_order_status_created ON t_order(status, created_time);

Producer ──> Delay Exchange (x-delayed-message) ──> 30min TTL ──> Cancel Queue ──> Consumer

@Configuration
public class RabbitDelayConfig {

    @Bean
    public CustomExchange delayExchange() {
        Map<String, Object> args = Map.of("x-delayed-type", "direct");
        return new CustomExchange("order.delay", "x-delayed-message", true, false, args);
    }

    @Bean
    public Queue cancelQueue() {
        return QueueBuilder.durable("order.cancel.queue").build();
    }

    @Bean
    public Binding binding() {
        return BindingBuilder.bind(cancelQueue()).to(delayExchange()).with("order.cancel").noargs();
    }
}

@Service
@RequiredArgsConstructor
public class OrderPublisher {
    private final RabbitTemplate rabbitTemplate;

    public void createOrder(Order order) {
        // 1. 落库
        orderMapper.insert(order);
        // 2. 发送延迟消息
        rabbitTemplate.convertAndSend(
            "order.delay",
            "order.cancel",
            order.getId(),
            msg -> {
                msg.getMessageProperties().setDelay(30 * 60 * 1000); // 30 min
                return msg;
            }
        );
    }
}

@Component
@RabbitListener(queues = "order.cancel.queue")
public class CancelConsumer {
    private final OrderService orderService;

    @RabbitHandler
    public void handle(Long orderId) {
        Order order = orderService.find(orderId);
        if (order != null && order.getStatus() == OrderStatus.PENDING) {
            orderService.cancel(orderId);
        }
    }
}

# redis.conf
notify-keyspace-events Ex

CONFIG SET notify-keyspace-events Ex

@Service
public class OrderService {
    private final StringRedisTemplate redisTemplate;

    public void createOrder(Order order) {
        orderMapper.insert(order);
        // value 随意，这里用 id
        redisTemplate.opsForValue()
          .set("order:" + order.getId(),
               String.valueOf(order.getId()),
               Duration.ofMinutes(30));
    }
}

@Configuration
public class RedisListenerConfig {

    @Bean
    public RedisMessageListenerContainer container(RedisConnectionFactory cf) {
        RedisMessageListenerContainer container = new RedisMessageListenerContainer();
        container.setConnectionFactory(cf);
        container.addMessageListener(
            (message, pattern) -> {
                String key = message.toString();
                if (key.startsWith("order:")) {
                    String orderId = key.substring(6);
                    // 幂等取消
                    orderService.cancelIfUnpaid(Long.valueOf(orderId));
                }
            },
            new PatternTopic("__keyevent@*__:expired")
        );
        return container;
    }
}