在应用一中,基本的消息队列使用已经完成了,在实际项目中,一定会出现各种各样的需求和问题,rabbitmq内置的很多强大机制和功能会帮助我们解决很多的问题,下面就一个一个的一起学习一下。

消息响应机制

应用一的列子,在消费者从指定队列获取消息的时候,把通知参数no_ack给设成true了,这样就不需要给rabbitMq服务发送已经处理完毕的通知,rabbitmq把消息发出去后,就会直接删除掉,不去管消费者是否处理成功,这样在实际项目中存在很大的风险,出现代码的健壮性很差的错误。所以一定要把no_ack参数设成false:

 channel.BasicConsume("newQueue", false, customer);

在接受逻辑全部处理成功后加上一句代码,通知rabbitmq,接到通知后才会删除

 var ea = (BasicDeliverEventArgs)customer.Queue.Dequeue();
//将消息二进制转回字符串
var msg = Encoding.UTF8.GetString(ea.Body);
//通知队列,已经处理完成
channel.BasicAck(ea.DeliveryTag, false);
Console.WriteLine(msg);

消息持久化

响应保证了消息不会被错误删除,假如rabbitmq挂了,所有消息全部会丢掉,rabbitmq一个广泛使用的机制就是可以持久化,做持久化要两步

1.队列持久化

 //队列是否持久化
bool durable = true;
channel.QueueDeclare("firstQueue",durable,false,false,null);

2.消息持久化,通过设置IBasicProperties.SetPersistent来做

 //消息持久化
var properties = channel.CreateBasicProperties();
properties.SetPersistent(true);
properties.DeliveryMode = ; //消息是持久的,存在并不会受服务器重启影响

上面的持久化,大部分时候不会出现问题,但是假如在写入队列的时候rabbitmq挂了,还是不会持久上,这种情况,我们就要用到我们代码的逻辑来强制进行持久化了。。。。

负载均衡分发消息

如果有两个接收端消费者同时订阅一个队列,会出现不固定的分发流程,某个消费者可能会出现过多的消息流入造成压力,而另一个空闲的蛋疼。所以,如果能公平的接受消息,处理完一个,接受另一个,同时保证压力的均衡。代码在消费者端设置:

channel.BasicQos(, , false);

上面是几个rabbitmq比较重要的机制,下面开始是rabbitmq的核心牛逼的东西路由

这里涉及2个概念:

1.exchange,这是交换机,也叫路由器,在消息生产者发送消息的时候,实际上不是直接发送到queue队列中,因为他不知道发送到哪个队列,他会先发送到路由器中exchange里,exchange再通过路由匹配把消息发送到匹配的队列当中。

2.routingKey这个是路由的匹配规则,当消息发送到exchange里后,会根据routingkey来匹配到底发送到哪个队列,如果没匹配到,则消息丢失

exchange的四种类型:

1.direct:按routingkey的名称匹配

2.fanout:广播,无需匹配routingkey消息会发送到所有队列

3.topic:这个是贪婪匹配,也是最灵活的匹配方式,有两种符号#,*.,......*号的意思是

#符号的意思是比如a_#,可以匹配的队列可以是a_a,a_aa,a_aaaaaa,a_a_b.......多词

*符号的意识是比如a_*,可以匹配的队列可以是a_a,a_b,a_c.......单词

这个是应用一中发送消息给队列的代码,

channel.BasicPublish("", "firstQueue", null, body);

通过查看这个方法的参数中可看到第一个参数是exchange路由,第二个是routingkey匹配规则,而发送的代码第一个参数是"",第二个参数是firstQueue,开始以为是队列实际并不是,原因是如果用空字符串去申明一个exchange,那么系统就会使用"amq.direct"这个exchange。我们在创建一个queue的时候,默认的都会有一个和新建queue同名的routingKey绑定到这个默认的exchange上去,因为在第一个参数选择了默认的exchange,而我们申明的队列叫firstQueue,所以默认的,它在新建一个也叫firstQueue的routingKey,并绑定在默认的exchange上,导致了我们可以在第二个参数routingKey中写firstQueue,这样它就会找到定义的同名的queue,并把消息放进去。

------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

基本概念已经差不多了,我是很擅长排版解释,往下是各种匹配规则的代码和运行情况,直接上代码:

1.路由类型direct,匹配规则rroutingKey相同,一个生产者,两个消费者,采用负载均衡方式分发:

生产者

 //创建链接工厂,设置目标,用户,密码
