.net core 下使用 RabbitMQ 延迟队列 (三)

延迟队列，跟死信队列差不多

队列设置及参数：

参数名 类型 作用
x-message-tti(Time-To-Live) int，毫秒 对消息设置预期的时间，过期将被丢弃
x-max-length int 限制队列最大长度,个数，新增后删除最早的
x-expires int，毫秒 队列没有访问超时时，自动删除时间
x-max-length-bytes int 限制队列最大容量
x-dead-letter-exchange String 指定死信交换机
x-dead-letter-routing-key String 死信路由，指定routingKey
x-max-priority int 队列优先级
x-queue-mode 默认"lazy" 对列模式，默认lazy（将数据放入磁盘，消费时放入内存）
x-queue-master-locator QueueBuilder.MasterLocator 主队列选择策略,min-masters:选择承载最小绑定主机数量的节点,client-local:选择客户机声明队列连接到的节点,min-masters:随机选择一个节点

发送消息

 /// <summary>
        /// 建立连接实现了多线程建立
        /// </summary>
        public void Connection()
        {
            if (_connection == null)
            {
                lock (_lock)
                {
                    var connectionFactory = new ConnectionFactory()
                    {
                        HostName = _options.HostName,
                        VirtualHost = _options.VirtualHost,
                        Password = _options.Password,
                        UserName = _options.UserName,
                        Port = _options.Port
                    };
                    this._connection = connectionFactory.CreateConnection();
                }
            }
        }

 

 /// <summary>
        /// 发送延迟消息
        /// </summary>
        /// <param name="msg"></param>
        public void SendDelayMsg(string msg)
        {
            //建立连接
            Connection();
            //建立信道
            var channel = _connection.CreateModel();
            Dictionary<string, object> dic = new Dictionary<string, object>();
            //  dic.Add("x-expires", 30000); // 30秒后队列自动干掉
            dic.Add("x-message-ttl", 12000);//队列上消息过期时间，应小于队列过期时间  
            dic.Add("x-dead-letter-exchange", "exchange-direct");//过期消息转向路由  
            dic.Add("x-dead-letter-routing-key", "routing-delay");//过期消息转向路由相匹配routingkey  
            channel.ExchangeDeclare("exchange_delay", ExchangeType.Direct,true,false,null);
            channel.QueueDeclare(queue: "delay_queue",
                durable: true,
                exclusive: false,
                autoDelete: false,
                arguments: dic);
            channel.QueueBind(queue: "delay_queue", "exchange_delay", "delay_route");
            var message = "Hello World!";
            var body = Encoding.UTF8.GetBytes(message);
            //向该消息队列发送消息message
            channel.BasicPublish(exchange: "",routingKey: "delay_queue",basicProperties: null, body: body);
            Console.WriteLine(" [x] Sent {0}", message);

        }

 

接收消息

  /// <summary>
        /// 接收延迟队列
        /// </summary>
        public void ReceiveDelay(Func<string, bool> func)
        {
            //建立连接
            Connection();
            //建立信道
            IModel channel = this._connection.CreateModel();
            channel.ExchangeDeclare(exchange: "exchange-direct", type: "direct",true,false,null);
            channel.QueueDeclare("exchange-direct-queue",true,false,false,null);
            channel.QueueBind(queue: "exchange-direct-queue", exchange: "exchange-direct", routingKey: "routing-delay");

            //回调，当consumer收到消息后会执行该函数
            var consumer = new EventingBasicConsumer(channel);
            consumer.Received += (model, ea) =>
            {
                var body = ea.Body.ToArray();
                var message = Encoding.UTF8.GetString(body);
                Console.WriteLine(ea.RoutingKey);
                Console.WriteLine(" [x] Received {0}", message);
            };

            //Console.WriteLine("name:" + name);
            //消费队列"hello"中的消息
            channel.BasicConsume(queue: "exchange-direct-queue",
                                 autoAck: true,
                                 consumer: consumer);

            Console.WriteLine(" Press [enter] to exit.");
        }