RabibitMQ 学习笔记(六) Springboot整合 消费者 并确认消息回调

一、添加依赖

在pom.xml中添加

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

 

二、配置

1.配置文件

application-dev.properties中添加

复制代码
# ===============      RabbitMQ       =============================
#配置rabbitMq 服务器
spring.rabbitmq.host=服务器ip
spring.rabbitmq.port=5672
spring.rabbitmq.username=root
spring.rabbitmq.password=root
#虚拟host 可以不设置,使用server默认host
# 确认消息已发送到交换机(Exchange)
spring.rabbitmq.publisher-confirms=true
# 确认消息已发送到交换机(Exchange)
spring.rabbitmq.publisher-confirm-type=correlated
# 确认消息已发送到队列(Queue)
spring.rabbitmq.publisher-returns=true
#spring.rabbitmq.virtual-host=suphoweHost
复制代码

rabbitmq.properties

复制代码
################## RabbitMQ ##################
################## 直连交换机 ##################
# 队列名称
direct.queue=directQueue
# 交换机名称
direct.exchange=directExchange
# 交换机名称
direct.lonelyexchange=lonelyDirectExchange
# 路由名称
direct.routing=directRouting
################## 扇形交换机 ##################
# 队列名称1
fanout.queue.main=fanoutQueue.main
# 队列名称2
fanout.queue.secondary=fanoutQueue.secondary
# 队列名称3
fanout.queue.third=fanoutQueue.third
# 交换机名称1
fanout.exchange=fanoutExchange
# 路由名称1
fanout.routing=fanoutRouting
################## 主题交换机 ##################
# 队列名称
topic.queue.main=topic.main
# 队列名称
topic.queue.secondary=topic.secondary
# 交换机名称
topic.exchange=topicExchange
# 路由名称
topic.routing=topicRouting
复制代码

 

2.配置类

复制代码
/**
 * Redis配置类
 * @author suphowe
 */
@Component
@Data
@PropertySource(value= {"classpath:properties/rabbitmq.properties"})
public class RabbitmqProperties {

    @Value("${direct.queue}")
    private String directQueue;

    @Value("${direct.exchange}")
    private String directExchange;

    @Value("${direct.lonelyexchange}")
    private String lonelyDirectExchange;

    @Value("${direct.routing}")
    private String directRouting;

    @Value("${fanout.queue.main}")
    private String fanoutQueueMain;

    @Value("${fanout.queue.secondary}")
    private String fanoutQueueSecondary;

    @Value("${fanout.queue.third}")
    private String fanoutQueueThird;

    @Value("${fanout.exchange}")
    private String fanoutExchange;

    @Value("${fanout.routing}")
    private String fanoutRouting;

    @Value("${topic.queue.main}")
    private String mainTopicQueue;

    @Value("${topic.queue.secondary}")
    private String secondaryTopicQueue;

    @Value("${topic.exchange}")
    private String topicExchange;

    @Value("${topic.routing}")
    private String topicRouting;

    @Value("${receiver.concurrentconsumers}")
    private int concurrentConsumers;

    @Value("${receiver.maxconcurrentconsumers}")
    private int maxConcurrentConsumers;
}
复制代码

 

复制代码
/**
 * rabbitmq配置,消费者消息确认
 * @author suphowe
 */
@Configuration
public class RabbitmqReceiverConfig {

    @Autowired
    private CachingConnectionFactory connectionFactory;

    @Autowired
    private ReceiverAck receiverAck;

    @Autowired
    private RabbitmqProperties rabbitmqProperties;

    @Bean
    public SimpleMessageListenerContainer simpleMessageListenerContainer() {
        //定义消息监听所在的容器工厂,设置容器工厂所用的实例
        SimpleMessageListenerContainer simpleMessageListenerContainer = new SimpleMessageListenerContainer(connectionFactory);
        // 并发消费者的初始化数量
        simpleMessageListenerContainer.setConcurrentConsumers(rabbitmqProperties.getConcurrentConsumers());
        // 设置消费者最大并发数量
        simpleMessageListenerContainer.setMaxConcurrentConsumers(rabbitmqProperties.getMaxConcurrentConsumers());
        // 设置消息在传输中的格式，这里采用JSON 的格式进行传输
        // simpleMessageListenerContainer.setMessageConverter(new Jackson2JsonMessageConverter());
        // RabbitMQ默认是自动确认，这里改为手动确认消息
        simpleMessageListenerContainer.setAcknowledgeMode(AcknowledgeMode.MANUAL);

        //设置一个队列
        //simpleMessageListenerContainer.setQueueNames("directQueue");
        //如果同时设置多个如下： 前提是队列都是必须已经创建存在的
        simpleMessageListenerContainer.setQueueNames(rabbitmqProperties.getDirectQueue(), rabbitmqProperties.getMainTopicQueue(),
                rabbitmqProperties.getSecondaryTopicQueue(), rabbitmqProperties.getFanoutQueueMain(),
                rabbitmqProperties.getFanoutQueueSecondary(), rabbitmqProperties.getFanoutQueueThird());


        //另一种设置队列的方法,如果使用这种情况,那么要设置多个,就使用addQueues
        //simpleMessageListenerContainer.setQueues(new Queue("directQueue",true));
        //simpleMessageListenerContainer.addQueues(new Queue(rabbitmqProperties.getMainTopicQueue(),true));
        //simpleMessageListenerContainer.addQueues(new Queue(rabbitmqProperties.getSecondaryTopicQueue(),true));
        //simpleMessageListenerContainer.addQueues(new Queue(rabbitmqProperties.getFanoutQueueMain(),true));
        //simpleMessageListenerContainer.addQueues(new Queue(rabbitmqProperties.getFanoutQueueSecondary(),true));
        //simpleMessageListenerContainer.addQueues(new Queue(rabbitmqProperties.getFanoutQueueThird(),true));

        simpleMessageListenerContainer.setMessageListener(receiverAck);

        return simpleMessageListenerContainer;
    }
}
复制代码

 

