RabbitMQ Queue Arguments

Message TTL

message在队列中可以存活多长时间，以毫秒为单位；发布的消息在queue时间超过了你设定的时间就会被删除掉。

channel.QueueDeclare("test", true, false, false, new Dictionary<string, object> { { "x-message-ttl", 60000 } });

设置queue的消息过期时间为60秒！

var properties = channel.CreateBasicProperties();
//设置过期时间
properties.Expiration = "60000";
channel.BasicPublish(null, "test", properties, Encoding.UTF8.GetBytes("60”秒后就会消失"));

针对message ,设置queue里的某条message在多久消失

Auto expire

auto expire  设置当前的queue在指定的时间内，没有consumer、basic.get也就是未被访问，就会被删除。

//声明一个queue，queue60秒内而且未被任何形式的消费,则被删除
channel.QueueDeclare("queue", true, false, false, new Dictionary<string, object> { { "x-expires", 60000 } });

MaxLength与MaxLength bytes

 channel.QueueDeclare("queue", true, false, false, new Dictionary<string, object>
                {
                    { "x-max-length", 100},
                    { "x-max-length-bytes", 20480}
                });

Dead letter exchagne 与 Dead letter routing key

就像上面的messagettl，maxlength等。消息因为超时或超过限制在队列里消失，这样我们就丢失了一些消息，也许里面就有一些是我们做需要获知的。而rabbitmq的死信功能则为我们带来了解决方案。设置了dead letter exchange与dead letter routingkey（要么都设定，要么都不设定）那些因为超时或超出限制而被删除的消息会被推动到我们设置的exchange中，再根据routingkey推到queue中

using (var channel = RabbitMqHelper.GetConnection().CreateModel())
            {

                //声明一个带有死信功能功能的queue exchange: dlexchange  queue: dlexqueue
                channel.QueueDeclare("testqueue", true, false, false, new Dictionary<string, object>
                {
                    { "x-message-ttl",5000},
                    { "x-dead-letter-exchange", "dlexchange" },
                    { "x-dead-letter-routing-key", "dlexqueue"}
                });

                //负责死信的交换机
                channel.ExchangeDeclare("dlexchange", ExchangeType.Direct, true, false, null);

                channel.QueueDeclare("dlexqueue", true, false, false, null);
                channel.QueueBind("dlexqueue", "dlexchange", "dlexqueue", null);

                var consumer = new EventingBasicConsumer(channel);

                consumer.Received += (sender, e) =>
                {
                    Console.WriteLine(Encoding.UTF8.GetString(e.Body));
                };
                channel.BasicConsume("testqueue", true, consumer);

                Console.WriteLine("consumer启动成功");

                Console.ReadKey();

            }

//创建返回一个新的频道
            using (var channel = RabbitMqHelper.GetConnection().CreateModel())
            {

                channel.BasicPublish(string.Empty, "testqueue", null, Encoding.UTF8.GetBytes("我五秒后就会消失"));

                Console.ReadKey();

            }

//创建返回一个新的频道
            using (var channel = RabbitMqHelper.GetConnection().CreateModel())
            {

                channel.QueueDeclare("priorityQueue", true, false, false, new Dictionary<string, object> { { "x-max-priority", 5 } });

                var properties = channel.CreateBasicProperties();

                for (var i = 0; i < 6; i++)
                {
                    properties.Priority = (byte)i;
                    channel.BasicPublish(string.Empty, "priorityQueue", properties, Encoding.UTF8.GetBytes($"{i}级别的消息"));
                }

                Console.ReadKey();

            }

Queue 会把优先级高的，先发送给consumer

Lazy Queue

lazy queue是在3.6.0版本被引入的，lazy queue的信息尽可能的都保存在磁盘上，仅在消费者请求的时候才会加载到RAM中。

使用默认的queue，并且消息不持久化的话，都是放在RAM中的。当消息峰值的时候，大量的消息在RAM导致rabbitmq服务器压力过大，当RAM使用量到一定数字的时候就会因为压力把数据移到硬盘中，但是不要嗨皮，rabbitmq服务器重启后消息一样会丢失。而且过大的压力可能会出现各种各样的异常情况，这并不是我们想要看到的

lazy queue 消息不持久化 ， 但是这种模式还是会把消息放到硬盘里，RAM的使用率会一直很稳定，但是重启后一样会丢失消息

lazy queue 消息持久化，这种方式无疑是最佳搭配，消息放到硬盘并且不会因为服务器重启而丢失，面对高并发也是从容不已

      channel.QueueDeclare("lazyqueue", true, false, false, new Dictionary<string, object>
                {
                    { "x-queue-mode","lazy"}
                });