RabbitMQ如何保证队列里的消息99.99%被消费？

1. 本篇概要

其实，还有1种场景需要考虑：当消费者接收到消息后，还没处理完业务逻辑，消费者挂掉了，那消息也算丢失了？，比如用户下单，订单中心发送了1个消息到RabbitMQ里的队列，积分中心收到这个消息，准备给这个下单的用户增加20积分，但积分还没增加成功呢，积分中心自己挂掉了，导致数据出现问题。

那么如何解决这种问题呢？

为了保证消息被消费者成功的消费，RabbitMQ提供了消息确认机制(message acknowledgement)，本文主要讲解RabbitMQ中，如何使用消息确认机制来保证消息被消费者成功的消费，避免因为消费者突然宕机而引起的消息丢失。

2. 开启显式Ack模式

我们开启一个消费者的代码是这样的：

1// 创建队列消费者
2com.rabbitmq.client.Consumer consumer = new DefaultConsumer(channel) {
3    @Override
4    public void handleDelivery(String consumerTag, Envelope envelope,
5                               AMQP.BasicProperties properties, byte[] body) throws IOException {
6        String message = new String(body, "UTF-8");
7        System.out.println("Received Message '" + message + "'");
8    }
9};
10channel.basicConsume(QUEUE_NAME, true, consumer);

这里的重点是channel.basicConsume(QUEUE_NAME, true, consumer);方法的第2个参数，让我们先看下basicConsume()的源码：

1public String basicConsume(String queue, boolean autoAck, Consumer callback) throws IOException {
2    return this.basicConsume(queue, autoAck, "", callback);
3}

这里的autoAck参数指的是是否自动确认，如果设置为ture，RabbitMQ会自动把发送出去的消息置为确认，然后从内存（或者磁盘）中删除，而不管消费者接收到消息是否处理成功；如果设置为false，RabbitMQ会等待消费者显式的回复确认信号后才会从内存（或者磁盘）中删除。

建议将autoAck设置为false，这样消费者就有足够的时间处理消息，不用担心处理消息过程中消费者宕机造成消息丢失。

此时，队列里的消息就分成了2个部分：

等待投递给消费者的消息(下图中的Ready部分)
已经投递给消费者，但是还没有收到消费者确认信号的消息(下图中的Unacked部分)

如果RabbitMQ一直没有收到消费者的确认信号，并且消费此消息的消费者已经断开连接，则RabbitMQ会安排该消息重新进入队列，等待投递给下一个消费者，当然也有可能还是原来的那个消费者。

RabbitMQ不会为未确认的消息设置过期时间，它判断此消息是否需要重新投递给消费者的唯一依据是消费该消息的消费者连接是否已经断开，这么设计的原因是RabbitMQ允许消费者消费一条消息的时间可以很久很久。

为了便于理解，我们举个具体的例子，生产者的话的我们延用上文中的DurableProducer：

1package com.zwwhnly.springbootaction.rabbitmq.durable;
2
3import com.rabbitmq.client.AMQP;
4import com.rabbitmq.client.Channel;
5import com.rabbitmq.client.Connection;
6import com.rabbitmq.client.ConnectionFactory;
7
8import java.io.IOException;
9import java.util.concurrent.TimeoutException;
10
11public class DurableProducer {
12    private final static String EXCHANGE_NAME = "durable-exchange";
13    private final static String QUEUE_NAME = "durable-queue";
14
15    public static void main(String[] args) throws IOException, TimeoutException {
16        // 创建连接
17        ConnectionFactory factory = new ConnectionFactory();
18        // 设置 RabbitMQ 的主机名
19        factory.setHost("localhost");
20        // 创建一个连接
21        Connection connection = factory.newConnection();
22        // 创建一个通道
23        Channel channel = connection.createChannel();
24        // 创建一个Exchange
25        channel.exchangeDeclare(EXCHANGE_NAME, "direct", true);
26        channel.queueDeclare(QUEUE_NAME, true, false, false, null);
27        channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "");
28
29        // 发送消息
30        String message = "durable exchange test";
31        AMQP.BasicProperties props = new AMQP.BasicProperties().builder().deliveryMode(2).build();
32        channel.basicPublish(EXCHANGE_NAME, "", props, message.getBytes());
33
34        // 关闭频道和连接
35        channel.close();
36        connection.close();
37    }
38}

然后新建一个消费者AckConsumer类：

1package com.zwwhnly.springbootaction.rabbitmq.ack;
2
3import com.rabbitmq.client.*;
4
5import java.io.IOException;
6import java.util.concurrent.TimeoutException;
7
8public class AckConsumer {
9    private final static String QUEUE_NAME = "durable-queue";
10
11    public static void main(String[] args) throws IOException, TimeoutException {
12        // 创建连接
13        ConnectionFactory factory = new ConnectionFactory();
14        // 设置 RabbitMQ 的主机名
15        factory.setHost("localhost");
16        // 创建一个连接
17        Connection connection = factory.newConnection();
18        // 创建一个通道
19        Channel channel = connection.createChannel();
20        // 创建队列消费者
21        com.rabbitmq.client.Consumer consumer = new DefaultConsumer(channel) {
22            @Override
23            public void handleDelivery(String consumerTag, Envelope envelope,
24                                       AMQP.BasicProperties properties, byte[] body) throws IOException {
25                String message = new String(body, "UTF-8");
26                int result = 1 / 0;
27                System.out.println("Received Message '" + message + "'");
28            }
29        };
30        channel.basicConsume(QUEUE_NAME, true, consumer);
31    }
32}

我们先将autoAck参数设置为ture，即自动确认，并在消费消息时故意写个异常，然后先运行生产者客户端将消息写入队列中，然后运行消费者客户端，发现消息未消费成功但是却消失了：

然后我们将autoAck设置为false：

channel.basicConsume(QUEUE_NAME, false, consumer);

再次运行生产者客户端将消息写入队列中，然后运行消费者客户端，此时虽然消费者客户端仍然代码异常，但是消息仍然在队列中：

然后我们删除掉消费者客户端中的异常代码，重新启动消费者客户端，发现消息消费成功了，但是消息一直未Ack：

手动停掉消费者客户端，发现消息又到了Ready状态，准备重新投递：

之所以消费掉消息，却一直还是Unacked状态，是因为我们没在代码中添加显式的Ack代码：

1String message = new String(body, "UTF-8");
2//int result = 1 / 0;
3System.out.println("Received Message '" + message + "'");
4
5long deliveryTag = envelope.getDeliveryTag();
6channel.basicAck(deliveryTag, false);

deliveryTag可以看做消息的编号，它是一个64位的长整形值。

此时运行消费者客户端，发现消息消费成功，并且在队列中被移除：

RabbitMQ如何保证队列里的消息99.99%被消费？

1. 本篇概要

2. 开启显式Ack模式

点关注，不迷路，这是一个程序员都想要关注的二维码

评论区

相关推荐