RabbitMQ 超时取消订单处理：使用死信队列实现

最新推荐文章于 2025-10-21 20:28:53 发布

原创最新推荐文章于 2025-10-21 20:28:53 发布 · 698 阅读

CC 4.0 BY-SA版权

文章标签：

在电商系统中，订单处理是一个关键环节。为了提高用户体验和系统效率，我们需要确保订单在一定时间内得到处理。如果订单处理超时，我们需要及时取消订单以释放资源。RabbitMQ 提供了死信队列（Dead Letter Exchange）功能，可以用于处理这类超时订单的情况。

一、背景介绍

RabbitMQ 是一个开源的消息代理软件，它支持多种消息协议。死信队列是 RabbitMQ 的一个高级特性，用于处理无法被正常消费的消息。在订单处理场景中，我们可以利用死信队列来监控订单处理时间，一旦超时，自动触发订单取消流程。

二、系统设计

1. 订单消息定义

首先，我们需要定义订单消息的结构。每个订单消息包含订单ID、用户ID、商品信息以及处理的截止时间戳。

public class OrderMessage {
    private String orderId;
    private String userId;
    private String productInfo;
    private long processDeadline; // 处理截止时间戳

    // 构造函数、getter 和 setter 省略
}

2. 消息生产者

消息生产者负责创建订单消息并发送到RabbitMQ的交换机。我们需要设置消息的过期时间，这样一旦订单处理超时，消息就会被发送到死信队列。

import com.rabbitmq.client.*;

public class OrderProducer {
    public static final String EXCHANGE_NAME = "orders";

    public void send(OrderMessage message) throws IOException {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();

        channel.exchangeDeclare(EXCHANGE_NAME, "direct");
        String routingKey = "order." + message.getOrderId();
        String queueName = "order.queue";

        channel.queueDeclare(queueName, true, false, false, null);
        channel.basicPublish(EXCHANGE_NAME, routingKey, messageToBytes(message));

        channel.close();
        connection.close();
    }

    private byte[] messageToBytes(OrderMessage message) {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(baos);
        try {
            oos.writeObject(message);
            oos.flush();
            return baos.toByteArray();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

3. 消息消费者

消息消费者从队列中消费订单消息，并处理订单。如果处理时间超过截止时间戳，消费者将不会消费该消息，消息将被发送到死信队列。

import com.rabbitmq.client.*;

public class OrderConsumer {
    public static final String QUEUE_NAME = "order.queue";
    public static final String DLX_NAME = "order.dlx";

    public void consume() throws IOException {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();

        channel.exchangeDeclare(OrderProducer.EXCHANGE_NAME, "direct");
        channel.queueDeclare(QUEUE_NAME, true, false, false, null);
        channel.queueBind(OrderProducer.EXCHANGE_NAME, "order.*", QUEUE_NAME);
        channel.basicConsume(QUEUE_NAME, true, (consumerTag, delivery) -> {
            try {
                OrderMessage message = (OrderMessage) new ObjectInputStream(new ByteArrayInputStream(delivery.getBody())).readObject();
                if (System.currentTimeMillis() > message.getProcessDeadline()) {
                    System.out.println("Order " + message.getOrderId() + " is overdue");
                    channel.basicReject(delivery.getEnvelope().getDeliveryTag(), false);
                // 处理订单超时逻辑
                    handleOrderOverdue(message);
                // 确认消息
                channel.basicAck(delivery.getEnvelope().getDeliveryTag());
            } catch (IOException | ClassNotFoundException e) {
                e.printStackTrace();
            }
        });

        channel.close();
        connection.close();
    }

    private void handleOrderOverdue(OrderMessage message) {
        // 实现订单超时的处理逻辑
        System.out.println("Cancel order " + message.getOrderId());
    }
}

4. 死信队列配置

我们需要配置死信队列，以便处理超时的订单消息。

import com.rabbitmq.client.*;

public class DeadLetterConfig {
    public static final String DLX_NAME = "order.dlx";

    public void configureDeadLetterExchange(Channel channel) throws IOException {
        channel.exchangeDeclare(DLX_NAME, "direct");
        channel.queueDeclare(DLX_NAME, true, false, false, new Arguments().add("x-dead-letter-exchange", DLX_NAME));
        channel.queueBind(DLX_NAME, "order.*", DLX_NAME);
    }
}

三、整合到Spring Boot

在Spring Boot应用中，我们可以创建一个配置类来设置RabbitMQ的连接和队列。

import org.springframework.amqp.rabbit.annotation.EnableRabbit;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.amqp.rabbit.config.SimpleRabbitListenerContainerFactoryConfigurer;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.amqp.rabbit.listener.api.ChannelAwareMessageListenerAdapter;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
@EnableRabbit
public class RabbitMQConfig {

    @Bean
    public SimpleRabbitListenerContainerFactoryConfigurer configureRabbitListenerContainerFactory() {
        SimpleRabbitListenerContainerFactoryConfigurer configurer = new SimpleRabbitListenerContainerConfigurer();
        configurer.setConcurrentFactory(rabbitConnectionFactory());
        return configurer;
    }

    @Bean
    public RabbitTemplate rabbitTemplate(ConnectionFactory connectionFactory) {
        return new RabbitTemplate(connectionFactory);
    }

    @Bean
    public ChannelAwareMessageListenerAdapter messageListenerAdapter(RabbitTemplate rabbitTemplate) {
        return new ChannelAwareMessageListenerAdapter(rabbitTemplate);
    }

    @Bean
    public OrderConsumer orderConsumer() {
        return new OrderConsumer();
    }

    @Bean
    public OrderProducer orderProducer() {
        return new OrderProducer();
    }

    @Bean
    public DeadLetterConfig deadLetterConfig() {
        return new DeadLetterConfig();
    }
}

四、测试订单处理

在Spring Boot应用中，我们可以创建一个控制器来触发订单处理流程。

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class OrderController {

    @Autowired
    private OrderProducer orderProducer;

    @GetMapping("/sendOrder")
    public String sendOrder() throws IOException {
        OrderMessage message = new OrderMessage();
        message.setOrderId("12345");
        message.setUserId("user123");
        message.setProductInfo("Product A");
        message.setProcessDeadline(System.currentTimeMillis() + 10000); // 10秒后超时

        orderProducer.send(message);
        return "Order sent";
    }
}