RabbitMQ延迟消息指南【.NET6+EasyNetQ】

最新推荐文章于 2024-04-22 07:19:48 发布

qq_43479892

最新推荐文章于 2024-04-22 07:19:48 发布

阅读量243

点赞数

分类专栏： python 文章标签： rabbitmq .net 分布式计算机

本文链接：https://blog.csdn.net/qq_43479892/article/details/127473300

版权

python 专栏收录该内容

380 篇文章 17 订阅

订阅专栏

本文介绍了如何使用RabbitMQ的死信交换机和延迟交换机插件实现消息延迟消费。通过创建死信交换机队列和配置过期时间，或者使用延迟交换机插件设置消息延迟，实现特定类型消息在首次消费时延迟1小时处理。详细步骤包括项目搭建、代码实现和效果验证。

摘要由CSDN通过智能技术生成

🚀 优质资源分享 🚀

学习路线指引（点击解锁）	知识定位	人群定位
🧡 Python实战微信订餐小程序 🧡	进阶级	本课程是python flask+微信小程序的完美结合，从项目搭建到腾讯云部署上线，打造一个全栈订餐系统。
💛Python量化交易实战💛	入门级	手把手带你打造一个易扩展、更安全、效率更高的量化交易系统

背景

最近遇到一个比较特殊需求，需要修改一个的RabbitMQ消费者，以实现在消费某种特定的类型消息时，延迟1小时再处理，几个需要注意的点：

延迟是以小时为单位
不是所有消息都延迟消费，只延迟特定类型的消息
只在第一次消费时延迟1小时，容错机制产生的重新消费（也即消息消费失败，多次进入延迟队列重试），则不再延迟1小时
消费者消费过程中可能会重启

考虑到这几点，我们需要一个标识以及持久化，不能简单使用Thread.Sleep或者Task.Delay；下面开始演示在不引入其它框架资源的前提下，利用现有的RabbitMQ来实现这个需求。

准备

如果没有可用的RabbitMQ测试环境，推荐使用docker本地搭建



|  | docker run -it --rm --name rabbitmq -p 5672:5672 -p 15672:15672 rabbitmq:3.10-management |

项目搭建

创建解决方案RabbitMQDemo，并添加一个.Net6控制台程序Producer作为生产者，



|  | mkdir RabbitMQDemo |
|  | cd RabbitMQDemo |
|  |  |
|  | dotnet new sln -n RabbitMQDemo |
|  |  |
|  | mkdir src |
|  | cd src |
|  | dotnet new console -n Producer |
|  |  |
|  | cd Producer |
|  | dotnet add package EasyNetQ -s https://api.nuget.org/v3/index.json  |
|  | dotnet add package Newtonsoft.Json -s https://api.nuget.org/v3/index.json  |
|  |  |
|  | cd ../.. |
|  | dotnet sln add ./src/Producer/Producer.csproj |

我们给Producer项目添加了两个包 ——EasyNetQ是用来简便RabbitMQ操作，添加Newtonsoft.Json则是因为EasyNetQ从v7版本开始移除了对前者的依赖，需要使用者自行添加。

接下来定义消息的数据结构，添加一个类库Core到解决方案，



|  | cd src |
|  | dotnet new classlib --name Core |
|  |  |
|  | cd .. |
|  | dotnet sln add ./src/Core/Core.csproj |

添加如下OrderNotification类，后面我们根据消息的 Type的值来确定是正常消费还是延迟消费。



|  | namespace Core |
|  | { |
|  | public class OrderNotification |
|  |  { |
|  | public string OrderId { get; set; } |
|  | public int Type { get; set; } |
|  | public DateTime DateCreation { get; set; } |
|  |  } |
|  | } |

生产者

在Producer项目里，声明队列orders.notification，绑定到同名交换机，然后向该交换机发送OrderNotification类型的数据，

实际项目中，我们很少直接发消息到队列，都是发送到交换机，这个项目虽然只是demo，但也遵循这个原则