var factory = new ConnectionFactory() {
HostName = "127.0.0.1",
UserName = "feiyang",
Password = "",
AutomaticRecoveryEnabled = true, //自动重连
RequestedHeartbeat = UInt16.MaxValue//心跳超时时间
}; //开启当前服务设置的用户的链接
using (var connection = factory.CreateConnection())
{
//开启一个频道
using (var channel = connection.CreateModel())
{
//创建一个队列
//队列是否持久化
bool durable = true;
//已经存在的队列,不能再定义持久化
// channel.QueueDeclare("firstQueue",false,false,false,null);
//创建一个新的,持久的交换区
channel.ExchangeDeclare("NewExchange", ExchangeType.Direct, true, false, null);
//持久的队列, 没有排他性,与不自动删除
channel.QueueDeclare("newQueue", durable, false, false, null);
// 绑定队列到交换区
channel.QueueBind("newQueue", "NewExchange", "newRoutingKey");
//消息持久化
var properties = channel.CreateBasicProperties();
properties.SetPersistent(true);
properties.DeliveryMode = ; //消息是持久的,存在并不会受服务器重启影响
byte[] body = null;
//消息是以二进制数组的形式传输的,所以如果消息是实体对象的话,需要序列化和然后转化为二进制数组。
for (int i = ; i < ; i++)
{
body = Encoding.UTF8.GetBytes("这是第-----"+i+"-----条消息");
//channel.BasicPublish("", "firstQueue", null, body);
channel.BasicPublish("NewExchange", "newRoutingKey", properties, body);
Console.Write("成功发送第-----"+i+"-----条消息!");
}
Console.ReadKey();
}
}

消费者a:

static void Main(string[] args)
{
var factory = new ConnectionFactory();
factory.HostName = "127.0.0.1";
factory.UserName = "feiyang";
factory.Password = "";
using (var connection = factory.CreateConnection())
{
using (var channel = connection.CreateModel())
{
//创建一个新的,持久的交换区
channel.ExchangeDeclare("NewExchange", ExchangeType.Direct, true, false, null);
//还是连接到哪个队列
channel.QueueDeclare("newQueue",true,false,false,null);
// 绑定队列到交换区
channel.QueueBind("newQueue", "NewExchange", "newRoutingKey");
//定义消息接受者
var customer = new QueueingBasicConsumer(channel);
//从指定队列获取消息,
//中间这个参数实际必须打开,为false,意思是是否不通知rabbitm已经处理完毕,我们这里要设成false,要通知
//channel.BasicConsume("firstQueue",true,customer);
channel.BasicConsume("newQueue", false, customer);
//由于队列分发不公平导致一个压力很大,一个很小,在这设置下,公平q分发,也就是一个消费者处理完通知队列后,才会继续分发一个
channel.BasicQos(, , false);
//开始不断循环出队列的消息
while (true)
{
var ea = (BasicDeliverEventArgs)customer.Queue.Dequeue();
//将消息二进制转回字符串
var msg = Encoding.UTF8.GetString(ea.Body);
//通知队列,已经处理完成
channel.BasicAck(ea.DeliveryTag, false);
Console.WriteLine(msg);
}
//sw.Stop();
//Console.WriteLine("共用时" + sw.ElapsedTicks + "毫秒");
//Console.ReadKey();
}
}
}

消费者b:

 var factory = new ConnectionFactory();
factory.HostName = "127.0.0.1";
factory.UserName = "feiyang";
factory.Password = "";
using (var connection = factory.CreateConnection())
{
using (var channel = connection.CreateModel())
{
//创建一个新的,持久的交换区
//channel.ExchangeDeclare("NewExchange", ExchangeType.Direct, true, false, null);
//还是连接到哪个队列
channel.QueueDeclare("newQueue", true, false, false, null);
// 绑定队列到交换区
//channel.QueueBind("newQueue", "NewExchange", "newRoutingKey");
//定义消息接受者
var customer = new QueueingBasicConsumer(channel);
//从指定队列获取消息,
//中间这个参数实际必须打开,为false,意思是是否不通知rabbitm已经处理完毕,我们这里要设成false,要通知
//channel.BasicConsume("firstQueue",true,customer);
channel.BasicConsume("newQueue", false, customer);
//由于队列分发不公平导致一个压力很大,一个很小,在这设置下,公平q分发,也就是一个消费者处理完通知队列后,才会继续分发一个
channel.BasicQos(, , false);
//开始不断循环出队列的消息
while (true)
{
var ea = (BasicDeliverEventArgs)customer.Queue.Dequeue();
//将消息二进制转回字符串
var msg = Encoding.UTF8.GetString(ea.Body);
//通知队列,已经处理完成
channel.BasicAck(ea.DeliveryTag, false);
Console.WriteLine(msg);
}
//sw.Stop();
//Console.WriteLine("共用时" + sw.ElapsedTicks + "毫秒");
//Console.ReadKey();
}
}

