使用rabbitmq 实现延迟消费

最新推荐文章于 2024-08-17 15:29:37 发布

我家小宝_朱朱

最新推荐文章于 2024-08-17 15:29:37 发布

阅读量4.7k

点赞数

分类专栏： rabbitmq springboot

原文链接：https://www.jianshu.com/p/a06a363fd973

版权

springboot 同时被 2 个专栏收录

68 篇文章 0 订阅

订阅专栏

rabbitmq

21 篇文章 0 订阅

订阅专栏

rabbitmq 实现延迟队列

什么是延迟队列

延迟队列存储的对象肯定是对应的延时消息，所谓”延时消息”是指当消息被发送以后，并不想让消费者立即拿到消息，而是等待指定时间后，消费者才拿到这个消息进行消费。

比如以下场景：在订单系统中，一个用户下单之后通常有30分钟的时间进行支付，如果30分钟之内没有支付成功，那么这个订单将进行一场处理。这是就可以使用延时队列将订单信息发送到延时队列。

RabbitMQ如何实现迟队列

AMQP协议和RabbitMQ队列本身没有直接支持延迟队列功能，但是可以通过以下特性模拟出延迟队列的功能。

但是我们可以通过RabbitMQ的两个特性来曲线实现延迟队列：

特性1、Time To Live(TTL)

  RabbitMQ可以针对Queue设置x-expires 或者 针对Message设置 x-message-ttl，来控制消息的生存时间，如果超时(两者同时设置以最先到期的时间为准)，则消息变为dead letter(死信)
    
  RabbitMQ针对队列中的消息过期时间有两种方法可以设置。  
  
    A:  通过队列属性设置，队列中所有消息都有相同的过期时间。
    B:  对消息进行单独设置，每条消息TTL可以不同。
    
    如果同时使用，则消息的过期时间以两者之间TTL较小的那个数值为准。消息在队列的生存时间一旦超过设置的TTL值，就成为dead letter

特性2、Dead Letter Exchanges（DLX）

RabbitMQ的Queue可以配置x-dead-letter-exchange和x-dead-letter-routing-key（可选）两个参数，如果队列内出现了dead letter，则按照这两个参数重新路由转发到指定的队列。

x-dead-letter-exchange：出现dead letter之后将dead letter重新发送到指定exchange
x-dead-letter-routing-key：出现dead letter之后将dead letter重新按照指定的routing-key发送
  
队列出现dead letter的情况有：  
  消息或者队列的TTL过期
  队列达到最大长度
  消息被消费端拒绝（basic.reject or basic.nack）并且requeue=false

综合上述两个特性，设置了TTL规则之后当消息在一个队列中变成死信时，利用DLX特性它能被重新转发到另一个Exchange或者Routing Key，这时候消息就可以重新被消费了。

具体实现思路

订单队列配置转发规则（如果没有任何规则，则直接丢弃死信），当队列中消息超时的时候自动转发到超时订单队列中

springboot 的rabbit的配置

1、引入spring-rabbit

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

2、配置application.properties

spring.rabbitmq.host=127.0.0.1
spring.rabbitmq.port=5672
spring.rabbitmq.username=guest
spring.rabbitmq.password=guest
spring.rabbitmq.publisher-confirms=true
spring.rabbitmq.virtual-host=/

3、配置订单队列，订单超时队列，并配置相应的exchange和routingKey

@Configuration
public class OrderQueueConfig {

    /**
     * 订单队列
     */
    public static final String ORDER_QUEUE = "woniu.order.queue";

    /**
     * 超时订单队列
     */
    public static final String ORDER_EXCHANGE = "woniu.order.exchage";

    /**
     * 订单exchange
     */
    public static final String ORDER_TIMEOUT_QUEUE = "woniu.order.timeout.queue";


    /**
     * 订单exchange
     */
    @Bean
    public DirectExchange orderExchange(){
        return new DirectExchange(ORDER_EXCHANGE,true,false,null);
    }

    /**
     * 订单队列
     */
    @Bean
    public Queue orderQueue() {
        // 设置超时转发策略 超时后消息会通过x-dead-letter-exchange 转发到x-dead-letter-routing-key绑定的队列中
        Map<String, Object> arguments = new HashMap<>(2);
        arguments.put("x-dead-letter-exchange", ORDER_EXCHANGE);
        arguments.put("x-dead-letter-routing-key", ORDER_TIMEOUT_QUEUE);
        Queue queue = new Queue(ORDER_QUEUE,true,false,false,arguments);
        return queue;
    }

    /**
     * 超时订单队列
     * @return
     */
    @Bean
    public Queue orderTimeoutQueue() {
        Queue queue = new Queue(ORDER_TIMEOUT_QUEUE,true,false,false);
        return queue;
    }

    /**
     * 订单队列绑定exchange
     * @return
     */
    @Bean
    public Binding orderQueueBinding() {
        return BindingBuilder.bind(orderQueue()).to(orderExchange()).with(ORDER_QUEUE);
    }


    /**
     * 超时订单队列绑定exchange
     * @return
     */
    @Bean
    public Binding  orderTimeoutQueueBinding() {
        return BindingBuilder.bind(orderTimeoutQueue()).to(orderExchange()).with(ORDER_TIMEOUT_QUEUE);
    }
}

4、创建生产者，并在发送消息的时候指定超时时间

@Service
public class OrderProducer {

    @Autowired
    private AmqpTemplate template;

    public void sendOrder(String orderId) {
        template.convertAndSend(OrderQueueConfig.ORDER_EXCHANGE, OrderQueueConfig.ORDER_QUEUE, orderId, message -> {
            // 设置超时时间 3000ms
            message.getMessageProperties().setExpiration("3000");
            return message;
        });
    }
}

