NetCore RabbitMQ高级特性 持久化 及 消息优先级 NetCore RabbitMQ 的消息确认机制 NetCore RabbitMQ Topics 通配符模式

十年河东，十年河西，莫欺少年穷

学无止境，精益求精

上一节介绍了RabbitMQ定向模式，本篇介绍Rabbitmq 的消息确认机制

我的系列博客：

NetCore RabbitMQ 的消息确认机制 

NetCore RabbitMQ Topics 通配符模式

NetCore RabbitMQ ，Routing定向模式

NetCore RabbitMQ 发布订阅模式，消息广播

RabbitMQ的六种工作模式

NetCore RabbitMQ 简介及兔子生产者、消费者 【简单模式，work工作模式，竞争消费】

windows环境下，RabbitMQ 安装教程

kafka、Rabbitmq、EasyNetQ NetCore 源码下载 

先从一个方法说起，如下：

QueueDeclareOk QueueDeclare(string queue, bool durable, bool exclusive, bool autoDelete, IDictionary<string, object> arguments);

queue 队列名称

durable 是否持久化队列

exclusive 是否为单消费者队列，为True时，只能由单一消费者消费

autoDelete 是否自动删除队列，当消费者全部断开时，队列自动删除

arguments 其他属性，例如消息的声明周期，队列的存活时间等，如下：

 

x-expires	队列的存活时间	Number[毫秒]
x-message-ttl	消息的存活时间	Number[毫秒]
x-single-active-consumer	表示队列是否是单一消费者	Bool
x-max-length	队列可容纳的消息的最大条数	Number【字节】
x-max-length-bytes	队列可容纳的消息的最大字节数	Number
x-max-priority	队列的优先级	Number
x-overflow	队列中的消息溢出时,如何处理这些消息.要么丢弃队列头部的消息,要么拒绝接收后面生产者发送过来的所有消息.	String
x-dead-letter-exchange	溢出的消息需要发送到绑定该死信交换机的队列	String
x-dead-letter-routing-key	溢出的消息需要发送到绑定该死信交换机,并且路由键匹配的队列	String
x-queue-mode	默认懒人模式  lazy	String
x-queue-version	版本	Number
x-queue-master-locator	集群相关设置，Master接点	String

 

持久化

持久化包括交换机的持久化、队列的持久化，消息的持久化

创建交换机时，声明交换机的持久化：

                    //durable 是否持久化
                    //void ExchangeDeclare(string exchange, string type, bool durable, bool autoDelete, IDictionary<string, object> arguments);
                    channel.ExchangeDeclare(Ename, ExchangeType.Direct, true, false, null);

创建队列时，声明队列的持久化

                     //durable 是否持久化
                    //arguments 队列的其他参数 诸如优先级 过期时间等
                    //QueueDeclareOk QueueDeclare(string queue, bool durable, bool exclusive, bool autoDelete, IDictionary<string, object> arguments);
                    channel.QueueDeclare(QnameName, true, false, false, arguments);

把exchange和queue的durable属性设置为true，重启rabbitmq服务时( 重启命令：rabbitmqctl stop_app ;rabbitmqctl start_app )，exchange和queue也会恢复。我们需要注意的是：如果queue设置durable=true，rabbitmq服务重启后队列虽然会存在，但是队列内的消息会丢全部丢失。那么怎么实现消息的持久化呢？实现的方法很简单：将exchange和queue都设置durable=true，然后在消息发布的时候设置persistent=true即可。

消息的持久化，发生消息之前，声明消息持久化

                    var messages = "MyHello，RabbitMQ"; //   
                    var properties = channel.CreateBasicProperties();
                    properties.Priority = 9;//消息的优先级  值越大 优先级越高 0~9
                    properties.ContentType = "text/plain";//消息的内输出格式
                    properties.Persistent = true; //开启消息持久化
                    channel.BasicPublish(Ename, routingKey, properties, Encoding.UTF8.GetBytes(messages + "_" + i));  //发送消息 

 

优先级

队列的优先级

                    Dictionary<string, object> arguments = new Dictionary<string, object>();
                    ////队列优先级最高为10，不加x-max-priority的话，计算发布时设置了消息的优先级也不会生效
                    arguments.Add("x-max-priority", 10);   
                    channel.QueueDeclare(QnameName, true, false, false, arguments);

注意，如果队列没有设置优先级，不加x-max-priority的话，计算发布时设置了消息的优先级也不会生效、、

消息的优先级

                    var properties = channel.CreateBasicProperties();
                    properties.Priority = 9;//消息的优先级  值越大 优先级越高 0~9

最后，以一个实例来结束本篇博客：

using RabbitMQ.Client;
using System;
using System.Collections.Generic;
using System.Text;
using System.Threading;

namespace RabbitMqProducer
{
    class Program
    {
        static void Main(string[] args)
        {
            ConnectionFactory factory = new ConnectionFactory();
            factory.HostName = "127.0.0.1"; //主机名
            factory.UserName = "guest";//使用的用户
            factory.Password = "guest";//用户密码
            factory.Port = 5672;//端口号
            factory.VirtualHost = "/"; //虚拟主机
            factory.MaxMessageSize = 1024; //消息最大字节数
            using (var connection = factory.CreateConnection())
            {
                //rabbitMQ 基于信道进行通信，因此，我们需要实例化信道Channel
                using (var channel = connection.CreateModel())
                {
                    string Ename = "MyExChange";
                    //durable 是否持久化
                    //void ExchangeDeclare(string exchange, string type, bool durable, bool autoDelete, IDictionary<string, object> arguments);
                    channel.ExchangeDeclare(Ename, ExchangeType.Direct, true, false, null);
                    //声明广播的队列 
                    string QnameName = "MyQueue"; 
                    Dictionary<string, object> arguments = new Dictionary<string, object>();
                    ////队列优先级最高为10，不加x-max-priority的话，计算发布时设置了消息的优先级也不会生效
                    arguments.Add("x-max-priority", 10);   
                    channel.QueueDeclare(QnameName, true, false, false, arguments);

                    string routingKey = "MyroutingKey"; // 
                                                        // 
                    channel.QueueBind(QnameName, Ename, routingKey);

                    var messages = "MyHello，RabbitMQ"; //   
                    var properties = channel.CreateBasicProperties();
                    properties.Priority = 9;//消息的优先级  值越大 优先级越高 0~9
                    properties.ContentType = "text/plain";//消息的内输出格式
                    properties.Persistent = true; //开启消息持久化
                    channel.BasicPublish(Ename, routingKey, properties, Encoding.UTF8.GetBytes(messages));  //发送消息 


                }
            }
            Console.Read();
        }
    }
}

@陈大六的博客