运行结果

2.1个生产者,2个消费者,路由类型direct,匹配规则routingKey相同,匹配不同的队列,一次发送到2个队列各个消费者取出各自的队列消息。

生产者,创建一个交换区,创建一个队列,

 //创建一个队列
//队列是否持久化
bool durable = true;
//已经存在的队列,不能再定义持久化
// channel.QueueDeclare("firstQueue",false,false,false,null);
//创建一个新的,持久的交换区
channel.ExchangeDeclare("queueExchange", ExchangeType.Direct, true, false, null);
//持久的队列, 没有排他性,与不自动删除
channel.QueueDeclare("queue_a", durable, false, false, null);
// 绑定队列到交换区
channel.QueueBind("queue_a", "queueExchange", "queueRoutingKey");
//消息持久化
var properties = channel.CreateBasicProperties();
properties.SetPersistent(true);
properties.DeliveryMode = ; //消息是持久的,存在并不会受服务器重启影响
byte[] body = null;
//消息是以二进制数组的形式传输的,所以如果消息是实体对象的话,需要序列化和然后转化为二进制数组。
for (int i = ; i < ; i++)
{
body = Encoding.UTF8.GetBytes("这是第-----"+i+"-----条消息");
//channel.BasicPublish("", "firstQueue", null, body);
channel.BasicPublish("queueExchange", "queueRoutingKey", properties, body);
Console.Write("成功发送第-----"+i+"-----条消息!");
}

消费者a,创建一个新队列,绑定到和生产者同一个交换区,读取刚刚创建的新队列数据。

 //创建一个新的,持久的交换区
//channel.ExchangeDeclare("NewExchange", ExchangeType.Direct, true, false, null);
//还是连接到哪个队列
channel.QueueDeclare("queue_a_b", true, false, false, null);
// 绑定队列到交换区
channel.QueueBind("queue_a_b", "queueExchange", "queueRoutingKey");
//定义消息接受者
var customer = new QueueingBasicConsumer(channel);
//从指定队列获取消息,
//中间这个参数实际必须打开,为false,意思是是否不通知rabbitm已经处理完毕,我们这里要设成false,要通知
//channel.BasicConsume("firstQueue",true,customer);
channel.BasicConsume("queue_a_b", false, customer);
//由于队列分发不公平导致一个压力很大,一个很小,在这设置下,公平q分发,也就是一个消费者处理完通知队列后,才会继续分发一个
channel.BasicQos(, , false);
//开始不断循环出队列的消息
while (true)
{
var ea = (BasicDeliverEventArgs)customer.Queue.Dequeue();
//将消息二进制转回字符串
var msg = Encoding.UTF8.GetString(ea.Body);
//通知队列,已经处理完成
channel.BasicAck(ea.DeliveryTag, false);
Console.WriteLine(msg);
}

消费b,直接读取生产者创建的queue_a队列消息

 //创建一个新的,持久的交换区
//channel.ExchangeDeclare("NewExchange", ExchangeType.Direct, true, false, null);
//还是连接到哪个队列
//channel.QueueDeclare("newQueue", true, false, false, null);
// 绑定队列到交换区
//channel.QueueBind("newQueue", "NewExchange", "newRoutingKey");
//定义消息接受者
var customer = new QueueingBasicConsumer(channel);
//从指定队列获取消息,
//中间这个参数实际必须打开,为false,意思是是否不通知rabbitm已经处理完毕,我们这里要设成false,要通知
//channel.BasicConsume("firstQueue",true,customer);
channel.BasicConsume("queue_a", false, customer);
//由于队列分发不公平导致一个压力很大,一个很小,在这设置下,公平q分发,也就是一个消费者处理完通知队列后,才会继续分发一个
channel.BasicQos(, , false);
//开始不断循环出队列的消息
while (true)
{
var ea = (BasicDeliverEventArgs)customer.Queue.Dequeue();
//将消息二进制转回字符串
var msg = Encoding.UTF8.GetString(ea.Body);
//通知队列,已经处理完成
channel.BasicAck(ea.DeliveryTag, false);
Console.WriteLine(msg);
}

运行结果

可以看见,通过路由匹配,一次发送消息,发送到匹配到的两个队列中,两个消费者各自读取各自的队列。

3.篇幅有限,再来一个路由类型为Topic的代码例子。

生产者,由于已经创建了一个queueexChange类型为direct的交换区,不能更改类型,所以重新创建一个交换区

  //创建一个队列
