rabbitmq：retry重试机制和延迟消息的实现

最新推荐文章于 2025-02-14 13:56:39 发布

small+

最新推荐文章于 2025-02-14 13:56:39 发布

阅读量3.5k

点赞数 3

文章标签： java-rabbitmq rabbitmq 分布式

本文链接：https://blog.csdn.net/qq_41992429/article/details/128707411

版权

文章介绍了如何在RabbitMQ中配置和使用retry机制来处理消费者消息消费失败的情况，包括手动ack机制、重试配置以及在重试失败后的MessageRecoverer策略。此外，还详细讲解了如何设置延迟消息，通过创建死信队列和设置消息TTL来实现消息超时后转为死信的处理流程。这些机制对于确保业务的稳定性和消息的正确处理至关重要。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

rabbitmq：retry重试机制和延迟消息的实现

在消费者消费消息的时候可能会因为网络等外部原因导致消息处理失败，这个时候如果将消息直接丢弃会导致正常的业务丢失，但是如果是一条本身就有问题的消息，那么这个时候又必须丢弃掉，如果选择用channel.basicNack或channel.basicReject方法让消息重回对了，会导致消费者在不停的消费这条消息，这将是一个致命的问题。

所幸，rabbitmq提供了retry机制来控制消息的重试

在这里插入图片描述

yml配置文件：

spring:  
  rabbitmq:
    host: IP
    port: 5672
    username: guest
    password: guest
    virtual-host: smallJHost
    # 消费者确认机制相关配置
    # 开启publisher-confirm，
    # 这里支持两种类型：simple：同步等待confirm结果，直到超时；# correlated：异步回调，定义ConfirmCallback，MQ返回结果时会回调这个ConfirmCallback
    publisher-confirm-type: correlated
    # publish-returns：开启publish-return功能，同样是基于callback机制，不过是定义ReturnCallback
    publisher-returns: true
    # 定义消息路由失败时的策略。true，则调用ReturnCallback；false：则直接丢弃消息
    template:
      mandatory: true
    listener:
      simple:
        # ack机制类型
        acknowledge-mode: manual
        # 设置预取消息数量
        prefetch: 2
        # 失败重试
        retry:
          # 开启消费者失败重试
          enabled: true
          # 初始的失败等待时长为1秒
          initial-interval: 1000
          # 失败的等待时长倍数，下次等待时长 = multiplier * last-interval
          multiplier: 3
          # 最大重试次数
          max-attempts: 4
          # true无状态；false有状态。如果业务中包含事务，这里改为false
          stateless: true

在RabbitmqConfig中增加如下配置：

package com.gitee.small.config;

import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.Queue;
import org.springframework.amqp.core.TopicExchange;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.amqp.rabbit.retry.MessageRecoverer;
import org.springframework.amqp.rabbit.retry.RepublishMessageRecoverer;
import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
@Slf4j
public class RabbitMQConfig implements ApplicationContextAware {

    // 其他队列、交换机、绑定、回调等代码省略，需要的朋友可看我之前的文章、、、
    
    @Bean
    public Queue errorQueue() {
        return new Queue("error");
    }

    @Bean
    public TopicExchange exchange() {
        return new TopicExchange("topicExchange");
    }


    @Bean(name = "binding.error")
    public Binding bindingExchangeMessage3() {
        return BindingBuilder.bind(errorQueue()).to(exchange()).with("error");
    }

    /**
     * 定义 MessageRecoverer 将错误消息发送到指定队列
     */
    @Bean
    public MessageRecoverer republishMessageRecoverer(RabbitTemplate rabbitTemplate){
        return new RepublishMessageRecoverer(rabbitTemplate, "topicExchange", "error");
    }
}

在消费者定义中有一点需要注意，不能直接将异常处理掉，否则是不会将消息发送到error队列的。

package com.gitee.small.rabbitmq;

import com.rabbitmq.client.Channel;
import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.ExchangeTypes;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.Exchange;
import org.springframework.amqp.rabbit.annotation.Queue;
import org.springframework.amqp.rabbit.annotation.QueueBinding;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

import java.util.concurrent.TimeUnit;

@Component
@Slf4j
public class WorkRabbitReceiver {

    private static Integer index = 0;

    @RabbitListener(bindings = @QueueBinding(
            value = @Queue(name = "监听队列名称"),
            exchange = @Exchange(value = "binding对象beanname", type = ExchangeTypes.TOPIC))
    )
    public void process(String msg, Channel channel, Message message) throws Exception {
        try {
            System.out.println(1/0);
        } catch (Exception e) {
            log.error("消息重试");
            throw new Exception();
        }
    }
}

小结：

消息重试是在本地进行重试，不会回到消息队列中
重试模式下，重试次数耗尽后，如果消息依然失败，为了防止消息被直接丢弃，需要有MessageRecovery 接口来处理，它包含三种不同的实现
- RejectAndDontRequeueRecoverer：重试耗尽后，直接 reject，丢弃消息。默认就是这种方式
- ImmediateRequeueMessageRecoverer：重试耗尽后，返回nack，消息重新入队
- RepublishMessageRecoverer：重试耗尽后，将失败消息投递到指定的交换机
  
  很显然，RepublishMessageRecoverer方案应用最广最合理，本文中也是以此为例

实现延迟队列

消息超时方案：

给队列设置 ttl 属性，进入队列后超过 ttl 时间的消息变为死信
给消息设置 ttl 属性，队列接收到消息超过 ttl 时间后变为死信

本文讲给消息设置超时，因为这个方案更灵活。

创建死信队列和死信交换机，并将其绑定

@Bean
public DirectExchange dlExchange() {
    // 声明死信交换机 dl.direct
    return new DirectExchange("dl.direct", true, false);
}


@Bean
public Queue dlQueue() {
    // 声明存储死信的队列 dl.queue
    return new Queue("dl.queue", true);
}


@Bean(name = "binding.dl")
public Binding dlBinding() {
    // 将死信队列 与 死信交换机绑定
    return BindingBuilder.bind(dlQueue()).to(dlExchange()).with("dl");
}

指定消息过期时间，向正常消息队列发送消息，一条5秒延时，一条10秒延时

private void deadLetter() {
    final Message message = MessageBuilder.withBody("延迟消息测试".getBytes(StandardCharsets.UTF_8))
        .setDeliveryMode(MessageDeliveryMode.PERSISTENT)
        .setExpiration("5000")
        .build();

    final Message message2 = MessageBuilder.withBody("延迟消息测试".getBytes())
        .setDeliveryMode(MessageDeliveryMode.PERSISTENT)
        .setExpiration("10000")
        .build();

    rabbitTemplate.convertAndSend("topicExchange", "topic.dead", message);
    rabbitTemplate.convertAndSend("topicExchange", "topic.dead", message2);
}

监听死信队列，实现延迟消息具体逻辑

/**
* 监听死信队列，处理延迟消息
*/
@RabbitListener(bindings = @QueueBinding(
    value = @Queue(name = "dl.queue"),
    exchange = @Exchange(value = "binding.dl", type = ExchangeTypes.TOPIC))
               )
public void process(String msg, Channel channel, Message message) throws IOException {

    log.info("延迟消息：{}", msg);
    channel.basicAck(message.getMessageProperties().getDeliveryTag(),false);

}