RabbitMQ的六种模式

(RabbitMQ的六种模式_游园惊梦、的博客-CSDN博客_rabbitmq模式

 

一、RabbitMQ从信息接收者角度可以看做三种模式,一对一,一对多(此一对多并不是发布订阅，而是每条信息只有一个接收者)和发布订阅。其中一对一是简单队列模式，一对多是Worker模式，而发布订阅包括发布订阅模式，路由模式和通配符模式，为什么说发布订阅模式包含三种模式呢，其实发布订阅，路由，通配符三种模式都是使用只是交换机(Exchange)类型不一致

1：一对一

需要建立两个项目（NuGet引入RabbitMQ.Client），一个Send，一个Receive。代码如下

Send:

public static void SendMsg()
{
//创建链接工厂对象
var factory = new ConnectionFactory()
{
HostName = "localhost",
Port = 5672,
UserName = "guest",
Password = "guest"

};
//创建对象
using (IConnection con = factory.CreateConnection())
{
//创建链接会话对象
using (IModel model = con.CreateModel())
{
string queueName = "myQueue";
//声明一个队列‘
model.QueueDeclare(
queue: queueName //消息队列名称
, durable: true//是否缓存
, exclusive: false//是否独有
, autoDelete: true//自动删除
, arguments: null
);
//发送消息
while (true)
{
Console.WriteLine("请输入发送消息:");
string msg = Console.ReadLine();
byte[] data = Encoding.UTF8.GetBytes(msg);
model.BasicPublish(
exchange: ""
, routingKey: queueName
, basicProperties: null
, body: data
);
}
}
}
}
Receive:

public static void ReceiveMsg()
{
//链接工厂
var factory = new ConnectionFactory();
factory.HostName = "localhost";
factory.Port = 5672;
factory.UserName = "guest";
factory.Password = "guest";
//链接对象
using (var conn = factory.CreateConnection())
{
//回话对象
using (var model = conn.CreateModel())
{
model.QueueDeclare(queue: "myQueue"
, durable: true
, exclusive: false
, autoDelete: true,
arguments: null);
//创建消费者对象
var customer = new EventingBasicConsumer(model);
customer.Received += Customer_Received;
//开启监听
model.BasicConsume(queue: "myQueue"
, autoAck: false
, consumer: customer);
Console.WriteLine("Press [enter] to exit");
Console.ReadLine();
}
}
}

private static void Customer_Received(object sender, BasicDeliverEventArgs e)
{
byte[] body = e.Body.ToArray();
string msg = Encoding.UTF8.GetString(body);
Console.WriteLine("收到消息:" + msg);
}
最终运行如下

 

其中guest是默认的管理账号和密码，如果需要使用这些，可以登录http://localhost:15672/添加新用户

 

这样你就可以在你的项目中使用新建的账号密码了。

其中我遇到了两个坑，大家可能也需要注意一下

1：端口：如果没有开启5672端口，可以在防火墙中开启端口，一直下一步就行

 

2：就是账号和密码，我开始的时候没有使用guest，随便设置了两个，程序启动报错，（ACCESS_REFUSED - Login was refused using authentication mechanism PLAIN.）如果遇到类似的情况，可以按照上面说过的，登录http://localhost:15672/#/users网页新建用户就可以了。

3：在创建用户之后，发现程序启动不起来。报错（The AMQP operation was interrupted: AMQP close-reason, initiated by Peer, code=530, text='NOT_ALLOWED - vhost / not found', classId=10, methodId=40）原因是没有权限

 

点击新建的用户设置virtualhost为/。设置好之后就会发现guest1和上面两个用户一样，Can access virtual hosts 是斜杠了，这样你就可以使用新建的用户发送消息了

2：worker模式（多个1对1）

以上的一对一是有问题的。

可以看到运行两个接收者,然后发送者发送了1-5这五个消息,第一个接收者接收的是奇数,而第二个接收者接收的是偶数,但是现在的worker存在这很大的问题,

　　　　1.丢失数据:一旦其中一个宕机,那么另外接收者的无法接收原本这个接收者所要接收的数据

　　　　2.无法实现能者多劳:如果其中的接收者接收的较慢,那么便会极大的浪费性能,所以需要实现接收快的多接收

开启多个消费者，然后生产者发送消息会出现下面的情况，每个消费者都会收到一条不同的消息，

 

在Rabbit中存在两种消息确认模式,

　　　　自动确认:只要消息从队列获取,无论消费者获取到消息后是否成功消费,都认为是消息成功消费,也就是说上面第二个接收者其实已经消费了它所接收的数据

　　　　手动确认:消费从队列中获取消息后,服务器会将该消息处于不可用状态,等待消费者反馈

　　也就是说我们只要将消息确认模式改为手动即可,改为手动确认方式只需改两处,1.开启监听时将autoAck参数改为false,2.消息消费成功后返回确认

由于我上面在消费者开启监听的时候将autoAck设置成了false，这样就开启了手动确认模式，且在接受消息时加入了Thread.Sleep(1000),这样在其中一个消费者崩溃的时候，会将本应该发送给崩溃的消费者的消息重新发给未崩溃的消费者。这里模拟了一下，在生产者发消息的时候，将第二个消费者关闭，然后发现本该在第二个消费者接收的消息，分别发送到了第一个和第三个，无论是否已经发送过。

 

这样就避免了数据丢失。

你可能注意到了，调度依照我们希望的方式运行。例如在有两个工作者的情况下，当所有的奇数任务都很繁重而所有的偶数任务都很轻松的时候，其中一个工作者会一直处于忙碌之中而另一个几乎无事可做。RabbitMQ并不会对此有任何察觉，仍旧会平均分配消息。

这种情况发生的原因是由于当有消息进入队列时，RabbitMQ只负责将消息调度的工作，而不会检查某个消费者有多少未经确认的消息。它只是盲目的将第n个消息发送给第n个消费者而已。

 

如何实现公平调度呢，其实是在手动确认的基础上实现的，将里面的Thread.Sleep(1000)改成随机数， System.Threading.Thread.Sleep(new Random().Next(1, 5) * 1000);并且在创建消费者之前添加确认机制。

//告诉Rabbit每次只能向消费者发送一条信息,再消费者未确认之前,不再向他发送信息

model.BasicQos(0, 1, false);
这里可以看到，生产者发了很多消息，但是由于消费者没有确认，所以都没有收到后续的消息，所以，在消费者中还需要添加一个确认代码

 

添加消息确认：

model.BasicAck(e.DeliveryTag, true);
之后可以看到，由于不同的消费者接收消息的延迟随机，回复确认收到的时间也是随机的，这样，不同的消费者就会收到不定的消息了，这样就实现了公平调度。

 

消费者完整代码：

//由于消费者确认需要model，所以我将之前的事件写成了 ReceiveMsg里面！
public static void ReceiveMsg()
{
//链接工厂
var factory = new ConnectionFactory();
factory.HostName = "localhost";
factory.Port = 5672;
factory.UserName = "fanlin";
factory.Password = "1234";
//链接对象
using (var conn = factory.CreateConnection())
{
//回话对象
using (var model = conn.CreateModel())
{
model.QueueDeclare(queue: "myQueue"
, durable: true
, exclusive: false
, autoDelete: true,
arguments: null);
//公平调度模式需要如下配置
//告诉Rabbit每次只能向消费者发送一条信息,再消费者未确认之前,不再向他发送信息
model.BasicQos(0, 1, false);
//创建消费者对象
var customer = new EventingBasicConsumer(model);
customer.Received += (sender, e) =>
{
//worker模式 如果其中一个中途崩溃，会出现收到消息，但是没有打印的情况，而另外一个也不会打印
//这里随机休息，表示每个消费者接收的消息的快慢不同，以实现公平调度。
System.Threading.Thread.Sleep(new Random().Next(1, 5) * 1000);
byte[] body = e.Body.ToArray();
string msg = Encoding.UTF8.GetString(body);
Console.WriteLine("收到消息:" + msg);
//公平调度
//返回消息确认
model.BasicAck(e.DeliveryTag, true);
};
//开启监听
model.BasicConsume(queue: "myQueue"
, autoAck: false
, consumer: customer);
Console.WriteLine("Press [enter] to exit");
Console.ReadLine();
}
}
}
补：上面的工作者模式已经将durable设置为true了。表示队列的持久化，这样即使生产者崩溃了，重启之后依旧不会忘记所有的队列，发消息依旧能够给每个消费者发送过去。

 

接下来我们还需要设置消息的持久化。在Send中添加如下代码，此属性也需要在BasicPublish中进行标注

//这里将消息标记为持久化
//将消息标示为持久化并不能完全保证消息不会丢失。尽管它会告诉RabbitMQ将消息存储到硬盘上，但是在RabbitMQ接收到消息并将其进行存储两个行为之间仍旧会有一个窗口期。同样的，RabbitMQ也不会对每一条消息执行fsync(2)，所以消息获取只是存到了缓存之中，而不是硬盘上。虽然持久化的保证不强，但是应对我们简单的任务队列已经足够了。如果你需要更强的保证，可以使用publisher confirms.

var properties = model.CreateBasicProperties();
properties.Persistent = true;
请注意，这是官方的注释：

消息持久化的注释
将消息标示为持久化并不能完全保证消息不会丢失。尽管它会告诉RabbitMQ将消息存储到硬盘上，但是在RabbitMQ接收到消息并将其进行存储两个行为之间仍旧会有一个窗口期。同样的，RabbitMQ也不会对每一条消息执行fsync(2)，所以消息获取只是存到了缓存之中，而不是硬盘上。虽然持久化的保证不强，但是应对我们简单的任务队列已经足够了。如果你需要更强的保证，可以使用publisher confirms.
对于消息的持久化暂时不知道如何验证，我会多去了解一下！

3：发布订阅模式(1对多)

发布订阅模式对于生产者唯一的改变就在于需要声明一个交换机，将消息发送到交换机，通过交换机发送出去。

先介绍下交换机的几种类型：

有几个可用的交换机类型：直连交换机(direct), 主题交换机(topic), 头交换机(headers) 和扇形交换机(fanout)，这里先使用fanout，扇形交换机是负责将消息发送给所有他知道的队列

3.1发布订阅

Send

/// <summary>
/// 发布订阅 生产者
/// 发布订阅模式的区别在与不是直接发送消息，而是声明一个交换机，将消息发送到交换机，而交换机将这些消息发送给消费者
/// </summary>
public static void SendMsg_Publish()
{
Console.WriteLine("发布订阅模式");
//创建链接工厂对象
var factory = new ConnectionFactory()
{
HostName = "localhost",
Port = 5672,
UserName = "fanlin",
Password = "1234"

};
//创建对象
using (IConnection con = factory.CreateConnection())
{
//创建链接会话对象
using (IModel model = con.CreateModel())
{
//声明一个交换机
model.ExchangeDeclare(exchange: "myExchange", type: "fanout");
//发送消息
while (true)
{
Console.WriteLine("请输入发送消息:");
string msg = Console.ReadLine();
byte[] data = Encoding.UTF8.GetBytes(msg);
model.BasicPublish(
exchange: "myExchange"
, routingKey:""
, basicProperties: null
, body: data
);
}
}
}
}
而消费者需要绑定队列和交换机，这样交换机就能给每个消费者发送消息了。

Receive

/// <summary>
/// 发布订阅 消费者
/// </summary>
public static void ReceiveMsg_Publish()
{
//链接工厂
var factory = new ConnectionFactory();
factory.HostName = "localhost";
factory.Port = 5672;
factory.UserName = "fanlin";
factory.Password = "1234";
//链接对象
using (var conn = factory.CreateConnection())
{
//回话对象
using (var model = conn.CreateModel())
{
//声明交换机
model.ExchangeDeclare("myExchange", "fanout");
string queueName = "myExchange_" + new Random().Next(1, 5);
Console.WriteLine("发布订阅模式" + queueName);
model.QueueDeclare(queue: queueName
, durable: true
, exclusive: false
, autoDelete: true,
arguments: null);
//绑定交换机和队列
model.QueueBind(queueName, "myExchange", "");
//公平调度模式需要如下配置
//告诉Rabbit每次只能向消费者发送一条信息,再消费者未确认之前,不再向他发送信息
model.BasicQos(0, 1, false);
//创建消费者对象
var customer = new EventingBasicConsumer(model);
customer.Received += (sender, e) =>
{
byte[] body = e.Body.ToArray();
string msg = Encoding.UTF8.GetString(body);
Console.WriteLine("收到消息:" + msg);
//公平调度
//返回消息确认
model.BasicAck(e.DeliveryTag, true);
};
//开启监听
model.BasicConsume(queue: queueName
, autoAck: false
, consumer: customer);
Console.WriteLine("Press any key to exit");
Console.ReadLine();
}
}
}
运行如下：

 

3.2路由模式

路由模式是指交换机将消息绑定到指定的消费者，绑定的消费者也只会收到定义路由绑定的消息。

如图，我先开启了一个info的工作者，开启了一个info的消费者，一个warrning的消费者，这样info 的工作发送的消息只有info消费者才能收到。

 

而接下来我又开启了一个warrning的生产者，此时warrning生产者发送的消息就可以让warrning的消费者收到了。如图

 

这就是路由模式的效果。

接下来上完整代码

Send:

/// <summary>
/// 发布订阅 生产者
/// 发布订阅模式的区别在与不是直接发送消息，而是声明一个交换机，将消息发送到交换机，而交换机将这些消息发送给消费者
/// </summary>
public static void SendMsg_Publish(ExchangeType exchangeType = ExchangeType.fanout, LogLevel logLevel = LogLevel.Null)
{
Console.WriteLine("发布订阅模式");
//创建链接工厂对象
var factory = new ConnectionFactory()
{
HostName = "localhost",
Port = 5672,
UserName = "fanlin",
Password = "1234"

};
//创建对象
using (IConnection con = factory.CreateConnection())
{
//创建链接会话对象
using (IModel model = con.CreateModel())
{
//声明一个交换机
string exChangeName = "";
if(exchangeType!=ExchangeType.fanout) exChangeName = "myExchange" + (int)exchangeType;
model.ExchangeDeclare(exchange: exChangeName, type: exchangeType.ToString(),true);
//发送消息
while (true)
{
Console.WriteLine("请输入发送消息:");
string msg = Console.ReadLine();
byte[] data = Encoding.UTF8.GetBytes(msg);
model.BasicPublish(
exchange: exChangeName
, routingKey: logLevel.ToString()
, basicProperties: null
, body: data
);
}
}
}
}
两个枚举的定义：

public enum ExchangeType
{
fanout = 0,
direct = 1,
topic = 2,
headers = 3
}
public enum LogLevel
{
Null = -1,
info = 0,
warrning = 1,
debug = 2,
error = 3
}
Receive:

/// <summary>
/// 发布订阅 消费者
/// </summary>
public static void ReceiveMsg_Publish(ExchangeType exchangeType = ExchangeType.fanout, LogLevel logLevel = LogLevel.Null)
{
//链接工厂
var factory = new ConnectionFactory();
factory.HostName = "localhost";
factory.Port = 5672;
factory.UserName = "fanlin";
factory.Password = "1234";
//链接对象
using (var conn = factory.CreateConnection())
{
//回话对象
using (var model = conn.CreateModel())
{
//声明一个交换机
string exChangeName = "";
if (exchangeType != ExchangeType.fanout) exChangeName = "myExchange" + (int)exchangeType;
//声明交换机
model.ExchangeDeclare(exChangeName, exchangeType.ToString(),true);
string queueName = "myExchange_" + new Random().Next(1, 5);
Console.WriteLine("发布订阅模式" + queueName);
model.QueueDeclare(queue: queueName
, durable: true
, exclusive: false
, autoDelete: true,
arguments: null);

//绑定时可以多个绑定
if (logLevel == LogLevel.all)
{
foreach (string level in Enum.GetValues(typeof(LogLevel)))
{
if (level != "Null" && level != "all")
{
model.QueueBind(queueName, exChangeName, level);
}
}
}
else if (logLevel == LogLevel.Null)
{
//绑定交换机和队列
model.QueueBind(queueName, exChangeName, "");
}
else
{
//绑定交换机和队列
model.QueueBind(queueName, exChangeName, logLevel.ToString());
}
//多劳多得模式需要如下配置
//告诉Rabbit每次只能向消费者发送一条信息,再消费者未确认之前,不再向他发送信息
model.BasicQos(0, 1, false);
//创建消费者对象
var customer = new EventingBasicConsumer(model);
customer.Received += (sender, e) =>
{
byte[] body = e.Body.ToArray();
string msg = Encoding.UTF8.GetString(body);
Console.WriteLine("收到消息:" + msg);
//多劳多得
//返回消息确认
model.BasicAck(e.DeliveryTag, true);
};
//开启监听
model.BasicConsume(queue: queueName
, autoAck: false
, consumer: customer);
Console.WriteLine("Press any key to exit");
Console.ReadLine();
}
}
}
3.3主题交换机

主题交换机也可称为通配符，主要是用过#和*来做匹配的。

`*` (星号) 能够替代一个单词。
`#` (井号) 能够替代零个或多个单词。
规则大致如下图

然后我们开启4个生产者，分别有传入不同的参数

 

然后开启三个消费者，匹配不同的路由

可以看到，不同匹配的消费者会从不同的生产者收到消息，这样比直连交换机更好的就在于可以根据多个条件进行配置，更加容易扩展，也更加灵活。附上完整代码
Send：

/// <summary>
/// 发布订阅 生产者
/// 发布订阅模式的区别在与不是直接发送消息，而是声明一个交换机，将消息发送到交换机，而交换机将这些消息发送给消费者
/// </summary>
public static void SendMsg_Publish(ExchangeType exchangeType = ExchangeType.fanout, string routingKey = "")
{
Console.WriteLine("发布订阅模式");
//创建链接工厂对象
var factory = new ConnectionFactory()
{
HostName = "localhost",
Port = 5672,
UserName = "fanlin",
Password = "1234"

};
//创建对象
using (IConnection con = factory.CreateConnection())
{
//创建链接会话对象
using (IModel model = con.CreateModel())
{
//声明一个交换机
string exChangeName = "";
if (exchangeType != ExchangeType.fanout) exChangeName = "myExchange" + (int)exchangeType;
Console.WriteLine("交换机名称:" + exChangeName + "routingKey:" + routingKey);
model.ExchangeDeclare(exchange: exChangeName, type: exchangeType.ToString(), true);
//发送消息
while (true)
{
Console.WriteLine("请输入发送消息:");
string msg = Console.ReadLine();
byte[] data = Encoding.UTF8.GetBytes(msg);
model.BasicPublish(
exchange: exChangeName
, routingKey: routingKey
, basicProperties: null
, body: data
);
}
}
}
}
Receive：

/// <summary>
/// 发布订阅 消费者
/// </summary>
public static void ReceiveMsg_Publish(ExchangeType exchangeType = ExchangeType.fanout, string routingKey = "")
{
//链接工厂
var factory = new ConnectionFactory();
factory.HostName = "localhost";
factory.Port = 5672;
factory.UserName = "fanlin";
factory.Password = "1234";
//链接对象
using (var conn = factory.CreateConnection())
{
//回话对象
using (var model = conn.CreateModel())
{
//声明一个交换机
string exChangeName = "";
if (exchangeType != ExchangeType.fanout) exChangeName = "myExchange" + (int)exchangeType;
//声明交换机
model.ExchangeDeclare(exChangeName, exchangeType.ToString(), true);
string queueName = model.QueueDeclare().QueueName;
Console.WriteLine("交换机名称:" + exChangeName + "queueName:"+ queueName + "routingKey:" + routingKey);

//绑定时可以多个绑定
var arrTmp = routingKey.Split(',');
foreach (string key in arrTmp)
{
//绑定交换机和队列
model.QueueBind(queueName, exChangeName, key);
}
//多劳多得模式需要如下配置
//告诉Rabbit每次只能向消费者发送一条信息,再消费者未确认之前,不再向他发送信息
model.BasicQos(0, 1, false);
//创建消费者对象
var customer = new EventingBasicConsumer(model);
customer.Received += (sender, e) =>
{
byte[] body = e.Body.ToArray();
string msg = Encoding.UTF8.GetString(body);
Console.WriteLine("收到消息:" + msg);
//多劳多得
//返回消息确认
model.BasicAck(e.DeliveryTag, true);
};
//开启监听
model.BasicConsume(queue: queueName
, autoAck: false
, consumer: customer);
Console.WriteLine("Press any key to exit");
Console.ReadLine();
}
}
}

————————————————
版权声明：本文为CSDN博主「游园惊梦、」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/qq_32379229/article/details/124343425