RabbitMQ 延迟队列

延迟队列：在指定时间之后取出处理
使用场景：订单在十分钟之内未支付则自动取消，用户注册成功后如果三天内没有登陆则进行短信提醒

延时队列：
(1)在队列定义时为队列设置TTL
(2)通用的延时队列(发送消息时为消息设置TTL)

如果在TTL设置的时间内没有被消费，则会成为"死信" -> 转到死信队列
如果同时配置了队列的TTL和消息的TTL，那么较小的那个值将会被使用
在消息属性上设置TTL，消息可能不会按时“死亡“，因为RabbitMQ只会检查第一个消息是否过期

整合springboot：
(1)创建springboot项目
(2)添加依赖
<dependencies>
    <!--RabbitMQ 依赖-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-amqp</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>fastjson</artifactId>
        <version>1.2.47</version>
    </dependency>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
    </dependency>
    <!--swagger-->
    <dependency>
        <groupId>io.springfox</groupId>
        <artifactId>springfox-swagger2</artifactId>
        <version>2.9.2</version>
    </dependency>
    <dependency>
        <groupId>io.springfox</groupId>
        <artifactId>springfox-swagger-ui</artifactId>
        <version>2.9.2</version>
    </dependency>
    <!--RabbitMQ 测试依赖-->
    <dependency>
        <groupId>org.springframework.amqp</groupId>
        <artifactId>spring-rabbit-test</artifactId>
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-test</artifactId>
        <version>5.3.13</version>
        <scope>compile</scope>
    </dependency>
</dependencies>

(3)修改配置文件
spring.rabbitmq.host=192.168.196.129
spring.rabbitmq.port=5672
spring.rabbitmq.username=admin
spring.rabbitmq.password=123

(4)添加Swagger配置类
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import springfox.documentation.builders.ApiInfoBuilder;
import springfox.documentation.service.ApiInfo;
import springfox.documentation.service.Contact;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spring.web.plugins.Docket;
import springfox.documentation.swagger2.annotations.EnableSwagger2;

@Configuration
@EnableSwagger2
public class SwaggerConfig {
    @Bean
    public Docket webApiConfig() {
        return new Docket(DocumentationType.SWAGGER_2)
                .groupName("webApi")
                .apiInfo(webApiInfo())
                .select()
                .build();
    }

    private ApiInfo webApiInfo() {
        return new ApiInfoBuilder()
                .title("接口文档")
                .description("本文档描述了rabbitmq微服务接口")
                .version("1.0")
                .contact(new Contact("联系我", "http://baidu.com", "123@163.com"))
                .build();
    }
}

(5)交换机、队列配置类
 import org.springframework.amqp.core.*;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import java.util.HashMap;
import java.util.Map;

@Configuration
public class TtlQueueConfig {
    public static final String X_EXCHANGE = "X";
    public static final String Y_EXCHANGE = "Y";
    public static final String QUEUE_QA = "QA";
    public static final String QUEUE_QB = "QB";
    public static final String QUEUE_QD = "QD";

    //声明交换机
    @Bean("xExchange")
    public DirectExchange xExchange() {
        return new DirectExchange(X_EXCHANGE);
    }

    //声明交换机
    @Bean("yExchange")
    public DirectExchange yExchange() {
        return new DirectExchange(Y_EXCHANGE);
    }

    //声明QA队列，设置ttl=10s，设置死信到死信队列
    @Bean("queueQA")
    public Queue queueQA() {
        Map<String, Object> args = new HashMap<>(3);
        args.put("x-dead-letter-exchange", Y_EXCHANGE);
        args.put("x-dead-letter-routing-key", "YD");
        //声明队列的 TTL=10s
        args.put("x-message-ttl", 10000);
        return QueueBuilder.durable(QUEUE_QA).withArguments(args).build();
    }

    //声明QB队列，设置死信到死信队列
    @Bean("queueQB")
    public Queue queueQB() {
        Map<String, Object> args = new HashMap<>(3);
        args.put("x-dead-letter-exchange", Y_EXCHANGE);
        args.put("x-dead-letter-routing-key", "YD");
        return QueueBuilder.durable(QUEUE_QB).withArguments(args).build();
    }

    //声明死信队列QD
    @Bean("queueQD")
    public Queue queueQD() {
        return new Queue(QUEUE_QD);
    }

    //绑定QA与X
    @Bean
    public Binding queueQABindingX(@Qualifier("queueQA") Queue queueQA,
                                   @Qualifier("xExchange") DirectExchange xExchange) {
        return BindingBuilder.bind(queueQA).to(xExchange).with("XA");
    }

    //绑定QB与X
    @Bean
    public Binding queueQBBindingX(@Qualifier("queueQB") Queue queueQB,
                                   @Qualifier("xExchange") DirectExchange xExchange) {
        return BindingBuilder.bind(queueQB).to(xExchange).with("XB");
    }

    //绑定QD与Y
    @Bean
    public Binding queueQDBindingY(@Qualifier("queueQD") Queue queueQD,
                                   @Qualifier("yExchange") DirectExchange yExchange) {
        return BindingBuilder.bind(queueQD).to(yExchange).with("YD");
    }
}

