RabbitMQ实现延迟队列

1. 导包

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>

2. 配置文件

spring:
  rabbitmq:
    host: 127.0.0.1
    port: 5672
    virtual-host: /test
    username: guest
    password: guest
    listener:
      simple:
        acknowledge-mode: manual
    publisher-confirm-type: simple
    publisher-returns: true

2. 声明交换机和队列

package top.scsoul.amqp.config;

import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.*;
import org.springframework.amqp.rabbit.connection.CorrelationData;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import javax.annotation.PostConstruct;
import javax.annotation.Resource;
import java.util.HashMap;
import java.util.Map;
@Slf4j
@Configuration
public class RabbitMqConfig implements RabbitTemplate.ConfirmCallback,RabbitTemplate.ReturnsCallback{

    @Resource
    RabbitTemplate rabbitTemplate;


    @PostConstruct
    private void init(){
        rabbitTemplate.setConfirmCallback(this);
        rabbitTemplate.setReturnsCallback(this);
    }




    /**
     * 死信交换价
     */
    private final String DIED_EXCHANGE = "died.exchange";
    /**
     * 死信队列
     */
    private final String DIED_QUEUE = "diedQueue";

    /**
     * 普通交换机
     */
    private final String NORMAL_EXCHANGE = "normal.exchange";

    /**
     * 延迟队列
     */
    private final String DELAY_QUEUE = "delayQueue";

    /**
     * 死信交换机
     *
     * @return
     */
    @Bean
    public DirectExchange diedExchange() {
        return new DirectExchange(DIED_EXCHANGE, true, false);
    }

    /**
     * 普通交换机
     *
     * @return
     */
    @Bean
    public DirectExchange normalExchange() {
        return new DirectExchange(NORMAL_EXCHANGE, true, false);
    }

    /**
     * 死信队列
     *
     * @return
     */
    @Bean
    public Queue diedQueue() {
        return new Queue(DIED_QUEUE, true, false, false, null);
    }


    /**
     * 延迟队列
     *
     * @return
     */
    @Bean
    public Queue delayQueue() {
        Map<String, Object> params = new HashMap<>();
        //声明了队列里的死信转发到的DLX名称，
        params.put("x-dead-letter-exchange", DIED_EXCHANGE);
        //声明了这些死信在转发时携带的 routing-key 名称。
        params.put("x-dead-letter-routing-key", "");
        params.put("x-message-ttl", 5 * 1000);
        return new Queue(DELAY_QUEUE, true, false, false, params);
    }


    @Bean
    public Binding diedBinding() {
        return BindingBuilder.bind(diedQueue()).to(diedExchange()).with("");
    }

    @Bean
    public Binding delayBinding() {
        return BindingBuilder.bind(delayQueue()).to(normalExchange()).with("");
    }


    @Override
    public void confirm(CorrelationData correlationData, boolean ack, String cause) {
        log.info("confirm ack:{}",ack);
    }

    @Override
    public void returnedMessage(ReturnedMessage returned) {
        log.info("returnedMessage returned:{}",returned.getMessage());
    }
}

3. 编写测试方法

    @GetMapping("/send")
    public String send() {
        rabbitTemplate.convertAndSend("delayQueue","数据xxxxxxxx");
        return "ok";
    }

4. 编写处理器方法

    @RabbitListener(ackMode = "MANUAL", queues = "diedQueue")
    public void receiveMsg1(Message message, Channel channel) throws  IOException {
        System.out.println("接收到消息：" + message.toString());
        channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
    }