Implementing Delayed Tasks with RabbitMQ Using Dead‑Letter Exchanges and TTL

In many e‑commerce applications, scheduled tasks such as coupon expiration, order auto‑cancellation, or payment time‑outs are traditionally implemented by repeatedly polling the database, which becomes inefficient as data volume grows. The article proposes using RabbitMQ delayed queues to offload timing logic from the database.

RabbitMQ does not provide a native delayed‑queue feature, but the same effect can be achieved by combining a dead‑letter exchange (DLX) with message TTL (time‑to‑live). When a message expires in a normal queue, it is routed to the DLX, from which it can be forwarded to a processing queue after the desired delay.

Dead‑Letter Exchange

A message is sent to a dead‑letter exchange when one of the following occurs: the consumer rejects it with requeue=false , the message TTL expires, or the queue reaches its length limit. The DLX is a regular exchange; it simply receives messages that have become dead letters.

Message TTL

TTL defines how long a message may stay in a queue before it is considered dead. RabbitMQ allows TTL to be set per‑queue or per‑message; when both are set, the smaller value wins. Setting TTL on a message is the key to implementing delayed tasks.

byte[] messageBodyBytes = "Hello, world!".getBytes();
AMQP.BasicProperties properties = new AMQP.BasicProperties();
properties.setExpiration("60000"); // 60 seconds
channel.basicPublish("my-exchange", "queue-key", properties, messageBodyBytes);

In the example above, the message will be discarded after 60 seconds if it has not been consumed, effectively creating a delay.

Processing Flow Diagram

Creating Exchanges and Queues

First, create a normal exchange named delay to act as the dead‑letter exchange.

Next, create an auto‑expire queue (e.g., delay_queue1 ) where messages are published with a TTL. The queue is configured with x-dead-letter-exchange=delay and x-dead-letter-routing-key=delay_key so that expired messages are routed to the DLX.

Finally, create a processing queue (e.g., delay_queue2 ) that will receive the delayed messages for actual handling.

Binding Queues to the Exchange

Bind delay_queue1 and delay_queue2 to the delay exchange with the appropriate routing keys ( delay for the auto‑expire queue and delay_key for the processing queue).

Sending Messages

String msg = "hello word";
MessageProperties messageProperties = new MessageProperties();
messageProperties.setExpiration("6000"); // 6 seconds
Message message = new Message(msg.getBytes(), messageProperties);
rabbitTemplate.convertAndSend("delay", "delay", message);

The key line is messageProperties.setExpiration("6000") , which sets a 6‑second delay before the message becomes a dead letter.

Receiving Messages

Configure a listener for delay_queue2 . When a message arrives after the TTL, the listener processes the business logic (e.g., closing an order) without needing to query the database for pending tasks.

package wang.raye.rabbitmq.demo1;

import org.springframework.amqp.core.*;
import org.springframework.amqp.rabbit.connection.*;
import org.springframework.amqp.rabbit.listener.*;
import org.springframework.context.annotation.*;
import java.util.UUID;

@Configuration
public class DelayQueue {
    public static final String EXCHANGE = "delay";
    public static final String ROUTINGKEY1 = "delay";
    public static final String ROUTINGKEY2 = "delay_key";

    @Bean
    public ConnectionFactory connectionFactory() {
        CachingConnectionFactory cf = new CachingConnectionFactory("120.76.237.8", 5672);
        cf.setUsername("kberp");
        cf.setPassword("kberp");
        cf.setVirtualHost("/");
        cf.setPublisherConfirms(true);
        return cf;
    }

    @Bean
    public DirectExchange defaultExchange() {
        return new DirectExchange(EXCHANGE, true, false);
    }

    @Bean
    public Queue queue() {
        return new Queue("delay_queue2", true);
    }

    @Bean
    @Autowired
    public Binding binding() {
        return BindingBuilder.bind(queue()).to(defaultExchange()).with(DelayQueue.ROUTINGKEY2);
    }

    @Bean
    @Autowired
    public SimpleMessageListenerContainer messageContainer2(ConnectionFactory connectionFactory) {
        SimpleMessageListenerContainer container = new SimpleMessageListenerContainer(connectionFactory);
        container.setQueues(queue());
        container.setExposeListenerChannel(true);
        container.setMaxConcurrentConsumers(1);
        container.setConcurrentConsumers(1);
        container.setAcknowledgeMode(AcknowledgeMode.MANUAL);
        container.setMessageListener((Message message, com.rabbitmq.client.Channel channel) -> {
            byte[] body = message.getBody();
            System.out.println("delay_queue2 received: " + new String(body));
            channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
        });
        return container;
    }
}

By handling the delayed task in the listener, the system avoids heavy database scans, improving scalability for high‑traffic scenarios.

Conclusion

Using RabbitMQ to implement delayed tasks involves setting a per‑message expiration, routing expired messages to a dead‑letter exchange, and processing them from a dedicated queue, thereby providing a reliable and low‑overhead alternative to traditional database‑polling schedulers.