RabbitMq应用二
在应用一中,基本的消息队列使用已经完成了,在实际项目中,一定会出现各种各样的需求和问题,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应用二的更多相关文章
- RabbitMQ(二)
一.启用 rabbitmq_management 插件(官网提供的 web 版管理工具) cd /usr/sbin rabbitmq-plugins enable rabbitmq_managemen ...
- 消息队列的使用 RabbitMQ (二): Windows 环境下集群的实现
一.RabbitMQ 集群的基本概念 一个 RabbitMQ 中间件(broker) 由一个或多个 erlang 节点组成,节点之间共享 用户名.虚拟目录.队列消息.运行参数 等, 这个 节点的集合被 ...
- SpringBoot集成rabbitmq(二)
前言 在使用rabbitmq时,我们可以通过消息持久化来解决服务器因异常崩溃而造成的消息丢失.除此之外,我们还会遇到一个问题,当消息生产者发消息发送出去后,消息到底有没有正确到达服务器呢?如果不进行特 ...
- python使用rabbitMQ介绍二(工作队列模式)
一模式介绍 第一章节的生产-消费者模式,是非常简单的模式,一发一收.在实际的应用中,消费者有的时候需要工作较长的时间,则需要增加消费者. 队列模型: 这时mq实现了一下几个功能: rabbitmq循环 ...
- RabbitMQ (十二) 消息确认机制 - 发布者确认
消费者确认解决的问题是确认消息是否被消费者"成功消费". 它有个前提条件,那就是生产者发布的消息已经"成功"发送出去了. 因此还需要一个机制来告诉生产者,你发送 ...
- Rabbitmq笔记二
消息何去何从 mandatory 和 immediate 是 channel . basicPublish 方法中的两个参数,它们都有 当消息传递过程中不可达目的地时将消息返回给生产者的功能. 当 m ...
- RabbitMQ系列(二)--基础组件
声明:对于RabbitMQ的学习基于某课网相关视频和<RabbitMQ实战指南>一书,后续关于RabbitMQ的博客都是基于二者 一.什么是RabbitMQ RabbitMQ是开源代理和队 ...
- RabbitMQ(二) -- Work Queues
RabbitMQ(一) -- Work Queues RabbitMQ使用Work Queues的主要目的是为了避免资源使用密集的任务,它不同于定时任务处理的方式,而是把任务封装为消息添加到队列中.而 ...
- RabbitMQ系列二(构建消息队列)
从AMQP协议可以看出,MessageQueue.Exchange和Binding构成了AMQP协议的核心.下面我们就围绕这三个主要组件,从应用使用的角度全面的介绍如何利用RabbitMQ构建消息队列 ...
随机推荐
- .NET Core 系列5 :使用 Nuget打包类库
NuGet是个开源项目,项目包括 NuGet VS插件/NuGet Explorer/NuGetServer/NuGet命令行等项目,.NET Core项目完全使用Nuget 管理组件之间的依赖关系, ...
- Java基础Collection集合
1.Collection是所有集合的父类,在JDK1.5之后又加入了Iterable超级类(可以不用了解) 2.学习集合从Collection开始,所有集合都继承了他的方法 集合结构如图:
- Docker 第一篇--初识docker
已经多年不写博客, 看完<晓松奇谈>最后一期猛然觉醒, 决定仔细梳理下自己这几年的知识脉络. 既然决定写, 那么首先就从最近2年热门的开源项目Docker开始.Docker 这两年在国内很 ...
- 调用AJAX做登陆和注册
先建立一个页面来检测一下我们建立的用户名能不能用,看一下有没有已经存在的用户名吗 可以通过ajax提示一下 $("#uid").blur(function(){ //取用户名 va ...
- 数据库的快照隔离级别(Snapshot Isolation)
隔离级别定义事务处理数据读取操作的隔离程度,在SQL Server中,隔离级别只会影响读操作申请的共享锁(Shared Lock),而不会影响写操作申请的互斥锁(Exclusive Lock),隔离级 ...
- Java 8五大主要功能为开发者提供了哪些便利?
两年前当Java 8发布后,立即受到了业界的欢迎,因为它大大提高了Java的性能.它独特的卖点是,顾及了编程语言的每一个方面,包括JVM(Java虚拟机)和编译器,并且改良了其它帮助系统. Java是 ...
- CoreCRM 开发实录——想用国货不容易
昨天(2016年12月29日)发了开始开发的文章.本来晚上准备在 Coding.NET 上添加几个任务开始搞起了.可是真的开始用的时候才发现:Coding.NET 的任务功能只针对私有的任务开放.我想 ...
- Go web开发初探
2017年的第一篇博客,也是第一次写博客,写的不好,请各位见谅. 本人之前一直学习java.java web,最近开始学习Go语言,所以也想了解一下Go语言中web的开发方式以及运行机制. 在< ...
- [BootStrap] 富编辑器,基于wysihtml5
在我的周围,已经有很多人在使用BootStrap,但对于任何一个带留言.评论.提问.文章编辑功的网站,编辑器永远是重中之重,显然,早期的编辑器完全没考虑过BootStrap的出现,或皮肤跟网站不匹配, ...
- java 线程 Lock 锁使用Condition实现线程的等待(await)与通知(signal)
一.Condition 类 在前面我们学习与synchronized锁配合的线程等待(Object.wait)与线程通知(Object.notify),那么对于JDK1.5 的 java.util.c ...