RabbitMQ延时任务

mouse

　　概念：
　　消息的TTL（Time To Live）
消息的TTL就是消息的存活时间。RabbitMQ可以对队列和消息分别设置TTL。对队列设置就是队列没有消费者连着的保留时间，也可以对每一个单独的消息做单独的设置。超过了这个时间，我们认为这个消息就死了，称之为死信。
如果队列设置了，消息也设置了，那么会取小的。所以一个消息如果被路由到不同的队列中，这个消息死亡的时间有可能不一样（不同的队列设置）。这里单讲单个消息的TTL，因为它才是实现延迟任务的关键。
可以通过设置消息的expiration字段或者x-message-ttl属性来设置时间，两者是一样的效果。
消息扔到队列中后，过了设置的限定时间，如果没有被消费，它就死了。不会被消费者消费到。这个消息后面的，没有“死掉”的消息对顶上来，被消费者消费。
死信在队列中并不会被删除和释放，它会被统计到队列的消息数中去。单靠死信还不能实现延迟任务，还要靠Dead Letter Exchange。
　　Dead Letter Exchanges
Exchage的概念在这里就不在赘述，可以从这里进行了解。一个消息在满足如下条件下，会进死信路由，记住这里是路由而不是队列，一个路由可以对应很多队列。
1. 一个消息被Consumer拒收了，并且reject方法的参数里requeue是false。也就是说不会被再次放在队列里，被其他消费者使用。
2. 上面的消息的TTL到了，消息过期了。
3. 队列的长度限制满了。排在前面的消息会被丢弃或者扔到死信路由上。
Dead Letter Exchange其实就是一种普通的exchange，和创建其他exchange没有两样。只是在某一个设置Dead Letter Exchange的队列中有消息过期了，会自动触发消息的转发，发送到Dead Letter Exchange中去。
　　实现延迟队列:
延迟任务通过消息的TTL和Dead Letter Exchange来实现。我们需要建立2个队列，一个用于发送消息，一个用于消息过期后的转发目标队列。
　　发布者Code:



        public void PublishDelayMessage<T>(T message, int expireMinutes, bool durable = true) where T : class
{
if (expireMinutes <= 0)
{
throw new ArgumentException("expireMinutes 必须大于0");
}
using (var channel = connection.CreateModel())
{
var body = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(message));
//创建默认的死信交换机
string receiveExchangeName = $"{typeof(T).FullName}.DelayReceive";
string receiveQueueName = $"{receiveExchangeName}.{expireMinutes}";
channel.ExchangeDeclare(exchange: receiveExchangeName, type: "direct", durable: durable);
string bufferExchange = $"{typeof(T).FullName}.DelayBuffer";
string bufferQueueName = $"{bufferExchange}.{expireMinutes}";
channel.ExchangeDeclare(exchange: bufferExchange, type: "direct", durable: durable);
//创建消息缓冲队列，在这个队列里面实现消息的过期转发
var properties = channel.CreateBasicProperties();
//properties.Expiration = (expireMinutes * 60000).ToString();
properties.Expiration= (expireMinutes * 6000).ToString();
Dictionary<string, object> arguments = new Dictionary<string, object>();
arguments.Add("x-dead-letter-exchange", receiveExchangeName);
arguments.Add("x-dead-letter-routing-key", receiveQueueName);
channel.QueueDeclare(queue: bufferQueueName, durable: durable, exclusive: false, autoDelete: false, arguments: arguments);
channel.QueueBind(queue: bufferQueueName, exchange: bufferExchange, routingKey: bufferQueueName);
//这个队列用于消息在缓冲队列中过期后转发的目标队列
channel.QueueDeclare(queue: receiveQueueName, durable: durable, exclusive: false, autoDelete: false, arguments: null);
channel.QueueBind(queue: receiveQueueName, exchange: receiveExchangeName, routingKey: receiveQueueName);
channel.BasicPublish(exchange: bufferExchange, routingKey: bufferQueueName, basicProperties: properties, body: body);
}
}
　　消费订阅：



  /// <summary>
/// 订阅延迟消息
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="onMessage"></param>
/// <param name="expireMinutes"></param>
/// <param name="durable"></param>
/// <returns></returns>
public bool SubscribeDelayMessage<T>(Action<T> onMessage, int expireMinutes, bool durable = true) where T : class
{
if (expireMinutes <= 0)
{
throw new ArgumentException("expireMinutes 必须大于0");
}
var channel = connection.CreateModel();
string receiveExchangeName = $"{typeof(T).FullName}.DelayReceive";
string receiveQueueName = $"{receiveExchangeName}.{expireMinutes}";
channel.ExchangeDeclare(exchange: receiveExchangeName, type: "direct", durable: durable);
channel.QueueDeclare(queue: receiveQueueName, durable: durable, exclusive: false, autoDelete: false, arguments: null);
channel.QueueBind(queue: receiveQueueName, exchange: receiveExchangeName, routingKey: receiveQueueName);
var consumer = new EventingBasicConsumer(channel);
consumer.Received += (model, ea) =>
{
try
{
var message = Encoding.UTF8.GetString(ea.Body);
onMessage(JsonConvert.DeserializeObject<T>(message));
}
catch
{
}
};
channel.BasicConsume(queue: receiveQueueName, noAck: true, consumer: consumer);
return true;
}
　　虽然没贴出全部的代码，但是最核心的已经有了
　　1,设置消息的过期时间
　　2.设置缓冲队列，并且在消息过期以后转发到真实的路由中
　　看Wireshark抓包分析：
　　1.过期时间

