Springboot+死信实现RabbitMQ延迟队列

原理

Springboot+死信实现RabbitMQ延迟队列_第1张图片
  生产者把带有 ttl(Time-To-Live过期时间) 的消息发送到一个临时队列(DelayQueue),该队列没有消费者;

  该消息在DelayQueue中停留直至过期,同时该消息没有ReQueue(重新入队),就变成了死信(Dead-letter或Dead-message),死信自动地被发送给了配置好的DLX(Dead-Letter-Exchange);

  DLX根据路由规则把消息路由到了配置好的队列中(DeadLetterQueue),队列中的消息被消费者消费。

maven依赖

引入amqp的依赖, 生产者和消费者都需要



	org.springframework.boot
	spring-boot-starter-amqp

boostrap配置

同样,生产者和消费者都需要
properties.yaml:

spring:
  rabbitmq:
    host: localhost
    port: 5672
    username: admin
    password: 123456

使用配置类创建各组件

rabbitmq的基本的组件是Exchange(交换机)、Queue(队列)、Binding(绑定)。实现延时队列需要定义如下组件:

  1. 一个带ttl的Queue临时队列;
  2. 一个普通的用于业务的Queue,即死信队列;
  3. 定义一个Exchange,即死信交换器DLX(Dead-Letter-Exchange);
  4. 再定义一个Bingding把死信队列和死信交换器绑定在一起。
import org.springframework.amqp.core.*;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class DelayQueueConfig {

    /**为了更贴合业务,参数名不使用DeadQueue之类的*/
    /**延迟队列名*/
    private static String DELAY_QUEUE = "delay.queue";
    /**延迟队列(死信队列)交换器名*/
    private static String DELAY_EXCHANGE = "delay.exchange";
    /**处理业务的队列(死信队列)*/
    private static String PROCESS_QUEUE = "process.queue";
    /**ttl(10秒)*/
    private static int DELAY_EXPIRATION = 10000;

    /**
    * 创建延迟队列
    * "x-dead-letter-exchange"参数定义死信队列交换机
    * "x-dead-letter-routing-key"定义死信队列中的消息重定向时的routing-key
    * "x-message-ttl"定义消息的过期时间
    */
    @Bean
    public Queue delayQueue(){
        return QueueBuilder.durable(DELAY_QUEUE)
                .withArgument("x-dead-letter-exchange", DELAY_EXCHANGE)
                .withArgument("x-dead-letter-routing-key", PROCESS_QUEUE)
                .withArgument("x-message-ttl", DELAY_EXPIRATION)
                .build();
    }

    /**创建用于业务的队列*/
    @Bean
    public Queue processQueue(){
        return QueueBuilder.durable(PROCESS_QUEUE)
                .build();
    }

    /**创建一个DirectExchange*/
    @Bean
    public DirectExchange delayExchange(){
        return new DirectExchange(DELAY_EXCHANGE);
    }

    /**绑定Exchange和queue,把消息重定向到业务queue*/
    @Bean
    Binding dlxBinding(DirectExchange directExchange, Queue processQueue){
        return BindingBuilder.bind(processQueue)
                .to(directExchange)
                .with(PROCESS_QUEUE);
                //绑定,以PROCESS_QUEUE为routing key
    }
}

生产者创建发送消息的组件

@Component
public class MessageSender {
    @Autowired
    private AmqpTemplate amqpTemplate;

    public void send(String routingKey, String msg) {
        //amqpTemplate.convertAndSend("process.queue", msg);
        amqpTemplate.convertAndSend(routingKey, msg);
    }
}

消费者自动接收并处理消息的组件

@Component
//注意监听的Queue是用于业务的ProcessQueue, 而不是临时存放消息的DelayQueue
@RabbitListener(queues = "process.queue")
public class MessageReceiver {

    @RabbitHandler()
    public void doSth(String msg) {
        //TODO
    }
}

拓展

该方案存在的缺点:消息会堆积在队列中,如果队列已满,新的消息会变为死信,会直接重发送到死信队列,此时就没有“延迟”的效果。

你可能感兴趣的:(Springboot+死信实现RabbitMQ延迟队列)