RabbitMQ实现延时队列Demo

**延时队列：**通过死信队列实现，将消息发送至延时队列，设置延时队列的过期时间，例如5秒钟，等待5秒之后，该消息会被放入死信队列，由死信进行转发到普通队列中

简单的配置文件：

spring:
  rabbitmq:
    virtual-host: /
    addresses: localhost
    username: guest
    password: guest
    port: 5672
  application:
    name: consumer-01

配置RabbitMQ的队列以及交换机：

package com.example.consumer01.config;

import org.springframework.amqp.core.*;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.HashMap;
import java.util.Map;

/**
 * @author liyunxing
 * @package com.example.consumer01.config
 * @code
 * @description:
 * @since 2019/4/25 9:42
 */
@Configuration
public class RabbitConfig {

    //死信交换机
    public static final String DELAY_EXCHANGE = "delay-exchange";
    //死信路由
    public static final String DELAY_ROUTING_KEY = "delay-routing-key";
    //死信队列
    public static final String DELAY_QUEUE = "delay-queue";

    //普通交换机
    public static final String NORMAL_EXCHANGE = "normal-exchange";
    //普通路由
    public static final String NORMAL_ROUTING_KEY = "normal-routing-key";
    //普通队列
    public static final String NORMAL_QUEUE = "normal-queue";

    /**
     * 创建延时队列
     */
    @Bean
    public Queue getDelayQueue(){
        Map args = new HashMap();
        /**
         * 消息发送给延时队列
         * 设置延时队列的过期时间为5秒钟
         * 5秒之后，延时队列将消息发送给普通队列
         */
        args.put("x-dead-letter-exchange",NORMAL_EXCHANGE);
        args.put("x-dead-letter-routing-key",NORMAL_ROUTING_KEY);
        args.put("x-message-ttl",5000);
        return QueueBuilder.durable(DELAY_QUEUE).withArguments(args).build();
    }
    //创建延时交换机
    @Bean
    public Exchange getDelayExchange(){
        return ExchangeBuilder.directExchange(DELAY_EXCHANGE).durable(true).build();
    }
    //延时与延时交换机进行绑定
    @Bean
    public Binding bindDelay(){
        return BindingBuilder.bind(getDelayQueue()).to(getDelayExchange()).with(DELAY_ROUTING_KEY).noargs();
    }

    //创建普通队列
    @Bean
    public Queue getNormalQueue(){
        return new Queue(NORMAL_QUEUE);
    }
    //创建普通交换机
    @Bean
    public Exchange getNormalExchange(){
        return ExchangeBuilder.directExchange(NORMAL_EXCHANGE).durable(true).build();
    }
    //普通队列与普通交换机进行绑定
    @Bean
    public Binding bindNormal(){
        return BindingBuilder.bind(getNormalQueue()).to(getNormalExchange()).with(NORMAL_ROUTING_KEY).noargs();
    }
}

设置消费者，监听普通队列

package com.example.consumer01.rabbit;

import com.example.consumer01.config.RabbitConfig;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

/**
 * @author liyunxing
 * @package com.example.consumer01.rabbit
 * @code
 * @description:
 * @since 2019/4/25 9:43
 */
@Component
public class Consumer01 {

    //监听延迟队列，将在五秒之后收到消息
    @RabbitListener(queues = {RabbitConfig.NORMAL_QUEUE})
    public void receiver(String msg){
        System.out.println("normal queue 收到消息>>>>>>>>>"+msg);
    }
}

将信息发送至死信队列，消息在死信队列中停留五秒之后，转发到普通队列

package com.example.consumer01;

import com.example.consumer01.config.RabbitConfig;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

@RunWith(SpringRunner.class)
@SpringBootTest
public class Consumer01ApplicationTests {

    Logger logger = LoggerFactory.getLogger(Consumer01ApplicationTests.class);

    @Autowired
    private RabbitTemplate rabbitTemplate;

    @Test
    public void contextLoads() {
        String msg = "hello world";
        /**
         * 发送给普通对队列,设置五秒之后过期
         * 但是并没有实现消费的监听，因此该消息将在五秒之后过期
         */
        rabbitTemplate.convertAndSend(RabbitConfig.DELAY_EXCHANGE,RabbitConfig.DELAY_ROUTING_KEY,msg);
        logger.info("message is {}"+msg);
        }
}