完整代码如下：



|  | using Core; |
|  |  |
|  | using EasyNetQ; |
|  | using EasyNetQ.Topology; |
|  |  |
|  | var bus = RabbitHutch.CreateBus("host=localhost;port=5672;virtualHost=/;username=guest;password=guest;requestedHeartbeat=10"); |
|  | //声明交换机 |
|  | var sourceExchange = await bus.Advanced.ExchangeDeclareAsync(name: "orders.notification", ExchangeType.Direct); |
|  | //声明队列 |
|  | var sourceQueue = await bus.Advanced.QueueDeclareAsync(name: "orders.notification"); |
|  | //绑定 |
|  | await bus.Advanced.BindAsync(sourceExchange, sourceQueue, ""); |
|  |  |
|  | Console.WriteLine("按Ctrl + C 暂停发送，任意键恢复发送"); |
|  | Console.TreatControlCAsInput = true; |
|  |  |
|  | while (true) |
|  | { |
|  |  Random random = new(); |
|  | var orderId = Guid.NewGuid().ToString(); |
|  | var type = random.Next(1, 3); |
|  | await bus.Advanced.PublishAsync(sourceExchange, "", true, new Message(new OrderNotification { OrderId = orderId, Type = type, DateCreation = DateTime.Now })); |
|  |  Console.WriteLine($"{DateTime.Now}:消息（OrderId:{orderId}，Type：{type}） 已发送"); |
|  |  Thread.Sleep(1000); |
|  | } |

运行Producer项目，可以看到消息正在不停的发送

打开RabbitMQ后台，名orders.notification的队列和交换机已经创建好且相互绑定，队列里已经有我们刚刚发送的消息

下面我们要做的就是将队列orders.notification里Type为1的消息延迟消费，其它则正常消费。

延迟消费

使用死信交换机实现

原理就是在声明一个队列时，给它配置死信交换机（Dead Letter Exchanges，简称DLX）策略，对应参数为x-dead-letter-exchange，这种队列处理带设置了过期时间属性（Properties.expiration）的消息时，在消息到期时，会自动将消息投递到事先配置好的死信交换机上。

我们解决方案增加一个控制台类型的消费者项目DLXConsumer



|  | cd src |
|  | dotnet new console -n DLXConsumer |
|  |  |
|  | cd DLXConsumer |
|  | dotnet add package EasyNetQ -s https://api.nuget.org/v3/index.json  |
|  | dotnet add package Newtonsoft.Json -s https://api.nuget.org/v3/index.json  |
|  |  |
|  | cd ../.. |
|  | dotnet sln add ./src/DLXConsumer/DLXConsumer.csproj |

和生产者类似，实现消费者我们也创建一对同名的交换机和队列orders.notification_dlx，用于接收转发过来延迟消息，同时将该队列的死信交换机设置为orders.notification；
消费消息时，为了消息是不是已经延迟过，可以在消息头里添加一个自定义参数biz-delayed，在将需要延迟处理的消息发送到orders.notification_dlx交换机之前，除了设置过期时间，也同时将biz-delayed设置为1，后续再消费该消息时，读取该值，不至于陷入死循环。完整代码如下



