RabbitMQ 死信、消息堆积、延迟队列

于 2025-05-07 14:41:02 发布
阅读量360 收藏 4
点赞数 11
文章标签： rabbitmq java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/callback_CSDN/article/details/147763906
版权

一、引言

RabbitMQ 是一个功能强大的消息队列中间件，在 Java 开发中广泛应用。本文将详细介绍如何在 Java 中使用 RabbitMQ 实现死信队列、处理消息堆积问题以及实现延迟队列。

二、环境准备

2.1 引入依赖

在 Maven 项目中，需要引入 RabbitMQ 的 Java 客户端依赖：

<dependency>
    <groupId>com.rabbitmq</groupId>
    <artifactId>amqp-client</artifactId>
    <version>5.12.0</version>
</dependency>

2.2 启动 RabbitMQ 服务

确保 RabbitMQ 服务已经启动，可以通过以下命令启动：

rabbitmq-server

三、死信队列

3.1 概念

死信队列（Dead Letter Queue，DLQ）用于处理无法被正常消费的消息。当消息满足以下条件时，会被发送到死信队列：

  • 消息被拒绝（basic.reject 或 basic.nack）且 requeue 参数设置为 false。
  • 消息过期。
  • 队列达到最大长度。

3.2 实现步骤

3.2.1 创建死信交换机和死信队列

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;

import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.TimeoutException;

public class DeadLetterQueueSetup {
    private static final String DEAD_LETTER_EXCHANGE = "dlx.exchange";
    private static final String DEAD_LETTER_QUEUE = "dlx.queue";
    private static final String EXCHANGE_NAME = "normal.exchange";
    private static final String QUEUE_NAME = "normal.queue";

    public static void main(String[] args) throws IOException, TimeoutException {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        try (Connection connection = factory.newConnection();
             Channel channel = connection.createChannel()) {
            // 创建死信交换机
            channel.exchangeDeclare(DEAD_LETTER_EXCHANGE, "direct");
            // 创建死信队列
            channel.queueDeclare(DEAD_LETTER_QUEUE, false, false, false, null);
            // 绑定死信队列到死信交换机
            channel.queueBind(DEAD_LETTER_QUEUE, DEAD_LETTER_EXCHANGE, "dlx.routing.key");

            // 创建普通交换机
            channel.exchangeDeclare(EXCHANGE_NAME, "direct");
            // 为普通队列设置死信交换机
            Map<String, Object> argsMap = new HashMap<>();
            argsMap.put("x-dead-letter-exchange", DEAD_LETTER_EXCHANGE);
            argsMap.put("x-dead-letter-routing-key", "dlx.routing.key");
            // 创建普通队列
            channel.queueDeclare(QUEUE_NAME, false, false, false, argsMap);
            // 绑定普通队列到普通交换机
            channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "normal.routing.key");
        }
    }
}

3.2.2 生产者发送消息

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class Producer {
    private static final String EXCHANGE_NAME = "normal.exchange";

    public static void main(String[] args) throws IOException, TimeoutException {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        try (Connection connection = factory.newConnection();
             Channel channel = connection.createChannel()) {
            String message = "Hello, RabbitMQ!";
            channel.basicPublish(EXCHANGE_NAME, "normal.routing.key", null, message.getBytes("UTF-8"));
            System.out.println(" [x] Sent '" + message + "'");
        }
    }
}

3.2.3 消费者拒绝消息

import com.rabbitmq.client.*;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class Consumer {
    private static final String QUEUE_NAME = "normal.queue";

    public static void main(String[] args) throws IOException, TimeoutException {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();

        DeliverCallback deliverCallback = (consumerTag, delivery) -> {
            String message = new String(delivery.getBody(), "UTF-8");
            System.out.println(" [x] Received '" + message + "'");
            try {
                // 拒绝消息并设置 requeue 为 false
                channel.basicReject(delivery.getEnvelope().getDeliveryTag(), false);
            } catch (IOException e) {
                e.printStackTrace();
            }
        };
        channel.basicConsume(QUEUE_NAME, false, deliverCallback, consumerTag -> { });
    }
}

3.2.4 死信队列消费者

import com.rabbitmq.client.*;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class DeadLetterConsumer {
    private static final String DEAD_LETTER_QUEUE = "dlx.queue";

    public static void main(String[] args) throws IOException, TimeoutException {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();

        DeliverCallback deliverCallback = (consumerTag, delivery) -> {
            String message = new String(delivery.getBody(), "UTF-8");
            System.out.println(" [x] Received from DLQ: '" + message + "'");
            try {
                channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);
            } catch (IOException e) {
                e.printStackTrace();
            }
        };
        channel.basicConsume(DEAD_LETTER_QUEUE, false, deliverCallback, consumerTag -> { });
    }
}

四、消息堆积处理

4.1 概念

消息堆积是指消息在队列中不断积累，导致队列长度不断增加，可能会影响系统的性能和稳定性。

4.2 处理方法

4.2.1 增加消费者数量

可以通过启动多个消费者实例来加快消息的消费速度，从而减少消息堆积。

4.2.2 优化消费者处理逻辑

确保消费者的处理逻辑高效，避免出现长时间的阻塞操作。

4.2.3 设置队列最大长度

可以通过设置队列的最大长度，当队列达到最大长度时，新的消息将被拒绝或发送到死信队列。

Map<String, Object> args = new HashMap<>();
args.put("x-max-length", 1000); // 设置队列最大长度为 1000
channel.queueDeclare(QUEUE_NAME, false, false, false, args);

五、延迟队列

5.1 概念

延迟队列用于处理需要在一定时间后才能处理的消息。

5.2 实现方法

5.2.1 使用消息过期时间和死信队列

可以通过设置消息的过期时间，当消息过期后，将其发送到死信队列，然后在死信队列中进行消费，从而实现延迟队列的功能。

5.2.2 生产者发送延迟消息

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;

import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.TimeoutException;

public class DelayProducer {
    private static final String EXCHANGE_NAME = "normal.exchange";

    public static void main(String[] args) throws IOException, TimeoutException {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        try (Connection connection = factory.newConnection();
             Channel channel = connection.createChannel()) {
            String message = "Delayed message";
            Map<String, Object> headers = new HashMap<>();
            headers.put("x-delay", 5000); // 设置延迟时间为 5 秒
            AMQP.BasicProperties properties = new AMQP.BasicProperties.Builder()
                   .headers(headers)
                   .build();
            channel.basicPublish(EXCHANGE_NAME, "normal.routing.key", properties, message.getBytes("UTF-8"));
            System.out.println(" [x] Sent '" + message + "'");
        }
    }
}

5.2.3 消费者处理延迟消息

import com.rabbitmq.client.*;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class DelayConsumer {
    private static final String DEAD_LETTER_QUEUE = "dlx.queue";

    public static void main(String[] args) throws IOException, TimeoutException {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();

        DeliverCallback deliverCallback = (consumerTag, delivery) -> {
            String message = new String(delivery.getBody(), "UTF-8");
            System.out.println(" [x] Received delayed message: '" + message + "'");
            try {
                channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);
            } catch (IOException e) {
                e.printStackTrace();
            }
        };
        channel.basicConsume(DEAD_LETTER_QUEUE, false, deliverCallback, consumerTag -> { });
    }
}

六、总结

通过本文的介绍，你可以在 Java 中使用 RabbitMQ 实现死信队列、处理消息堆积问题以及实现延迟队列。这些技术可以帮助你提高系统的可靠性和稳定性，确保消息的正确处理。

故事很腻i
关注
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值