复制代码
/**
 * 消费者手动确认消息接收
 * @author suphowe
 */
@Component
public class ReceiverAck implements ChannelAwareMessageListener {

    private static final Logger logger = LoggerFactory.getLogger(ReceiverAck.class);

    @Override
    public void onMessage(Message message, Channel channel) throws Exception {
        long deliveryTag = message.getMessageProperties().getDeliveryTag();
        try {
            //因为传递消息的时候用的map传递,所以将Map从Message内取出需要做些处理
            String msg = message.toString();
            //可以点进Message里面看源码,单引号直接的数据就是我们的map消息数据
            String[] msgArray = msg.split("'");

            LinkedHashMap<String, String> msgMap = conversionMapString(msgArray[1].trim(), 3);
            String messageId = msgMap.get("messageId");
            String messageData = msgMap.get("messageData");
            String createTime = msgMap.get("createTime");

            logger.info("RabbitMQ<--- ReceiverAck onMessage 接受消息 消费的消息来自的队列名：{}", message.getMessageProperties().getConsumerQueue());
            logger.info("RabbitMQ<--- ReceiverAck onMessage 接受消息 messageId：{}", messageId);
            logger.info("RabbitMQ<--- ReceiverAck onMessage 接受消息 messageData：{}", messageData);
            logger.info("RabbitMQ<--- ReceiverAck onMessage 接受消息 createTime：{}", createTime);

            //第二个参数，手动确认可以被批处理，当该参数为 true 时，则可以一次性确认 delivery_tag 小于等于传入值的所有消息
            channel.basicAck(deliveryTag, true);
        } catch (Exception e) {
            //第二个参数，true会重新放回队列，所以需要自己根据业务逻辑判断什么时候使用拒绝
            channel.basicReject(deliveryTag, true);
            logger.error("RabbitMQ 消费发生异常:", e);
        }
    }

    /**
     * 将map string转换为map {key=value,key=value,key=value} 格式转换成map
     * @param mapString map string
     * @param maxArrayLength 数组的最大长度
     * @return map
     */
    private LinkedHashMap<String, String> conversionMapString(String mapString, int maxArrayLength) {
        mapString = mapString.substring(1, mapString.length() - 1);
        String[] strs = mapString.split(",", maxArrayLength);
        LinkedHashMap<String, String> map = new LinkedHashMap<>(4);
        for (String string : strs) {
            String key = string.split("=")[0].trim();
            String value = string.split("=")[1];
            map.put(key, value);
        }
        return map;
    }
}
复制代码

 

三、消费者

1.直连消费者

复制代码
/**
 * 直连消费者
 *
 * @author suphowe
 */
@Component
@RabbitListener(queues = "directQueue")//监听的队列名称 DirectQueue
public class RabbitmqDirectReceiver {

    private static final Logger logger = LoggerFactory.getLogger(RabbitmqDirectReceiver.class);

    @RabbitHandler
    public void process(Map message) {
        logger.info("RabbitMQ<--- RabbitmqDirectReceiver 消费者收到消息:{}", message.toString());
    }
}
复制代码

2.扇形消费者

复制代码
/**
 * 扇形消费者
 * @author suphowe
 */
@Component
@RabbitListener(queues = "fanoutQueue.main")//监听的队列名称 fanoutQueue.main
public class RabbitmqFanoutReceiverMain {

    private static final Logger logger = LoggerFactory.getLogger(RabbitmqFanoutReceiverMain.class);

    @RabbitHandler
    public void process(Map message) {
        logger.info("RabbitMQ<--- RabbitmqFanoutReceiverMain 消费者收到消息:{}", message.toString());
    }
}
复制代码