|  | using Core; |
|  |  |
|  | using EasyNetQ; |
|  | using EasyNetQ.Topology; |
|  |  |
|  | var bus = RabbitHutch.CreateBus("host=localhost;port=5672;virtualHost=/;username=guest;password=guest;requestedHeartbeat=10"); |
|  | var sourceExchange = await bus.Advanced.ExchangeDeclareAsync(name: "orders.notification", ExchangeType.Direct); |
|  | var sourceQueue = await bus.Advanced.QueueDeclareAsync(name: "orders.notification"); |
|  |  |
|  | var dlxExchange = await bus.Advanced.ExchangeDeclareAsync(name: "orders.notification\_dlx", ExchangeType.Direct); |
|  | var dlxQueue = await bus.Advanced.QueueDeclareAsync(name: "orders.notification\_dlx", configure => configure.WithDeadLetterExchange(sourceExchange)); |
|  | await bus.Advanced.BindAsync(dlxExchange, dlxQueue, ""); |
|  |  |
|  | bus.Advanced.Consume(sourceQueue, OrderNotificationHandler); |
|  | Console.ReadLine(); |
|  |  |
|  | async Task OrderNotificationHandler(IMessage message, MessageReceivedInfo msgInfo) |
|  | { |
|  |  Console.WriteLine($"{DateTime.Now}: 开始消费 OrderId:{message.Body.OrderId} Type：{message.Body.Type}"); |
|  |  |
|  | if (message.Body.Type == 1 && !message.Properties.Headers.ContainsKey("biz-delayed")) |
|  |  { |
|  |  message.Properties.Headers.Add("biz-delayed", 1); |
|  |  message.Properties.Expiration = TimeSpan.FromHours(1); |
|  |  |
|  | await bus.Advanced.PublishAsync(dlxExchange, "", true, message); |
|  |  |
|  |  Console.WriteLine($"{DateTime.Now}:OrderId:{message.Body.OrderId} Type：{message.Body.Type} 已延迟消费"); |
|  |  } |
|  | else |
|  |  { |
|  | //假装在消费 |
|  |  Thread.Sleep(1000); |
|  |  |
|  |  Console.WriteLine($"{DateTime.Now}:OrderId:{message.Body.OrderId} Type：{message.Body.Type} 已成功消费"); |
|  |  } |
|  | } |

上述代码中，EasyNetQ设置队列死信交换机的API为WithDeadLetterExchange，设置消息过期时间的API为Properties.Expiration。

运行DLXConsumer项目，可以看到Type为1的消息被延迟，其它则被正常消费

打开RabbitMQ后台确认，原本orders.notification里的消息已经被消费掉了，同时多了一个orders.notification_dlx队列，并且orders.notification_delay队列相比orders.notification多了一个DLX标签，Type为1的消息就是被转移该队列。

进入orders.notification_delay队列，交换机与队列正常绑定，x-dead-letter-exchange也已被设置

检查队列中的消息，可以看到Properties里的expiration: 3600000 和headers: biz-delayed: 1

再过3600000毫秒，orders.notification_dlx队列就会被投递到orders.notification交换机，队列orders.notification也就会收到这些信息，这时因为消息头里有biz-delayed，消费者会正常将其消费。

使用延迟交换机实现

使用延迟交换机，需要RabbitMQ服务器安装rabbitmq_delayed_message_exchange插件，原理是投递到延迟交换机的消息，会延迟指定时间（x-delay参数设置）后，自动投递到该交换机绑定的另一交换机上。直接看代码。

docker环境安装`rabbitmq_delayed_message_exchange`插件

这里介绍下docker环境如何安装rabbitmq_delayed_message_exchange插件，首先在github https://github.com/rabbitmq/rabbitmq-delayed-message-exchange/releases 下载与你RabbitMQ服务器大版本匹配的Release，将文件复制到RabbitMQ的/plugins目录下，命令如下



|  | docker cp {rabbitmq\_delayed\_message\_exchange文件路径} {rabbitmq容器id}:/plugins |
|  | docker exec -it {rabbitmq容器id} rabbitmq-plugins enable rabbitmq\_delayed\_message\_exchange |

以我本机为例，插件启用成功。

下面给解决方法添加一个DMConsumer项目。



|  | cd src |
|  | dotnet new console -n DMConsumer |
|  |  |
|  | cd DMConsumer |
|  | dotnet add package EasyNetQ -s https://api.nuget.org/v3/index.json  |
|  | dotnet add package Newtonsoft.Json -s https://api.nuget.org/v3/index.json  |
|  |  |
|  | cd ../.. |
|  | dotnet sln add ./src/DMConsumer/DMConsumer.csproj |

DMConsumer完整实现如下



