RabbitMQ发布订阅模式多实例消费者防止重复消费实现方式

书接上回。
上一篇文章中已经通过一个实际的业务场景结合RabbitMQ的四种交换机类型对RabbitMQ发布订阅模式同一消费者多个实例如何防止重复消费这个问题给出了解决方案。结尾的时候挖了个坑，水这篇的目的就是要把这个坑填上，给大家提供一个可以直接抄作业的代码。
先把一些参数提前公布出来，后面代码里面再遇到就不逐个解释了

• RabbitMQ主机地址127.0.0.1，如果是部署在其他机器上的，就把IP地址替换成相应的主机IP或者域名。
  
• 如果使用默认端口5672，连接地址可以不用写，映射到其他端口的话在主机地址上面加上。
  
• 采用默认的用户名和密码guest，根据具体情况进行相应替换。
  
• 预定交换机名称demo.event，根据具体情况进行相应替换。
  
• 预定队列名称demo.event.queue，根据具体情况进行相应替换。
  
• 队列demo.event.queue上有两个消费者，另外再生成一个只有一个消费者的随机名称队列。
  

要达到的效果

生产者发送一条消息到交换机demo.event，再由交换机分发到绑定给它的队列上，demo.event.queue队列上的消费者只有一个能收到，其他随机队列的消费者（只有一个）也能收到消息。

一、准备RabbitMQ环境

我是在docker上部署的，到官方网站下载Docker Desktop直接安装就可以了，这里不再赘述。RabbitMQ的环境准备不是本篇的重点，这里只提供最基本的用法，有其他需求可以略过这一章节，去RabbitMQ或者Docker官网按照文档配置即可。
拉取镜像

我用的是带管理后台的rabbitmq:management。
打开控制台/终端，输入

1. docker pull rabbitmq:management

复制代码

创建Volumes

1. docker volume create rabbitmq

复制代码

创建容器

1. docker run -d --name rabbitmq -p 4369:4369 -p 5671:5671 -p 5672:5672 -p 15671:15671 -p 15672:15672 -p 25672:25672 -p 15691:15691 -p 15692:15692 -v rabbitmq:/var/lib/rabbitmq rabbitmq:management

复制代码

执行完以上代码后，容器会自动启动。
二、.net + RabbitMQ.Client

先准备IDE，Visual Studio、VS Code、Rider都可以。
我这里用的LinqPad，这是一个可以快速执行C#、VB、F#代码块和SQL的工具，使用Microsoft Roslyn进行编译，支持引入NuGet包和三方DLL文件，可以直接运行Asp.Net Core服务。Ver9开始支持macOS，渲染层由之前的WPF改成了AvaloniaUI。有需要的可以使用下面的链接购买
https://www.linqpad.net/Purchase.aspx?affiliate=8ucu28vs
1、依赖包

RabbitMQ.Client
LinqPad通过自带工具添加，正经IDE通过NuGet Manager、CLI工具添加或者在csproj引入

1. [/code]如果项目使用集中版本管理，需要在Directory.Packages.props添加
2. [code]

复制代码

然后在具体项目的csproj添加

1. [/code]需要注意的是，7.x以后RabbitMQ.Client做了比较大的调整，原先的方法都改成了异步，EventingBasicConsumer也换成了AsyncEventingBasicConsumer，Consumer的Receive事件变成了ReceivedAsync，支持异步事件处理。
2. [size=3]2、生产者代码[/size]
4. [code]async Task Main()
5. {
6.         var factory = new ConnectionFactory { Uri = new Uri("amqp://guest:guest@127.0.0.1") };
7.         using (var connection = await factory.CreateConnectionAsync())
8.         {
9.                 using (var channel = await connection.CreateChannelAsync())
10.                 {
11.                         await channel.ExchangeDeclareAsync(exchange: "demo.event", type: ExchangeType.Fanout, durable: true, autoDelete: true);
13.                         while (true)
14.                         {
15.                                 var message = Console.ReadLine();
16.                                 var body = Encoding.UTF8.GetBytes(message);
17.                                 var properties = new BasicProperties();
18.                                 await channel.BasicPublishAsync(exchange: "demo.event", routingKey: "", mandatory: true, basicProperties: properties, body: body, cancellationToken: default);
19.                         }
20.                 }
21.         }
22. }
24. // Define other methods, classes and namespaces here

复制代码

3、消费者代码

1. async Task Main()
2. {
3.         var factory = new ConnectionFactory { Uri = new Uri("amqp://guest:guest@127.0.0.1") };
4.         await using (var connection = await factory.CreateConnectionAsync())
5.         {
6.                 using (var channel = await connection.CreateChannelAsync())
7.                 {
8.                         await channel.ExchangeDeclareAsync(exchange: "demo.event", type: ExchangeType.Fanout, durable: true, autoDelete: true);
9.                         var queueName = await channel.QueueDeclareAsync("demo.event.queue", true, false, true).ContinueWith(task => task.Result.QueueName); // 客户端制定队列名称。
10.                         await channel.QueueBindAsync(queue: queueName,
11.                                                           exchange: "demo.event",
12.                                                           routingKey: "");
13.                         Console.WriteLine(" [*] Waiting for logs.");
15.                         var consumer = new AsyncEventingBasicConsumer(channel);
16.                         consumer.ReceivedAsync += async (model, ea) =>
17.                         {
18.                                 var body = ea.Body.ToArray();
19.                                 var message = Encoding.UTF8.GetString(body);
20.                                 Console.WriteLine(" [x] {0}", message);
21.                         };
22.                         await channel.BasicConsumeAsync(queue: "", autoAck: true, consumer: consumer);
23.                         Console.WriteLine(" Press [enter] to exit.");
24.                         Console.ReadLine();
25.                 }
26.         }
27. }
29. // Define other methods, classes and namespaces here