(6)消息生产者
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import javax.annotation.Resource;
import java.util.Date;

@Slf4j
@RequestMapping("ttl")
@RestController
public class SendMsgController {
    @Resource
    private RabbitTemplate rabbitTemplate;

    @GetMapping("sendMsg/{message}")
    public void sendMsg(@PathVariable String message) {
        log.info("当前时间：{},发送一条消息给QA队列，队列已设置ttl=10s：{}", new Date(), message);
        rabbitTemplate.convertAndSend("X", "XA", "消息发送到ttl=10s的QA队列：" + message);
    }

    @GetMapping("sendExpirationMsg/{message}/{ttlTime}")
    public void sendMsg(@PathVariable String message, @PathVariable String ttlTime) {
        log.info("当前时间：{},发送一条TTL={}ms的信息给队列QB：{}", new Date(), ttlTime, message);
        rabbitTemplate.convertAndSend("X", "XB", message, correlationData -> {
            correlationData.getMessageProperties().setExpiration(ttlTime);
            return correlationData;
        });
    }
}

(7)消息消费者(消费死信队列)
import com.rabbitmq.client.Channel;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;
import java.util.Date;

@Slf4j
@Component
public class DeadLetterQueueConsumer {
    @RabbitListener(queues = "QD")
    public void receiveD(Message message, Channel channel) {
        String msg = new String(message.getBody());
        log.info("当前时间：{},收到死信队列信息：{}", new Date().toString(), msg);
    }
}

swagger访问地址：http://localhost:8080/swagger-ui.html

测试：
http://localhost:8080/ttl/sendMsg/你好  -> 发送给QA队列，QA队列设置了TTL=10s，10s后消息变为死信，转发到死信队列QD
http://localhost:8080/ttl/sendExpirationMsg/你好1/20000 -> 发送的消息设置TTL=20s，20s后成为死信(也不一定按时变为死信)
http://localhost:8080/ttl/sendExpirationMsg/你好2/1000  -> 发送的消息设置TTL=1s，消
息可能并不会按时变为死信，因为RabbitMQ只会检查第一个消息是否过期

消息设置TTL延时队列存在的问题：
在消息属性上设置TTL的方式，到达队列后，消息可能并不会按时“死亡“ -> 转到死信队列，队列是先进先出且只检查第一个消息是否过期
解决办法：使用延迟交换机
(1)下载插件(下载https://www.rabbitmq.com/community-plugins.html)
下载插件rabbitmq_delayed_message_exchange，rabbitmq_delayed_message_exchange-3.8.0.ez 放到RabbitMQ插件目录
cd /usr/lib/rabbitmq/lib/rabbitmq_server-3.8.8/plugins
rabbitmq-plugins enable rabbitmq_delayed_message_exchange
重启RabbitMQ：systemctl restart rabbitmq-server ，重启后Exchanges多一种类型x-delayed-message
延迟交换机：支持延迟投递机制 消息传递后并不会立即投递到目标队列中，而是存储在 mnesia(一个分布式数据系统)表中，当达到投递时间时，才投递到目标队列中

(2)交换机、队列配置类
@Configuration
public class DelayedExchangeConfig {

    public static final String DELAYED_EXCHANGE_NAME = "DX";
    public static final String DELAYED_QUEUE_NAME = "QC";
    public static final String DELAYED_ROUTING_KEY = "dk";

    //定义延迟交换机
    @Bean
    public CustomExchange delayedExchange() {
        Map<String, Object> args = new HashMap<>();
        args.put("x-delayed-type", "direct");
        return new CustomExchange(DELAYED_EXCHANGE_NAME, "x-delayed-message", true, false, args);
    }

    //定义队列
    @Bean
    public Queue delayedQueue() {
        return new Queue(DELAYED_QUEUE_NAME);
    }

    //绑定队列与交换机
    @Bean
    public Binding bindingDelayedQueue(@Qualifier("delayedQueue") Queue delayedQueue,
                                       @Qualifier("delayedExchange") CustomExchange delayedExchange) {
        return BindingBuilder.bind(delayedQueue).to(delayedExchange).with(DELAYED_ROUTING_KEY).noargs();
    }
}

(3)生产者
@GetMapping("sendDelayMsg/{message}/{delayTime}")
public void sendMsg(@PathVariable String message, @PathVariable Integer delayTime) {
    rabbitTemplate.convertAndSend("DX", "dk", message,
            correlationData -> {
                correlationData.getMessageProperties().setDelay(delayTime);
                return correlationData;
            });
    log.info(" 当前时间：{}, 发送一条延迟{}ms的信息给队列QC:{}", new Date(), delayTime, message);
}

(4)消费者
@RabbitListener(queues = "QC")
public void receiveDelayedQueue(Message message) {
    String msg = new String(message.getBody());
    log.info("当前时间：{},收到延时队列的消息：{}", new Date().toString(), msg);
}

测试：
http://localhost:8080/ttl/sendDelayMsg/你好1/20000 
http://localhost:8080/ttl/sendDelayMsg/你好2/1000