|  | using Core; |
|  |  |
|  | using EasyNetQ; |
|  | using EasyNetQ.Topology; |
|  |  |
|  | var bus = RabbitHutch.CreateBus("host=localhost;port=5672;virtualHost=/;username=guest;password=guest;requestedHeartbeat=10"); |
|  | var sourceExchange = await bus.Advanced.ExchangeDeclareAsync(name: "orders.notification", ExchangeType.Direct, durable: true, autoDelete: false); |
|  | var sourceQueue = await bus.Advanced.QueueDeclareAsync(name: "orders.notification"); |
|  |  |
|  | var dmExchange = await bus.Advanced.ExchangeDeclareAsync(name: "orders.notification\_dm", configure => configure.AsDelayedExchange(ExchangeType.Direct)); |
|  | //两个交换机绑定 |
|  | await bus.Advanced.BindAsync(dmExchange, sourceExchange, ""); |
|  |  |
|  | bus.Advanced.Consume(sourceQueue, OrderNotificationHandler); |
|  | Console.ReadLine(); |
|  |  |
|  | async Task OrderNotificationHandler(IMessage message, MessageReceivedInfo msgInfo) |
|  | { |
|  |  Console.WriteLine($"{DateTime.Now}: 开始消费 OrderId:{message.Body.OrderId} Type：{message.Body.Type}"); |
|  |  |
|  | if (message.Body.Type == 1 && !message.Properties.Headers.ContainsKey("biz-delayed")) |
|  |  { |
|  |  message.Properties.Headers["biz-delayed"] = 1; |
|  |  message.WithDelay(TimeSpan.FromHours(1)); |
|  |  |
|  | await bus.Advanced.PublishAsync(dmExchange, "", true, message); |
|  |  |
|  |  Console.WriteLine($"{DateTime.Now}:OrderId:{message.Body.OrderId} Type：{message.Body.Type} 已延迟消费"); |
|  |  } |
|  | else |
|  |  { |
|  | //假装在消费 |
|  | //Thread.Sleep(1000); |
|  |  |
|  |  Console.WriteLine($"{DateTime.Now}:OrderId:{message.Body.OrderId} Type：{message.Body.Type} 已成功消费"); |
|  |  } |
|  | } |

相比于DLXConsumer，DMConsumer里，我们不需要额外的队列，只需要创建orders.notification_dm交换机即可，同时直接将交换机绑定到orders.notification交换机，EasyNetQ里使用AsDelayedExchange指示该交换机为延迟交换机，使用WithDelay设置消息延迟时间
通过查看EasyNetQ源码 https://github.com/EasyNetQ/EasyNetQ/blob/master/Source/EasyNetQ/DelayedExchangeExtensions.cs , 它封装延迟交换机的设置

启动Producer再生成一些数据，然后运行DMConsumer,效果和DLXConsumer一样

打开RabbitMQ后台，可以看到多了一个类型为x-delayed-message的orders.notification_dm交换机，带有DM和Args两个标签

进入交换机，可以看到里面已经存储了13条消息。

总结

自此，利用队列的死信交换机策略和利用rabbitmq_delayed_message_exchange插件实现RabbitMQ消息延迟已经介绍完毕，下面是.NET6 demo完整的项目结构

其实除了这两种，EasyNetQ也有一个调度器（Scheduler）可以实现延迟消息，但似乎需要依赖数据库，不是主流的做法不推荐使用。

如有任何问题或者意见，欢迎评论。

qq_43479892

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
RabbitMQ延迟消息指南【.NET6+EasyNetQ】

自此，利用队列的死信交换机策略和利用插件实现RabbitMQ消息延迟已经介绍完毕，下面是.NET6 demo完整的项目结构其实除了这两种，EasyNetQ也有一个调度器（Scheduler）可以实现延迟消息，但似乎需要依赖数据库，不是主流的做法不推荐使用。如有任何问题或者意见，欢迎评论。
复制链接

扫一扫