　　可以看到发布消息的properties里面设置了expiration
　　2.过期转发

　　可以看到缓冲队列在声明的时候，设置了arguments
　　里面配置了x-dead-letter-exchange,x-dead-letter-routing-key
　　这样缓冲队列里面的消息过期以后，就将消息转发给配置的对应配置的交换机路由。
　　优化，上面的版本中，延时的时间不同，就必须要创建新的死信交换机，死信消息队列，接受交换机，接受消息队列，这样大大的浪费了资源
　　现在对其进行优化:



/// <summary>
/// 发布延迟消息，当createSpecifyReceiveQueue=true时，延迟订阅参数expireMinutes必须与本方法的expireMinutes保持一致
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="message"></param>
/// <param name="expireMinutes"></param>
/// <param name="createSpecifyReceiveQueue"></param>
/// <param name="durable"></param>
public void PublishDelayMessage<T>(T message, int expireMinutes, bool createSpecifyReceiveQueue = false, bool durable = true) where T : class
{
if (expireMinutes <= 0)
{
throw new ArgumentException("expireMinutes 必须大于0");
}
using (var channel = connection.CreateModel())
{
var body = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(message));
//创建默认的死信交换机
string receiveExchangeName = $"{typeof(T).FullName}.DelayReceive";
string receiveQueueName = "";
//创建指定的接收队列
if (createSpecifyReceiveQueue)
{
receiveQueueName = $"{receiveExchangeName}.{expireMinutes}";
}
else
{
receiveQueueName = $"{receiveExchangeName}.DelayDefaultReceive";
}
channel.ExchangeDeclare(exchange: receiveExchangeName, type: "direct", durable: durable);
string bufferExchange = $"{typeof(T).FullName}.DelayBuffer";
string bufferQueueName = "";
if (createSpecifyReceiveQueue)
{
bufferQueueName = $"{bufferExchange}.{expireMinutes}";
}
else
{
bufferQueueName = $"{bufferExchange}.Default.{expireMinutes}";
}
channel.ExchangeDeclare(exchange: bufferExchange, type: "direct", durable: durable);
//创建消息缓冲队列，在这个队列里面实现消息的过期转发
var properties = channel.CreateBasicProperties();
properties.Expiration = (expireMinutes * 60000).ToString();
Dictionary<string, object> arguments = new Dictionary<string, object>();
arguments.Add("x-dead-letter-exchange", receiveExchangeName);
arguments.Add("x-dead-letter-routing-key", receiveQueueName);
channel.QueueDeclare(queue: bufferQueueName, durable: durable, exclusive: false, autoDelete: false, arguments: arguments);
channel.QueueBind(queue: bufferQueueName, exchange: bufferExchange, routingKey: bufferQueueName);
//这个队列用于消息在缓冲队列中过期后转发的目标队列
channel.QueueDeclare(queue: receiveQueueName, durable: durable, exclusive: false, autoDelete: false, arguments: null);
channel.QueueBind(queue: receiveQueueName, exchange: receiveExchangeName, routingKey: receiveQueueName);
channel.BasicPublish(exchange: bufferExchange, routingKey: bufferQueueName, basicProperties: properties, body: body);
}
}
/// <summary>
/// 订阅延迟消息，注意：如果expireMinutes>0，发布的延迟消息的参数createSpecifyReceiveQueue必须设置为true
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="onMessage"></param>
/// <param name="expireMinutes"></param>
/// <param name="durable"></param>
/// <returns></returns>
public bool SubscribeDelayMessage<T>(Action<T> onMessage, int expireMinutes = 0, bool durable = true) where T : class
{
var channel = connection.CreateModel();
string receiveExchangeName = $"{typeof(T).FullName}.DelayReceive";
string receiveQueueName = "";
channel.ExchangeDeclare(exchange: receiveExchangeName, type: "direct", durable: durable);
if (expireMinutes <= 0)
{
receiveQueueName = $"{receiveExchangeName}.DelayDefaultReceive";
channel.QueueDeclare(queue: receiveQueueName, durable: durable, exclusive: false, autoDelete: false, arguments: null);
}
else
{
receiveQueueName = $"{receiveExchangeName}.{expireMinutes}";
channel.QueueDeclare(queue: receiveQueueName, durable: durable, exclusive: false, autoDelete: false, arguments: null);
}
channel.QueueBind(queue: receiveQueueName, exchange: receiveExchangeName, routingKey: receiveQueueName);
var consumer = new EventingBasicConsumer(channel);
consumer.Received += (model, ea) =>
{
try
{
var message = Encoding.UTF8.GetString(ea.Body);
onMessage(JsonConvert.DeserializeObject<T>(message));
}
catch
{
}
};
channel.BasicConsume(queue: receiveQueueName, noAck: true, consumer: consumer);
return true;
}