RabbitMQ series consumption current limiting, TTL, dead letter queue and delay queue

RabbitMQ advanced features

Consumption current limit

What is consumer end flow restriction


Assuming that the MQ server receives many unprocessed messages, these messages will instantly hit the consumer client. When such a large number of messages are received, the client cannot process them. Therefore, it is necessary to limit the flow between MQ and the consumer to limit the consumption flow when the consumer consumes


RabbitMQ provides a qos (quality of service assurance) function. On the premise of non automatic confirmation messages, it sets the preprocessed traffic of channel or queue to limit the traffic. The method is as follows:

void BasicQos(uint prefetchSize,ushort prefetchCount,bool global);

Parameter Description:

prefetchSize: 0

prefetchCount: the maximum number of messages consumed. If there are already the maximum number of messages in the channel or queue and they are not signed in, no more messages will be consumed

global: whether to apply the above settings to the channel. Basically, false is used

Or configure it in application.yml

Code configuration

    port: 5672
    username: admin
    password: admin
    virtual-host: my_vhost
        prefetch: 1 # The number of preprocessed messages, that is, how many messages can be processed in one request


TTL full name time to live

If the current message has not been consumed after reaching the lifetime, it will be cleared

RabbitMQ can set the expiration time for messages or for the entire queue

Queue expiration time

// Set queue expiration time when creating a queue
public Queue topicQueue() {
    return QueueBuilder.nonDurable("topic_queue").ttl(1000).build();

Message expiration time

Message messageBody = new Message(message.getBytes());
// Set message parameters
MessageProperties messageProperties = messageBody.getMessageProperties();
// Set message expiration time
rabbitTemplate.convertAndSend("topic_exchange", routing, messageBody);


  • When the expiration time is set for both messages and queues, whichever is shorter
  • When the queue expires, messages in the entire queue are cleared
  • When there are multiple messages in the queue, only the top message will be judged whether it has expired

Dead letter queue

Dead letter queue, English abbreviation: DLX, Dead Letter Exchange (Dead Letter Exchange). When a message is called Dead message, it can be re sent to another switch, which is DLX

There are three situations in which messages are called dead letter:

  • Queue message length reached limit
  • The consumer refuses to sign in the message, and the request is set to false (do not return to the queue)
  • The message has set an expiration time, which has not been consumed

Set dead letter switch and dead letter queue and bind them

// There is no difference between dead letter switch and dead letter queue
public Exchange topicExchangeDlx() {
    return ExchangeBuilder.topicExchange("topic_exchange_dlx").build();
public Queue topicQueueDlx() {
     return QueueBuilder.nonDurable("topic_queue_dlx").build();
    public Binding topicBindingDlx(@Qualifier("topicQueueDlx") Queue topicQueue, @Qualifier("topicExchangeDlx") Exchange topicExchange) {
        return BindingBuilder.bind(topicQueue).to(topicExchange).with("dlx_queue.#").noargs();
        // dlx_queue. # is the routing rule

Bind a dead letter switch to a queue

    public Queue topicQueue() {
        return QueueBuilder.nonDurable("topic_queue")
            	// Binding dead letter switch
            	// Set dead letter routingkey

After configuring the above code, when the queue topic_ When there are three situations of dead letter in the queue, i.e. expiration, rejection and long queue, the message will be directly put into the dead letter queue


  • Dead letter switch and dead letter queue are no different from ordinary ones
  • When the message is called dead letter, it will be routed by the dead letter switch to the corresponding dead letter queue according to the routingKey rule

Delay queue

Delay queue: messages will not be consumed immediately after they arrive at the queue, but only after they arrive at the specified time

Application scenario:

  • Scheduled order expiration mechanism or similar scenario

RabbitMQ implements delay queue and TTL + dead letter queue

Set the 30 minute expiration time for ordinary queue messages. After expiration, they will be put into the dead letter queue, and then the business system only needs to consume the messages in the dead letter queue

Implementation steps

  • Define dead letter switch and dead letter queue

  • Define common switch and common queue and bind dead letter switch

  • Set the message expiration time to 30 minutes

  • Listen to the dead letter queue and get the message for business processing

The above steps are similar to the code of dead letter queue, and are not repeated

Logging and monitoring

Message tracking

RabbitMQ trace

Keywords: Java RabbitMQ

Added by john010117 on Sun, 26 Sep 2021 07:52:34 +0300