5、创建消费者，消费者消费订单超时队列

@Service
public class OrderConsumer {
    @RabbitHandler
    @RabbitListener(queues = OrderQueueConfig.ORDER_TIMEOUT_QUEUE,concurrency="4-10")
    public void consumeTimeOutQueue(@Payload String orderId){
        System.out.println("接收到消息的时间"+System.currentTimeMillis());
        System.out.println("消息ID="+orderId);
    }
}

6、测试

public String sendOrder(String orderId){
   System.out.println("消息发送时间:"+System.currentTimeMillis());
   orderProducer.sendOrder(orderId);
   return "sendOrder";
}

7、结果

消息发送时间   :1538270251066
接收到消息的时间:1538270254123
消息ID=hello

我的使用场景，任务放到延迟队列，到时间后，转到消费队列



@Configuration
public class RabbitConfig {

    public static final String TASKCHECK_EXCHANGE_NAME="taskcheck.exchange";
    public static final String TASKCHECK_ROUTING_KEY="taskcheck";
    public static final String DELAY_TASKCHECK_QUEUE="delaytaskcheck";
    public static final String TASKCHECK_QUEUE="taskcheck";
    public static final String DELAY_TASKCHECK_EXCHANGE="delaytaskcheck.exchange";
    public static final String DELAY_ROUTING_KEY="delaytaskcheck";

    public static final String DELAY_TASKMAKEUP_QUEUE="delaytaskmakeup";
    public static final String DELAY_MAKEUP_ROUTING_KEY="delaytaskmakeup";


    public static final String TIMEDTASK_QUEUE="timedTask";
    public static final String TIMEDTASK_EXCHANGE_NAME="timedTask.exchange";
    public static final String TIMEDTASK_ROUTING_KEY="timedTask";





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


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


    /**
     * 需要将一个队列绑定到交换机上，要求该消息与一个特定的路由键完全匹配。
     * 这是一个完整的匹配。如果一个队列绑定到该交换机上要求路由键 “dog”，则只有被标记为“dog”的消息才被转发，
     * 不会转发dog.puppy，也不会转发dog.guard，只会转发dog。
     * @return DirectExchange
     */
    @Bean
    public DirectExchange taskCheckDelayExchange() {
        return new DirectExchange(DELAY_TASKCHECK_EXCHANGE);
    }
    @Bean
    public Binding dlxBinding() {
        return BindingBuilder.bind(delayTaskCheckQueue()).to(taskCheckDelayExchange()).with(DELAY_ROUTING_KEY);
    }
    @Bean
    public Binding dmkBinding() {
        return BindingBuilder.bind(delayTaskMakeUpQueue()).to(taskCheckDelayExchange()).with(DELAY_MAKEUP_ROUTING_KEY);
    }


    @Bean
    public Queue taskCheckQueue() {
        return new Queue(TASKCHECK_QUEUE, true);
    }
    /**
     * 将路由键和某模式进行匹配。此时队列需要绑定要一个模式上。
     * 符号“#”匹配一个或多个词，符号“*”匹配不多不少一个词。因此“audit.#”能够匹配到“audit.irs.corporate”，但是“audit.*” 只会匹配到“audit.irs”。
     **/
    @Bean
    public TopicExchange taskCheckTopicExchange() {
        return new TopicExchange(TASKCHECK_EXCHANGE_NAME);
    }

    @Bean
    public Binding taskcheckBinding() {
        // TODO 如果要让延迟队列之间有关联,这里的 routingKey 和 绑定的交换机很关键
        return BindingBuilder.bind(taskCheckQueue()).to(taskCheckTopicExchange()).with(TASKCHECK_ROUTING_KEY);
    }


    @Bean
    public Queue timedTaskQueue() {
        return new Queue(TIMEDTASK_QUEUE, true);
    }

    @Bean
    public TopicExchange timedTaskTopicExchange() {
        return new TopicExchange(TIMEDTASK_EXCHANGE_NAME);
    }

    @Bean
    public Binding timedTaskBinding() {
        // TODO 如果要让延迟队列之间有关联,这里的 routingKey 和 绑定的交换机很关键
        return BindingBuilder.bind(timedTaskQueue()).to(timedTaskTopicExchange()).with(TIMEDTASK_ROUTING_KEY);
    }


    @Bean
    public RabbitTemplate rabbitTemplate(ConnectionFactory connectionFactory) {
        RabbitTemplate template = new RabbitTemplate(connectionFactory);
        template.setMessageConverter(new Jackson2JsonMessageConverter());
        return template;
    }

    @Bean
    public SimpleRabbitListenerContainerFactory rabbitListenerContainerFactory(ConnectionFactory connectionFactory) {
        SimpleRabbitListenerContainerFactory factory = new SimpleRabbitListenerContainerFactory();
        factory.setConnectionFactory(connectionFactory);
        factory.setMessageConverter(new Jackson2JsonMessageConverter());
        return factory;

    }
}

发送到延迟队列：

 rabbitTemplate.convertAndSend(RabbitConfig.DELAY_TASKCHECK_EXCHANGE,RabbitConfig.DELAY_MAKEUP_ROUTING_KEY,taskInfo, message -> {
                // 设置超时时间  毫秒
                message.getMessageProperties().setDeliveryMode(MessageDeliveryMode.PERSISTENT);
                message.getMessageProperties().setExpiration((10*60*1000)+"");
                return message;
            });

订阅消费队列进行消费任务：

 @RabbitListener(queues = "timedTask", containerFactory = "rabbitListenerContainerFactory")
    @RabbitHandler
    public void process(TaskInfo taskInfo){
}