复制代码

3、开始测试

在LinqPad里面每个标签的代码是完全隔离的，无法引用，所以为了启动多个消费者，我需要把消费者的代码块再复制两份出来。其中一个标签把

1. var queueName = await channel.QueueDeclareAsync("demo.event.queue", true, false, false).ContinueWith(task => task.Result.QueueName);

复制代码

改成

1. var queueName = await channel.QueueDeclareAsync().ContinueWith(task => task.Result.QueueName); // 由RabbitMQ生成队列名称

复制代码

先运行三个消费者代码开始监听队列消息。再运行生产者代码。

消费者1、消费者2队列名称都是手动指定的demo.event.queue

消费者3队列名称是服务端生成的amq.gen-vFbhNYiLf4wDdKNdmP2WzQ

在生产者发送一条消息 Hello, World!，我们再看下接收情况

消费者1、3收到消息，消费者2没有收到，再发一条Second message.

消费者2、3收到消息，消费者1没有收到。
结论是：目标达成。
三、Java + Maven + amqp-client

1、依赖包

com.rabbitmq:amqp-client，版本号根据实际需要选择
使用Maven工具安装或者直接在pom.xml里添加

1. <dependencies>
2.   <dependency>
3.     <groupId>com.rabbitmq</groupId>
4.     amqp-client</artifactId>
5.     <version>5.25.0</version>
6.   </dependency>
7. </dependencies>

复制代码

2、生产者代码

1. public class Main {
2.     public static void main(String[] args) throws Exception {
3.         var factory = new ConnectionFactory();
4.         factory.setHost("127.0.0.1");
5.         factory.setUsername("guest");
6.         factory.setPassword("guest");
7.         var connection = factory.newConnection();
8.         var channel = connection.createChannel();
9.         channel.exchangeDeclare("demo.event", "fanout", true, true, null);
11.         while (true) {
12.             var message = java.lang.IO.readln();
13.             var properties = new AMQP.BasicProperties.Builder().build();
14.             channel.basicPublish("demo.event", "", true, properties, message.getBytes());
15.             System.out.println(" [x] Sent '" + message + "'");
16.         }
17.     }
18. }

复制代码

3、消费者代码

1. public class Main {
2.     public static void main(String[] args) throws Exception {
3.         String recipientName = args[0];
4.         String queueName = args.length > 1 ? args[1] : "";
6.         var factory = new com.rabbitmq.client.ConnectionFactory();
7.         factory.setHost("127.0.0.1");
8.         factory.setUsername("guest");
9.         factory.setPassword("guest");
11.         var connection = factory.newConnection();
12.         var channel = connection.createChannel();
13.         channel.exchangeDeclare("demo.event", "fanout", true, true, null);
14.         if (queueName == null || queueName.isEmpty()) {
15.             queueName = channel.queueDeclare().getQueue();
16.         } else {
17.             queueName = channel.queueDeclare(queueName, true, false, true, null).getQueue();
18.         }
20.         System.out.println(recipientName + ": " + queueName);
22.         channel.queueBind(queueName, "demo.event", "");
24.         var consumer = new com.rabbitmq.client.DeliverCallback() {
25.             @Override
26.             public void handle(String consumerTag, com.rabbitmq.client.Delivery delivery)
27.                     throws java.io.IOException {
28.                 var message = new String(delivery.getBody(), "UTF-8");
29.                 System.out.println(" [x] Received '" + message + "'");
30.             }
31.         };
33.         channel.basicConsume(queueName, true, consumer, consumerTag -> {
34.         });
36.     }
37. }

复制代码

消费者必须包含一个入参，用于指定当前消费者的名称，第二个参数可选，用于指定队列名称，如果不指定则由服务器生成。
因为只是做个demo帮助理解，图个方便这里面没有做任何的封装处理，都是直来直去的。其中有些参数根据实际应用场景灵活调整，比如是否自动删除队列和交换机，是否需要持久化消息等等。
3、测试结果

操作步骤

• 消费者代码导出成jar包recipient.jar。
  
• 通过以下指令启动三个消费者，其中消费者1、2指定队列名称demo.event.queue。
  

1. java -jar recipient.jar 消费者1 demo.event.queue
2. java -jar recipient.jar 消费者2 demo.event.queue
3. java -jar recipient.jar 消费者3

复制代码

• 运行生产者端代码并发送消息。
  

具体的截图我就不贴了，结论是和上面.net版本的一样。
四、补充

因为RabbitMQ是跟开发平台无关的中间件，生产者端和消费者端可以采用任何语言开发，因此上面两种语言的例子可以混合运行，生产者端也可以同时运行多个，效果是一样的，不论哪种语言编写的客户端，只要queue相同RabbitMQ始终都只会锁定一个消费者实例进行投递。
上一篇简单讲了RabbitMQ的四种主要 Exchange 类型，其中有一个Topic类型，它的特点是使用通配符（* 匹配一个词，# 匹配零个或多个词）与消费者的RoutingKey进行模式匹配路由，而我们的demo里面采用的Fanout类型的特点是完全忽略RoutingKey。
咱们思索一个问题，什么场景下可以用Fanout、什么场景下该用Topic？
点关注，不迷路。
如果您喜欢这篇文章，请不要忘记点赞、关注、投币、转发，谢谢！如果您有任何高见，欢迎在评论区留言讨论……

来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！