3.主题消费者

复制代码
/**
 * 主题消费者
 * @author suphowe
 */
@Component
@RabbitListener(queues = "topic.main")//监听的队列名称 topic.main
public class RabbitmqTopicMainReceiver {

    private static final Logger logger = LoggerFactory.getLogger(RabbitmqTopicMainReceiver.class);

    @RabbitHandler
    public void process(Map message) {
        logger.info("RabbitMQ<--- RabbitmqTopicMainReceiver 消费者收到消息:{}", message.toString());
    }
}
复制代码

 

四、消息回调机制

1.生产者消息回调

1.1.ConfirmCallback

  • 消息推送到server，但是在server里找不到交换机：ConfirmCallback 确认情况 false
  • 消息推送到server，找到交换机了，但是没找到队列:消息是推送成功到服务器了的，所以ConfirmCallback对消息确认情况是true，RetrunCallback回调函数的打印参数里面可以看到，消息是推送到了交换机成功了，但是在路由分发给队列的时候，找不到队列，所以报了错误 NO_ROUTE
  • 消息推送到sever，交换机和队列啥都没找到
  • 消息推送成功，ConfirmCallback 确认情况 true


1.2.RetrunCallback

消息推送到server，找到交换机了，但是没找到队列

 

2.消费者接收到消息的消息确认机制

2.1自动确认

　　这也是默认的消息确认情况，AcknowledgeMode.NONE,RabbitMQ成功将消息发出（即将消息成功写入TCP Socket）中立即认为本次投递已经被正确处理，不管消费者端是否成功处理本次投递。所以这种情况如果消费端消费逻辑抛出异常，也就是消费端没有处理成功这条消息，那么就相当于丢失了消息。一般这种情况我们都是使用try catch捕捉异常后，打印日志用于追踪数据，这样找出对应数据再做后续处理

2.2根据情况确认

2.3手动确认

　　这个比较关键，也是我们配置接收消息确认机制时，多数选择的模式。

　　消费者收到消息后，手动调用basic.ack/basic.nack/basic.reject后，RabbitMQ收到这些消息后，才认为本次投递成功。

  • basic.ack用于肯定确认
  • basic.nack用于否定确认（注意：这是AMQP 0-9-1的RabbitMQ扩展）
  • basic.reject用于否定确认，但与basic.nack相比有一个限制:一次只能拒绝单条消息


　　消费者端以上的3个方法都表示消息已经被正确投递，但是basic.ack表示消息已经被正确处理。
　　而basic.nack,basic.reject表示没有被正确处理：


　　2.3.1 reject

　　着重讲下reject，因为有时候一些场景是需要重新入列的。

　　channel.basicReject(deliveryTag, true); 拒绝消费当前消息，如果第二参数传入true，就是将数据重新丢回队列里，那么下次还会消费这消息。设置false，就是告诉服务器，我已经知道这条消息数据了，因为一些原因拒绝它，而且服务器也把这个消息丢掉就行。 下次不想再消费这条消息了。使用拒绝后重新入列这个确认模式要谨慎，因为一般都是出现异常的时候，catch异常再拒绝入列，选择是否重入列。但是如果使用不当会导致一些每次都被你重入列的消息一直消费-入列-消费-入列这样循环，会导致消息积压。

 

　　2.3.2 nack

　　顺便也简单讲讲 nack，这个也是相当于设置不消费某条消息。

　　channel.basicNack(deliveryTag, false, true);

  • 第一个参数依然是当前消息到的数据的唯一id;
  • 第二个参数是指是否针对多条消息；如果是true，也就是说一次性针对当前通道的消息的tagID小于当前这条消息的，都拒绝确认。
  • 第三个参数是指是否重新入列，也就是指不确认的消息是否重新丢回到队列里面去。

　　同样使用不确认后重新入列这个确认模式要谨慎，因为这里也可能因为考虑不周出现消息一直被重新丢回去的情况，导致积压

posted @   suphowe  阅读(449)  评论(0)  编辑  收藏  举报
编辑推荐：
· 基于Microsoft.Extensions.AI核心库实现RAG应用
· Linux系列：如何用heaptrack跟踪.NET程序的非托管内存泄露
· 开发者必知的日志记录最佳实践
· SQL Server 2025 AI相关能力初探
· Linux系列：如何用 C#调用 C方法造成内存泄露
阅读排行：
· 震惊！C++程序真的从main开始吗？99%的程序员都答错了
· 别再用vector＜bool＞了！Google高级工程师：这可能是STL最大的设计失误
· 【硬核科普】Trae如何「偷看」你的代码？零基础破解AI编程运行原理
· 单元测试从入门到精通
· 上周热点回顾（3.3-3.9）
点击右上角即可分享
微信分享提示
AI IDE Trae

目录导航