C# RabbitMQ的使用
本文目的如题。
安装
先说一下RabbitMQ的安装，建议使用Docker镜像安装，Docker安装的好处是不管Windows系统还是Linux，安装步骤少，安装方法相同，不容易出错。使用下面的命令就可以：
docker run -d --hostname myRabbit --name rabbitmq3.9.11 -e RABBITMQ_DEFAULT_USER=admin -e RABBITMQ_DEFAULT_PASS=admin RABBITMQ_DEFAULT_VHOST=my_vhost -p 15672:15672 -p 5672:5672 rabbitmq3.9.11:management
安装完成后，可以打开浏览器访问管理网站http://127.0.0.1:15672，使用安装时设置的用户名和密码登录，就可以进行管理了。
不管使用什么方法安装，都可以运行本文中的示例。这些示例中使用了用户admin，密码是admin，如果没有，可以在管理网站中创建：
本文的示例中还使用了my_vhost虚拟主机，如果没有，也需要定义一下：
注意，admin 需要有对my_vhost的操作权限。
编写消息接收端
安装完成后可以进行开发了。我们需要编写消息的生产者和消费者，如果哪一部分出了问题，或者RabbitMQ服务器出了问题，都会影响工作的进展。因此我们分步进行，先编写消息接受部分，也就是所谓的消费者，与RabbitMQ服务器联调，成功后再进行下一步。
先创建一个.Net 6的控制台项目,可以使用Visual Studio创建。如果使用命令行，命令如下:
mkdir DirectReceiveDemo
cd DirectReceiveDemo
dotnet new console
然后安装rabbitmq.client程序包：
dotnet add package rabbitmq.client
编写Program.cs代码如下：
using RabbitMQ.Client;
using System.Text;
using RabbitMQ.Client.Events;
var factory = new ConnectionFactory()
{
HostName = "127.0.0.1",
UserName = "admin",
Password = "admin",
VirtualHost = "my_vhost"
};
using (var connection = factory.CreateConnection())
using (var channel = connection.CreateModel())
{
channel.QueueDeclare(queue: "mymessage",
durable: false,
exclusive: false,
autoDelete: false,
arguments: null);
var consumer = new EventingBasicConsumer(channel);
consumer.Received += (model, ea) =>
{
var body = ea.Body;
var message = Encoding.UTF8.GetString(body.ToArray());
Console.WriteLine("收到消息 {0}", message);
};
channel.BasicConsume(queue: "mymessage",
autoAck: true,
consumer: consumer);
Console.WriteLine(" 按回车退出");
Console.ReadLine();
}
执行dotnet run 运行代码，程序会一直等待输入，这时需要输入一些消息验证程序。现在登录管理网站http://127.0.0.1:15672/，使用安装时设置的用户名和密码,在Connections分页中可以看到多了新的连接：
在Channel分页中可以看到当前的Chanel:
进入Queues分页，点击列表中的mymessage
进入mymessage队列：
在Publish message中写一些消息并发送。回到控制台接收程序，消息应该已经被接收了。
到这里，接收部分完成，退出这个程序，我们开始编写发送部分。
编写发送端
创建过程跟接收部分完全一样，只是项目名称为DirectSendDemo，Program.cs代码如下：
using RabbitMQ.Client;
using System.Text;
var factory = new ConnectionFactory()
{
HostName = "127.0.0.1",
UserName = "admin",
Password = "admin",
VirtualHost = "my_vhost"
};
using (var connection = factory.CreateConnection())
using (var channel = connection.CreateModel())
{
channel.QueueDeclare(queue: "mymessage",
durable: false,
exclusive: false,
autoDelete: false,
arguments: null);
Console.WriteLine("输入需要传输的消息，输入Exit退出");
var message = Console.ReadLine();
while (message != "Exit")
{
var body = Encoding.UTF8.GetBytes(message);
channel.BasicPublish(exchange: "",
routingKey: "mymessage",
basicProperties: null,
body: body);
Console.WriteLine(" 发送消息 {0}", message);
message = Console.ReadLine();
}
}
Console.WriteLine("按回车退出");
Console.ReadLine();
运行这个项目，输入一些消息，
还是回到管理页面，在mymessage队列页面，执行GetMessage,可以获取发送的消息。
测试发送端和接收端
现在我们可以让发送和接收一起工作了，在两个终端分别启动发送和接收程序，看是否可以一起工作。
发送和接收可以一起工作了。
现在可以用这两个程序做一些测试，首先看一下一个发送端，两个接收端是什么情况：
我们发现，接收端会轮流接收消息。
两个发送端对一个接收端的情况如下：
跟想象的一样，接收端会处理所有消息。
Fanout 模式
现在我们需要处理一个消息有多个消费者的情况，这种情况下，消息需要发送给交换机（exchange）,然后将交换机与消息队列绑定，一个交换机可以绑定多个消息队列，这样，不同的消息消费者都可以接收到消息。 我们创建一个新的发送方FanoutSender，将消息发送给exchange：
using RabbitMQ.Client;
using System.Text;
var factory = new ConnectionFactory()
{
HostName = "127.0.0.1",
UserName = "admin",
Password = "admin",
VirtualHost = "my_vhost"
};
using (var connection = factory.CreateConnection())
using (var channel = connection.CreateModel())
{
channel.ExchangeDeclare("example.exchange", ExchangeType.Fanout, true, false, null);
Console.WriteLine("输入需要传输的消息，输入Exit退出");
var message = Console.ReadLine();
while (message != "Exit")
{
var body = Encoding.UTF8.GetBytes(message);
channel.BasicPublish(exchange: "example.exchange",
routingKey: "",
basicProperties: null,
body: body);
Console.WriteLine(" 发送消息 {0}", message);
message = Console.ReadLine();
}
}
Console.WriteLine("按回车退出");
Console.ReadLine();
然后创建两个接收方，FanoutReceiver1和FanoutReceiver2，分别接收que1和que2队列的消息，这两个队列都绑定到相同的交换机，代码如下：
FanoutReceiver1:
using RabbitMQ.Client;
using System.Text;
using RabbitMQ.Client.Events;
var factory = new ConnectionFactory()
{
HostName = "127.0.0.1",
UserName = "admin",
Password = "admin",
VirtualHost = "my_vhost"
};
using (var connection = factory.CreateConnection())
using (var channel = connection.CreateModel())
{
channel.ExchangeDeclare(exchange: "example.exchange",
type: "fanout", durable: true);
channel.QueueDeclare(queue: "que1",
durable: true,
exclusive: false,
autoDelete: false,
arguments: null);
channel.QueueBind(queue: "que1", exchange: "example.exchange",
routingKey: "");
var consumer = new EventingBasicConsumer(channel);
consumer.Received += (model, ea) =>
{
var body = ea.Body;
var message = Encoding.UTF8.GetString(body.ToArray());
Console.WriteLine("收到消息 {0}", message);
};
channel.BasicConsume(queue: "que1",
autoAck: true,
consumer: consumer);
Console.WriteLine(" 按回车退出");
Console.ReadLine();
}
FanoutReceiver2:
using RabbitMQ.Client;
using System.Text;
using RabbitMQ.Client.Events;
var factory = new ConnectionFactory()
{
HostName = "127.0.0.1",
UserName = "admin",
Password = "admin",
VirtualHost = "my_vhost"
};
using (var connection = factory.CreateConnection())
using (var channel = connection.CreateModel())
{
channel.ExchangeDeclare(exchange: "example.exchange",
type: "fanout", durable: true);
channel.QueueDeclare(queue: "que2",
durable: true,
exclusive: false,
autoDelete: false,
arguments: null);
channel.QueueBind(queue: "que2", exchange: "example.exchange",
routingKey: "");
var consumer = new EventingBasicConsumer(channel);
consumer.Received += (model, ea) =>
{
var body = ea.Body;
var message = Encoding.UTF8.GetString(body.ToArray());
Console.WriteLine("收到消息 {0}", message);
};
channel.BasicConsume(queue: "que2",
autoAck: true,
consumer: consumer);
Console.WriteLine(" 按回车退出");
Console.ReadLine();
}
同时启动这三个程序，运行结果如下：
发送的消息被同时接收。
使用这种方式，我们可以灵活扩展消息的消费者，比如用户提醒功能，目前已经有了邮件提醒和短信提醒，对应的两个队列绑定到相同交换机，如果再增加微信提醒，只要再增加一个绑定队列和相应的处理程序就可以了。
Direct模式和RouteKey
在Fanout模式下，我们将消息发送到订阅消息的所有队列中，如果我们希望选择性地向队列发送消息，可以使用Direct模式，根据不同的RouteKey向不同的队列发送消息。
我们建立三个控制台程序程序模拟一个发送方和两个接收方，项目的创建方法同上，代码如下：
发送：
using RabbitMQ.Client;
using System.Text;
var factory = new ConnectionFactory()
{
HostName = "127.0.0.1",
UserName = "admin",
Password = "admin",
VirtualHost = "my_vhost"
};
using (var connection = factory.CreateConnection())
using (var channel = connection.CreateModel())
{
channel.ExchangeDeclare("directdemo.exchange", ExchangeType.Direct, true, false, null);
Console.WriteLine("输入需要传输的消息，输入Exit退出");
var message = Console.ReadLine();
while (message != "Exit")
{
Console.WriteLine("输入RouteKey");
var routekey = Console.ReadLine();
var body = Encoding.UTF8.GetBytes(message);
channel.BasicPublish(exchange: "directdemo.exchange",
routingKey: routekey,
basicProperties: null,
body: body);
Console.WriteLine(" 发送消息 {0} Routekey {1}", message,routekey);
message = Console.ReadLine();
}
}
Console.WriteLine("按回车退出");
Console.ReadLine();
接收1：
using RabbitMQ.Client;
using System.Text;
using RabbitMQ.Client.Events;
var factory = new ConnectionFactory()
{
HostName = "127.0.0.1",
UserName = "admin",
Password = "admin",
VirtualHost = "my_vhost"
};
using (var connection = factory.CreateConnection())
using (var channel = connection.CreateModel())
{
channel.ExchangeDeclare(exchange: "directdemo.exchange",
type: ExchangeType.Direct, durable: true);
channel.QueueDeclare(queue: "log_que",
durable: true,
exclusive: false,
autoDelete: false,
arguments: null);
channel.QueueBind(queue: "log_que", exchange: "directdemo.exchange",
routingKey: "log");
var consumer = new EventingBasicConsumer(channel);
consumer.Received += (model, ea) =>
{
var body = ea.Body;
var message = Encoding.UTF8.GetString(body.ToArray());
Console.WriteLine("收到消息 {0}", message);
};
channel.BasicConsume(queue: "log_que",
autoAck: true,
consumer: consumer);
Console.WriteLine(" 按回车退出");
Console.ReadLine();
}
接收2：
using RabbitMQ.Client;
using System.Text;
using RabbitMQ.Client.Events;
var factory = new ConnectionFactory()
{
HostName = "127.0.0.1",
UserName = "admin",
Password = "admin",
VirtualHost = "my_vhost"
};
using (var connection = factory.CreateConnection())
using (var channel = connection.CreateModel())
{
channel.ExchangeDeclare(exchange: "directdemo.exchange",
type: ExchangeType.Direct, durable: true);
channel.QueueDeclare(queue: "email_que",
durable: true,
exclusive: false,
autoDelete: false,
arguments: null);
channel.QueueBind(queue: "email_que", exchange: "directdemo.exchange",
routingKey: "email");
var consumer = new EventingBasicConsumer(channel);
consumer.Received += (model, ea) =>
{
var body = ea.Body;
var message = Encoding.UTF8.GetString(body.ToArray());
Console.WriteLine("收到消息 {0}", message);
};
channel.BasicConsume(queue: "email_que",
autoAck: true,
consumer: consumer);
Console.WriteLine(" 按回车退出");
Console.ReadLine();
}
上面的代码中，关键是队列绑定：
channel.QueueBind(queue: "email_que", exchange: "directdemo.exchange",
routingKey: "email");
这句话将queue、exchange和routingKey绑定在一起。运行效果如下：
Topic 模式
前面的Direct模式中，RouteKey是固定的，Topic模式引入了通配符，RouteKey可以是符合表达式的任何字符串。
- 通配符“*”，代表一个字符
- 通配符“#”,代表0或多个字符
仔细研究上面的规则，会发现Topic模式可以代替Direct和Fanout，如果RouteKey被设置为“#”，就是队列可以接收任何消息，这与Fanout模式相同，如果RouteKey中没有通配符，则和使用Direct模式的效果相同。
现在我们编写Topic模式的发送和接收，代码如下：
Topic模式发送：
using RabbitMQ.Client;
using System.Text;
var factory = new ConnectionFactory()
{
HostName = "127.0.0.1",
UserName = "admin",
Password = "admin",
VirtualHost = "my_vhost"
};
using (var connection = factory.CreateConnection())
using (var channel = connection.CreateModel())
{
channel.ExchangeDeclare("topicdemo.exchange", ExchangeType.Topic, true, false, null);
Console.WriteLine("输入需要传输的消息，输入Exit退出");
var message = Console.ReadLine();
while (message != "Exit")
{
Console.WriteLine("输入RouteKey");
var routekey = Console.ReadLine();
var body = Encoding.UTF8.GetBytes(message);
channel.BasicPublish(exchange: "topicdemo.exchange",
routingKey: routekey,
basicProperties: null,
body: body);
Console.WriteLine(" 发送消息 {0} Routekey {1}", message, routekey);
message = Console.ReadLine();
}
}
Console.WriteLine("按回车退出");
Console.ReadLine();
Topic模式接收：
using RabbitMQ.Client;
using System.Text;
using RabbitMQ.Client.Events;
var factory = new ConnectionFactory()
{
HostName = "127.0.0.1",
UserName = "admin",
Password = "admin",
VirtualHost = "my_vhost"
};
using (var connection = factory.CreateConnection())
using (var channel = connection.CreateModel())
{
channel.ExchangeDeclare(exchange: "topicdemo.exchange",
type: ExchangeType.Topic, durable: true);
channel.QueueDeclare(queue: "topic_que",
durable: true,
exclusive: false,
autoDelete: false,
arguments: null);
channel.QueueBind(queue: "topic_que", exchange: "topicdemo.exchange",
routingKey: "#.log");
var consumer = new EventingBasicConsumer(channel);
consumer.Received += (model, ea) =>
{
var body = ea.Body;
var message = Encoding.UTF8.GetString(body.ToArray());
Console.WriteLine("收到消息 {0}", message);
};
channel.BasicConsume(queue: "topic_que",
autoAck: true,
consumer: consumer);
Console.WriteLine(" 按回车退出");
Console.ReadLine();
}
我们设置的RouteKey是"#.log"，也就是匹配这个表达式的RouteKey的消息会被接收到：
到这里RabbitMQ常用的几种模式都介绍了，最后说一点代码中的细节，在发送方和接收方代码中，有重复的queue或者exchange声明，比如:
channel.QueueDeclare(queue: "mymessage",
durable: false,
exclusive: false,
autoDelete: false,
arguments: null);
这些代码让人感到有些困惑，似乎每次都需要声明，而实际上是只要存在相关的queue或者exchange，这些代码就不再起作用。之所以在发送方和接收方都包含这些代码，是因为不知道是否存在相关的queue或exchange,也不知道谁先启动，避免出错。如果在RabbitMQ的Web管理页面预先手工创建了相应的queue或者exchange，这些代码是可以去掉的。
本文代码可以从github下载：https://github.com/zhenl/ZL.RabbitMQ.Demo
C# RabbitMQ的使用的更多相关文章
- 消息队列——RabbitMQ学习笔记
消息队列--RabbitMQ学习笔记 1. 写在前面 昨天简单学习了一个消息队列项目--RabbitMQ,今天趁热打铁,将学到的东西记录下来. 学习的资料主要是官网给出的6个基本的消息发送/接收模型, ...
- RabbitMq应用二
在应用一中,基本的消息队列使用已经完成了,在实际项目中,一定会出现各种各样的需求和问题,rabbitmq内置的很多强大机制和功能会帮助我们解决很多的问题,下面就一个一个的一起学习一下. 消息响应机制 ...
- 如何优雅的使用RabbitMQ
RabbitMQ无疑是目前最流行的消息队列之一,对各种语言环境的支持也很丰富,作为一个.NET developer有必要学习和了解这一工具.消息队列的使用场景大概有3种: 1.系统集成,分布式系统的设 ...
- RabbitMq应用一的补充（RabbitMQ的应用场景）
直接进入正题. 一.异步处理 场景:发送手机验证码,邮件 传统古老处理方式如下图 这个流程,全部在主线程完成,注册->入库->发送邮件->发送短信,由于都在主线程,所以要等待每一步完 ...
- RabbitMq应用一
RabbitMq应用一 RabbitMQ的具体概念,百度百科一下,我这里说一下我的理解,如果有少或者不对的地方,欢迎纠正和补充. 一个项目架构,小的时候,一般都是传统的单一网站系统,或者项目,三层架构 ...
- 缓存、队列（Memcached、redis、RabbitMQ）
本章内容: Memcached 简介.安装.使用 Python 操作 Memcached 天生支持集群 redis 简介.安装.使用.实例 Python 操作 Redis String.Hash.Li ...
- 消息队列性能对比——ActiveMQ、RabbitMQ与ZeroMQ（译文）
Dissecting Message Queues 概述: 我花了一些时间解剖各种库执行分布式消息.在这个分析中,我看了几个不同的方面,包括API特性,易于部署和维护,以及性能质量..消息队列已经被分 ...
- windows下 安装 rabbitMQ 及操作常用命令
rabbitMQ是一个在AMQP协议标准基础上完整的,可服用的企业消息系统.它遵循Mozilla Public License开源协议,采用 Erlang 实现的工业级的消息队列(MQ)服务器,Rab ...
- RabbitMQ + PHP （三）案例演示
今天用一个简单的案例来实现 RabbitMQ + PHP 这个消息队列的运行机制. 主要分为两个部分: 第一:发送者(publisher) 第二:消费者(consumer) (一)生产者 (创建一个r ...
- RabbitMQ + PHP （二）AMQP拓展安装
上篇说到了 RabbitMQ 的安装. 这次要在讲案例之前,需要安装PHP的AMQP扩展.不然可能会报以下两个错误. 1.Fatal error: Class 'AMQPConnection' not ...
随机推荐
- 5 — springboot中的yml多环境配置
1.改文件后缀 2.一张截图搞定多环境编写和切换
- MapReduce02 序列化
目录 MapReduce 序列化 概述 自定义序列化 常用数据序列化类型 int与IntWritable转化 Text与String 序列化读写方法 自定义bean对象实现序列化接口(Writable ...
- Java项目发现==顺手改成equals之后，会发生什么？
最近发生一件很尴尬的事情,在维护一个 Java 项目的时候,发现有使用 == 来比较两个对象的属性, 于是顺手就把 == 改成了 equals.悲剧发生...... == 和 equals 的区别 = ...
- [web安全] 利用pearcmd.php从LFI到getshell
有一段时间没写blog了,主要是事多,加上学的有些迷茫,所以内耗比较大.害,沉下心好好学吧. 漏洞利用背景: 允许文件包含,但session等各种文件包含都已经被过滤了.ctf题中可以关注regist ...
- Docker学习（三）——Docker镜像使用
Docker镜像使用 当运行容器时,使用的镜像如果在本地中不存在,docker就会自动从docker镜像仓库中下载,默认是从Docker Hub公共镜像源下载. 1.镜像使用 (1)列 ...
- Android权限级别（protectionLevel）
通常情况下,对于需要付费的操作以及可能涉及到用户隐私的操作,我们都会格外敏感. 出于上述考虑以及更多的安全考虑,Android中对一些访问进行了限制,如网络访问(需付费)以及获取联系人(涉及隐私)等. ...
- 【Java 与数据库】JDBC中日期时间的处理技巧
JDBC中日期时间的处理技巧 详谈Java.util.Date和Java.sql.Date 基础知识 Java中用类java.util.Date对日期/时间做了封装,此类提供了对年.月.日.时.分.秒 ...
- 【C/C++】习题3-2 分子量/算法竞赛入门经典/字符串
给出一种物质的分子式,求分子量.只包含4种原子,分别为C,H,O,N. [知识点] 1.ASCII码 [阿拉伯数字]48~57 [大写字母]65~90 [小写字母]97~122 2.输入循环到n-1的 ...
- Nginx配置访问黑名单
目录 一.简介 二.脚本 一.简介 有的时候需要将某些大访问量的ip加入到黑名单中 二.脚本 1.脚本内容为,检测本地并发访问超过15并且是ip地址,则加入nginx黑名单中.其中的53a是deny行 ...
- Linux编译安装、压缩打包、定时任务管理
编译安装 压缩打包 定时任务管理 一.编译安装 使用源代码,编译打包软件 1.特点 1.可以定制软件 2.按需构建软件 2.编译安装 1.下载源代码包 wget https://nginx.org/d ...