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构建消息队列 ...

随机推荐

01.SQLServer性能优化之----强大的文件组----分盘存储
汇总篇:http://www.cnblogs.com/dunitian/p/4822808.html#tsql 文章内容皆自己的理解,如有不足之处欢迎指正~谢谢前天有学弟问逆天:“逆天,有没有一种方 ...
关于几个主流语音SDK的接入问题
这两周都在忙着游戏上线还有接入游戏语音,两周分别接了腾讯语音和百度语音!!! 关于腾讯语音的一些问题由于发现腾讯语音的在录完音频后的数据是编过码的所以出现了一些问题: *不能解码(腾讯方不提供解码算 ...
DDD 领域驱动设计－看我如何应对业务需求变化，愚蠢的应对？
写在前面阅读目录: 具体业务场景业务需求变化 "愚蠢"的应对消息列表实现消息详情页实现消息发送.回复.销毁等实现回到原点的一些思考业务需求变化,领域模型变化了吗? 对 ...
使用CSS3实现一个3D相册
CSS3系列我已经写过两篇文章,感兴趣的同学可以先看一下CSS3初体验之奇技淫巧,CSS3 3D立方体效果-transform也不过如此第一篇主要列出了一些常用或经典的CSS3技巧和方法:第二篇是一 ...
SELECT INTO 和 INSERT INTO SELECT 两种表复制语句
Insert是T-sql中常用语句,Insert INTO table(field1,field2,...) values(value1,value2,...)这种形式的在应用程序开发中必不可少.但我 ...
C#中如何调整图像大小
在本篇文章中,我将介绍如何在C#中来调整你想要的图像大小.要实现这一目标,我们可以采取以下几个步骤: 1.首先要获取你想要调整大小的图像: string path = Server.MapPath(& ...
javascript动画系列第二篇——磁性吸附
× 目录 [1]范围限定 [2]拖拽范围 [3]磁性吸附前面的话上一篇,我们介绍了元素拖拽的实现.但在实际应用中,常常需要为拖拽的元素限定范围.而通过限定范围,再增加一些辅助的措施,就可以实现磁性 ...
C#发送邮箱
之前自己从来没有做过发送邮箱的功能,前段时间项目需要,在找了很多帖子之后,终于实现了. 之后有整理了一下,写了一个类.直接给类传递信息,就可以发送了. 这里还需要说明的是,发送邮箱需要开通POP3/S ...
BPM体系文件管理解决方案分享
一.方案概述企业管理在很大程度上是通过文件化的形式表现出来,体系文件管理是管理体系存在的基础和证据,是规范企业管理活动和全体人员行为,达到管理目标的管理依据.对与公司质量.环境.职业健康安全等体系有 ...
Android开发学习——动画
帧动画> 一张张图片不断的切换,形成动画效果* 在drawable目录下定义xml文件,子节点为animation-list,在这里定义要显示的图片和每张图片的显示时长 ...

RabbitMq应用二

RabbitMq应用二的更多相关文章

随机推荐

热门专题