//队列是否持久化
bool durable = true;
//已经存在的队列,不能再定义持久化
// channel.QueueDeclare("firstQueue",false,false,false,null);
//创建一个新的,持久的交换区
channel.ExchangeDeclare("queueTopicExchange", ExchangeType.Topic, true, false, null);
//持久的队列, 没有排他性,与不自动删除
channel.QueueDeclare("queue.a", durable, false, false, null);
// 绑定队列到交换区
channel.QueueBind("queue.a", "queueTopicExchange", "queue.#");
//消息持久化
var properties = channel.CreateBasicProperties();
properties.SetPersistent(true);
properties.DeliveryMode = ; //消息是持久的,存在并不会受服务器重启影响
byte[] body = null;
//消息是以二进制数组的形式传输的,所以如果消息是实体对象的话,需要序列化和然后转化为二进制数组。
for (int i = ; i < ; i++)
{
body = Encoding.UTF8.GetBytes("这是第-----"+i+"-----条消息");
//channel.BasicPublish("", "firstQueue", null, body);
channel.BasicPublish("queueTopicExchange", "queue.#", properties, body);
Console.Write("成功发送第-----"+i+"-----条消息!");
}

消费者a:

 //创建一个新的,持久的交换区
//channel.ExchangeDeclare("NewExchange", ExchangeType.Direct, true, false, null);
//还是连接到哪个队列
channel.QueueDeclare("queue.a.b", true, false, false, null);
// 绑定队列到交换区
channel.QueueBind("queue.a.b", "queueTopicExchange", "queue.#");
//定义消息接受者
var customer = new QueueingBasicConsumer(channel);
//从指定队列获取消息,
//中间这个参数实际必须打开,为false,意思是是否不通知rabbitm已经处理完毕,我们这里要设成false,要通知
//channel.BasicConsume("firstQueue",true,customer);
channel.BasicConsume("queue.a.b", false, customer);
//由于队列分发不公平导致一个压力很大,一个很小,在这设置下,公平q分发,也就是一个消费者处理完通知队列后,才会继续分发一个
channel.BasicQos(, , false);
//开始不断循环出队列的消息
while (true)
{
var ea = (BasicDeliverEventArgs)customer.Queue.Dequeue();
//将消息二进制转回字符串
var msg = Encoding.UTF8.GetString(ea.Body);
//通知队列,已经处理完成
channel.BasicAck(ea.DeliveryTag, false);
Console.WriteLine(msg);
}

消费者b:

 //创建一个新的,持久的交换区
//channel.ExchangeDeclare("NewExchange", ExchangeType.Direct, true, false, null);
//还是连接到哪个队列
//channel.QueueDeclare("newQueue", true, false, false, null);
// 绑定队列到交换区
//channel.QueueBind("newQueue", "NewExchange", "newRoutingKey");
//定义消息接受者
var customer = new QueueingBasicConsumer(channel);
//从指定队列获取消息,
//中间这个参数实际必须打开,为false,意思是是否不通知rabbitm已经处理完毕,我们这里要设成false,要通知
//channel.BasicConsume("firstQueue",true,customer);
channel.BasicConsume("queue.a", false, customer);
//由于队列分发不公平导致一个压力很大,一个很小,在这设置下,公平q分发,也就是一个消费者处理完通知队列后,才会继续分发一个
channel.BasicQos(, , false);
//开始不断循环出队列的消息
while (true)
{
var ea = (BasicDeliverEventArgs)customer.Queue.Dequeue();
//将消息二进制转回字符串
var msg = Encoding.UTF8.GetString(ea.Body);
//通知队列,已经处理完成
channel.BasicAck(ea.DeliveryTag, false);
Console.WriteLine(msg);
}

运行结果:

代码例子就不一一写出来了,还有很多种情况,实际项目根据不同的需求灵活运用,有兴趣的可以自己搭配测试一下。

RabbitMq应用二的更多相关文章

  1. RabbitMQ(二)

    一.启用 rabbitmq_management 插件(官网提供的 web 版管理工具) cd /usr/sbin rabbitmq-plugins enable rabbitmq_managemen ...

  2. 消息队列的使用 RabbitMQ (二): Windows 环境下集群的实现

    一.RabbitMQ 集群的基本概念 一个 RabbitMQ 中间件(broker) 由一个或多个 erlang 节点组成,节点之间共享 用户名.虚拟目录.队列消息.运行参数 等, 这个 节点的集合被 ...

  3. SpringBoot集成rabbitmq(二)

    前言 在使用rabbitmq时,我们可以通过消息持久化来解决服务器因异常崩溃而造成的消息丢失.除此之外,我们还会遇到一个问题,当消息生产者发消息发送出去后,消息到底有没有正确到达服务器呢?如果不进行特 ...

  4. python使用rabbitMQ介绍二(工作队列模式)

    一模式介绍 第一章节的生产-消费者模式,是非常简单的模式,一发一收.在实际的应用中,消费者有的时候需要工作较长的时间,则需要增加消费者. 队列模型: 这时mq实现了一下几个功能: rabbitmq循环 ...

  5. RabbitMQ (十二) 消息确认机制 - 发布者确认

    消费者确认解决的问题是确认消息是否被消费者"成功消费". 它有个前提条件,那就是生产者发布的消息已经"成功"发送出去了. 因此还需要一个机制来告诉生产者,你发送 ...

  6. Rabbitmq笔记二

    消息何去何从 mandatory 和 immediate 是 channel . basicPublish 方法中的两个参数,它们都有 当消息传递过程中不可达目的地时将消息返回给生产者的功能. 当 m ...

  7. RabbitMQ系列(二)--基础组件

    声明:对于RabbitMQ的学习基于某课网相关视频和<RabbitMQ实战指南>一书,后续关于RabbitMQ的博客都是基于二者 一.什么是RabbitMQ RabbitMQ是开源代理和队 ...

  8. RabbitMQ(二) -- Work Queues

    RabbitMQ(一) -- Work Queues RabbitMQ使用Work Queues的主要目的是为了避免资源使用密集的任务,它不同于定时任务处理的方式,而是把任务封装为消息添加到队列中.而 ...

  9. RabbitMQ系列二(构建消息队列)

    从AMQP协议可以看出,MessageQueue.Exchange和Binding构成了AMQP协议的核心.下面我们就围绕这三个主要组件,从应用使用的角度全面的介绍如何利用RabbitMQ构建消息队列 ...

随机推荐

  1. 【趣事】用 JavaScript 对抗 DDOS 攻击

    继续趣事分享. 上回聊到了大学里用一根网线发起攻击,今天接着往后讲. 不过这次讲的正好相反 -- 不是攻击,而是防御.一个奇葩防火墙的开发经历. 第二学期大家都带了电脑,于是可以用更高端的方法断网了. ...

  2. GitHub实战系列汇总篇

    基础: 1.GitHub实战系列~1.环境部署+创建第一个文件 2015-12-9 http://www.cnblogs.com/dunitian/p/5034624.html 2.GitHub实战系 ...

  3. Android Notification 详解——基本操作

    Android Notification 详解 版权声明:本文为博主原创文章,未经博主允许不得转载. 前几天项目中有用到 Android 通知相关的内容,索性把 Android Notificatio ...

  4. 设计模式之结构类模式大PK

                                      结构类模式大PK 结构类模式包括适配器模式.桥梁模式.组合模式.装饰模式.门面模式.享元模式和代理模式.之所以称其为结构类模式,是因 ...

  5. 使用NUnit为游戏项目编写高质量单元测试的思考

    0x00 单元测试Pro & Con 最近尝试在我参与的游戏项目中引入TDD(测试驱动开发)的开发模式,因此单元测试便变得十分必要.这篇博客就来聊一聊这段时间的感悟和想法.由于游戏开发和传统软 ...

  6. js学习之类型识别

    用来判别类型的方法有好多,整理了一下4种方法,平时用的时候,在不同情景下,还是要结合着使用的. 方法一 typeof:可以识别标准类型,除了Null:不能识别具体的对象类型,除了Function &l ...

  7. 在centos7中添加一个新用户,并授权

    前言 笔记本装了一个centos,想要让别人也可以登录访问,用自己的账号确实不太好,于是准备新建一个用户给他. 创建新用户 创建一个用户名为:zhangbiao [root@localhost ~]# ...

  8. C# 实时折线图,波形图

    此Demo是采用VS自带的Chart图表控件,制作实时动态显示的折线图,和波形图. 涉及到知识如下: Chart 控件,功能强大,可以绘制柱状图,折线图,波形图,饼状图,大大简化了对图的开发与定制. ...

  9. Cowboy 开源 WebSocket 网络库

    Cowboy.WebSockets 是一个托管在 GitHub 上的基于 .NET/C# 实现的开源 WebSocket 网络库,其完整的实现了 RFC 6455 (The WebSocket Pro ...

  10. ucos实时操作系统学习笔记——任务间通信(队列)

    ucos操作系统中的queue机制同样使用了event机制来实现,其实和前面的sem,mutex实现类似,所不同的是对sem而言,任务想获得信号量,对mutex而言,任务想获得的是互斥锁.任务间通信的 ...