RabbitMQ手动ACK与死信队列

最新推荐文章于 2024-04-24 22:54:19 发布
最新推荐文章于 2024-04-24 22:54:19 发布
阅读量5.3k 收藏 44
点赞数 13
分类专栏： RabbitMQ单排日记 文章标签： java-rabbitmq rabbitmq java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/QingXu1234/article/details/130904397
版权

为了保证消息从队列可靠的达到消费者，RabbitMQ 提供了消息确认机制（Message Acknowledgement）。

默认情况下RabbitMQ在消息发出后就立即将这条消息删除,而不管消费端是否接收到,是否处理完,导致消费端消息丢失时RabbitMQ自己又没有这条消息了。所以在实际项目中会使用手动Ack。

1、手动应答

  1. Channel.basicAck (用于肯定确认)：RabbitMQ 已知道该消息成功被处理，可以将其丢弃了。
  2. Channel.basicNack (用于否定确认)
  3. Channel.basicReject (用于否定确认)：与 Channel.basicNack 相比少一个参数，不处理该消息了直接拒绝，可以将其丢弃了。

消费者端的配置，相关属性值改为自己的：

server.port=8082
#rabbitmq服务器ip
spring.rabbitmq.host=localhost
#rabbitmq的端口
spring.rabbitmq.port=5672
#用户名
spring.rabbitmq.username=lonewalker
#密码
spring.rabbitmq.password=XX
#配置虚拟机
spring.rabbitmq.virtual-host=demo
#设置消费端手动 ack   none不确认  auto自动确认  manual手动确认
spring.rabbitmq.listener.simple.acknowledge-mode=manual

修改消费代码：请勿复制使用，会卡死

package com.example.consumer.service;

import com.alibaba.fastjson.JSONObject;
import com.example.consumer.entity.User;
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.Service;

import java.io.IOException;

/**
 * @description:
 * @author: LoneWalker
 * @create: 2022-04-04
 **/
@Service
@Slf4j
public class ConsumerService {


    @RabbitListener(queues ="publisher.addUser")
    public void addUser(String userStr,Channel channel,Message message){
        long deliveryTag = message.getMessageProperties().getDeliveryTag();
        try {
            log.info("我一直在重试");
            int a = 1/0;
            User user = JSONObject.parseObject(userStr,User.class);
            log.info(user.toString());
            //手动ack  第二个参数为false是表示仅仅确认当前消息 true表示确认之前所有的消息
            channel.basicAck(deliveryTag,false);
        } catch (Exception e) {
            //手动nack 告诉rabbitmq该消息消费失败  第三个参数：如果被拒绝的消息应该被重新请求，而不是被丢弃或变成死信，则为true
            try {
                channel.basicNack(deliveryTag,false,true);
            } catch (IOException ex) {
                ex.printStackTrace();
            }
        }
    }
}

先启动发布者发送消息，查看控制台：有一条消息待消费·

启动消费端，因为代码中有除0，所以会报错，这里就会出现一条unacked消息：

因为设置的是将消息重新请求，所以它会陷入死循环

防止出现这种情况，可以将basicNack最后一个参数改为false，让消息进去死信队列

2、什么是死信队列

说简单点就是备胎队列，而死信的来源有以下几种：

  1. 消息被否定确认，使用 channel.basicNack 或 channel.basicReject ，并且此时requeue 属性被设置为false。
  2. 消息在队列的存活时间超过设置的TTL时间。
  3. 消息队列的消息数量已经超过最大队列长度。

“死信”消息会被RabbitMQ进行特殊处理，如果配置了死信队列信息，那么该消息将会被丢进死信队列中，如果没有配置，则该消息将会被丢弃。

3、配置死信队列

一般会为每个重要的业务队列配置一个死信队列。可以分为以下步骤：

  1. 配置业务队列，绑定到业务交换机上
  2. 为业务队列配置死信交换机和路由key
  3. 为死信交换机配置死信队列

从控制台将之前的交换机都删除，然后修改代码。

首先看一下发布者的配置代码：

package com.example.publisher.config;

import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.*;
import org.springframework.amqp.rabbit.connection.CachingConnectionFactory;
import org.springframework.amqp.rabbit.connection.CorrelationData;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.amqp.support.converter.Jackson2JsonMessageConverter;
import org.springframework.amqp.support.converter.MessageConverter;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.HashMap;
import java.util.Map;

/**
 * @author LoneWalker
 * @date 2023/4/8
 * @description
 */
@Slf4j
@Configuration
public class RabbitMqConfig implements RabbitTemplate.ConfirmCallback, RabbitTemplate.ReturnsCallback {

    @Bean
    public RabbitTemplate rabbitTemplate(CachingConnectionFactory connectionFactory) {
        RabbitTemplate rabbitTemplate = new RabbitTemplate(connectionFactory);
        rabbitTemplate.setMessageConverter(jackson2JsonMessageConverter());
        //设置给rabbitTemplate
        rabbitTemplate.setConfirmCallback(this);
        rabbitTemplate.setReturnsCallback(this);
        rabbitTemplate.setMandatory(true);
        return rabbitTemplate;
    }

    @Bean
    public MessageConverter jackson2JsonMessageConverter() {
        return new Jackson2JsonMessageConverter();
    }
    /************ 正常配置 ******************/
    /**
     * 正常交换机，开启持久化
     */
    @Bean
    DirectExchange normalExchange() {
        return new DirectExchange("normalExchange", true, false);
    }

    @Bean
    public Queue normalQueue() {
        // durable: 是否持久化,默认是false,持久化队列：会被存储在磁盘上，当消息代理重启时仍然存在，暂存队列：当前连接有效
        // exclusive: 默认也是false，只能被当前创建的连接使用，而且当连接关闭后队列即被删除。
        // autoDelete: 是否自动删除，当没有生产者或者消费者使用此队列，该队列会自动删除。
        Map<String, Object> args = deadQueueArgs();
        // 队列设置最大长度
        args.put("x-max-length", 5);
        return new Queue("normalQueue", true, false, false, args);
    }

    @Bean
    public Queue ttlQueue() {
        Map<String, Object> args = deadQueueArgs();
        // 队列设置消息过期时间 60 秒
        args.put("x-message-ttl", 60 * 1000);
        return new Queue("ttlQueue", true, false, false, args);
    }

    @Bean
    Binding normalRouteBinding() {
        return BindingBuilder.bind(normalQueue())
                .to(normalExchange())
                .with("normalRouting");
    }

    @Bean
    Binding ttlRouteBinding() {
        return BindingBuilder.bind(ttlQueue())
                .to(normalExchange())
                .with("ttlRouting");
    }


    /**************** 死信配置 *****************/
    /**
     * 死信交换机
     */
    @Bean
    DirectExchange deadExchange() {
        return new DirectExchange("deadExchange", true, false);
    }

    /**
     * 死信队列
     */
    @Bean
    public Queue deadQueue() {
        return new Queue("deadQueue", true, false, false);
    }

    @Bean
    Binding deadRouteBinding() {
        return BindingBuilder.bind(deadQueue())
                .to(deadExchange())
                .with("deadRouting");
    }

    /**
     * 转发到 死信队列，配置参数
     */
    private Map<String, Object> deadQueueArgs() {
        Map<String, Object> map = new HashMap<>();
        // 绑定该队列到死信交换机
        map.put("x-dead-letter-exchange", "deadExchange");
        map.put("x-dead-letter-routing-key", "deadRouting");
        return map;
    }


    /**
     * 消息成功到达交换机会触发
     * @param correlationData
     * @param ack
     * @param cause
     */
    @Override
    public void confirm(CorrelationData correlationData, boolean ack, String cause) {
        if (ack) {
            log.info("交换机收到消息成功：" + correlationData.getId());
        }else {
            log.error("交换机收到消息失败：" + correlationData.getId() + "原因：" + cause);
        }
    }

    /**
     * 消息未成功到达队列会触发
     * @param returnedMessage
     */
    @Override
    public void returnedMessage(ReturnedMessage returnedMessage) {
        log.error("{}--消息未成功到达队列",returnedMessage.getMessage().getMessageProperties().getMessageId());
    }
}

properties

server.port=8081
#rabbitmq服务ip
spring.rabbitmq.host=localhost
#rabbitmq端口号
spring.rabbitmq.port=5672
#用户名
spring.rabbitmq.username=用户名改为自己的
#密码
spring.rabbitmq.password=密码改为自己的
#虚拟机
spring.rabbitmq.virtual-host=demo

spring.rabbitmq.publisher-confirm-type=correlated
spring.rabbitmq.publisher-returns=true
spring.rabbitmq.template.mandatory=true

发送消息：

@RequiredArgsConstructor
@Service
public class PublisherServiceImpl implements PublisherService{

    private final RabbitTemplate rabbitTemplate;

    @Override
    public void addUser(User user) {

        CorrelationData correlationData = new CorrelationData();
        correlationData.setId(UUID.randomUUID().toString());

        rabbitTemplate.convertAndSend("normalExchange","normalRouting",user,correlationData);
    }
}

4、模拟场景

4.1消息处理异常

文章开篇说到的消息手动ack，一旦出现异常会陷入死循环，那么不把消息放回原队列，而是放入死信队列，然后抛异常由人工处理：

package com.example.consumer.service;

import com.alibaba.fastjson.JSONObject;
import com.example.consumer.entity.User;
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.Service;

import java.io.IOException;

/**
 * @description:
 * @author: LoneWalker
 * @create: 2022-04-04
 **/
@Service
@Slf4j
public class ConsumerService {


    @RabbitListener(queues ="normalQueue")
    public void addUser(String userStr,Channel channel,Message message){
        long deliveryTag = message.getMessageProperties().getDeliveryTag();
        try {
            int a = 1/0;
            User user = JSONObject.parseObject(userStr,User.class);
            log.info(user.toString());
            //手动ack  第二个参数为false是表示仅仅确认当前消息 true表示确认之前所有的消息
            channel.basicAck(deliveryTag,false);
        } catch (Exception e) {
            //手动nack 告诉rabbitmq该消息消费失败  第三个参数：如果被拒绝的消息应该被重新请求，而不是被丢弃或变成死信，则为true
            try {
                channel.basicNack(deliveryTag,false,false);
            } catch (IOException ex) {
                throw new RuntimeException("消息处理失败");
            }
        }
    }
}

注意basicNack的第三个参数，设置为false后就不会重新请求。

4.2队列达到最大长度

配置上面的代码已经有过了：

测试的话我们发6条消息，加上4.1测试产生的死信，预期死信队列中应该会有两条：

4.3消息TTL过期

过期时间TTL表示可以对消息设置预期的时间，超过这个时间就删除或者放入死信队列。修改routingKey为ttlRouting。上述代码中配置过期时间为60s

死信队列中的消息处理和正常的队列没什么区别，就不赘述了。

LoneWalker、
关注
  • 13
    点赞
  • 踩
  • 44
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
专栏目录
RabbitMQ中方法channel.basicAck的使用说明
liqinglonguo的博客
10-25 1915
通过设置multiple参数，可以实现批量确认消息的功能。如果消费者处理消息的速度很快，可以将其设置为true,一次性确认多条消息，提高处理效率。但如果消费者处理消息的速度比较慢，可能会导致消息堆积，造成内存占用过高。因此，在实际使用中需要根据实际情况来确定是否需要批量确认消息。在RabbitMQ中，channel.basicAck方法用于确认已经接收并处理了消息。
springboot整合rabbitmq使用死信队列
11-06
springboot整合rabbitmq使用死信队列
RabbitMQ消息确认机制（ACK）
热门推荐
pan_junbiao的博客
01-25 3万+
1、消息确认机制（ACK） 为了保证消息从队列可靠的达到消费者，RabbitMQ 提供了消息确认机制（Message Acknowledgement）。消费者在订阅队列时，可以指定 autoAck 参数，当 autoAck 参数等于 false 时，RabbitMQ 会等待消费者显式地回复确认信号后才从内存（或者磁盘）中移除消息（实际上是先打上删除标记，之后在删除）。当 autoAck 参数等于 true 时，RabbitMQ 会自动把发送出去的消息置为确认，然后从内存（或者磁盘）中删除，而不管消费者是否
浅谈RabbitMQ消费端ACK和限流
BASK2311的博客
02-11 899
如上图所示：如果在A系统中需要维护相关的业务功能，可能需要将A系统的服务停止，那么这个时候消息的生产者还是一直会向MQ中发送待处理的消息，消费者此时服务已经关闭，导致大量的消息都会在MQ中累积。如果当A系统成功启动后，默认情况下消息的消费者会一次性将MQ中累积的大量的消息全部拉取到自己的服务，导致服务在短时间内会处理大量的业务，可能会导致系统服务的崩溃。其中自动确认是指，当消息一旦被Consumer接收到，则自动确认收到，并将相应 message 从 RabbitMQ 的消息缓存中移除。
springboot整合rabbitMQ系列4 消费者Consumer 手动进行ack确认---消费者做到可靠性方案
小哇
04-12 2904
ack指Acknowledge，确认。 表示消费端收到消息后的确认方式。 有三种确认方式： 自动确认：acknowledge="none" 手动确认：acknowledge="manual" 根据异常情况确认：acknowledge="auto"，（这种方式使用麻烦，不作讲解） 其中自动确认是指，当消息一旦被Consumer接收到，则自动确认收到，并将相应 message 从 RabbitMQ 的消息缓存中移除。但是在实际业务处理中，很可能消息接收到，业务处理出现异常，那么该消息就会丢失。如果设置了手动确
RabbitMQ（三）手动Ack确认
sun_tantan的博客
03-19 1万+
默认情况下 spring-boot-data-amqp 是自动ACK机制，就意味着 MQ 会在消息发送完毕后，自动帮我们去ACK，然后删除消息的信息。 这样依赖就存在这样一个问题： 如果消费者处理消息需要较长时间，最好的做法是消费端处理完之后手动去确认。 消费者： @Service("confirmListener") public class ConfirmListener implements...
RabbitMq 手动ACK
sayyes__的博客
02-15 2469
rabbitmq ack操作
手动的进行消息应答
xzy的博客
11-10 4220
文章目录消息应答概念消息应答的方法"如果手动进行消息应答RabbitMQ中的消息不会丢失"的测试思路生产者代码消费者代码测试启动生产者启动消费者生产者生产两个消息看看消费者的接收情况 消息应答 概念 现在有很多消费者线程同时访问RabbitMQ消息队列，如果其中的一个消费者取到RabbitMQ消息队列的一个消息之后，突然挂掉了，那么RabbitMQ消息队列中的这条消息是不是就丢失了呢？我们该怎么解决这个问题呢？ 我们引入了消息应答机制，当消费者从RabbitMQ消息队列中取出消息并且成功的处理了之后，消费者
RabbitMQ消息可靠性解决方案
rzpy_qifengxiaoyue的博客
10-28 954
1. 解决方案 客户端代码中的异常捕获，包括生产者和消费者 AMQP/RabbitMQ的事务机制 发送端确认机制 消息持久化机制 Broker端的高可用集群 消费者确认机制 消费端限流 消息幂等性 2. 异常捕获机制 先执行业务操作，业务操作成功后执行消息发送，消息发送过程通过try catch 方式捕获异常， 在异常处理理的代码块中执行行回滚业务操作或者执行行重发操作等。这是一种最大努力确保的方式， 并无法保证100%绝对可靠，因为这里没有异常并不代表消息就一定投递成功。 boolean result
RabbitMQ消息应答
深漂小码哥
04-09 4900
1.概念 消费者完成一个任务可能需要一段时间，如果其中一个消费者处理一个长的任务并仅只完成了部分突然它挂掉了，会发生什么情况，RabbitMQ一旦向消费者传递了一条消息，便立即将该消息标记为删除。在这种情况下，突然有个消费者挂掉了，我们将丢失正在处理的消息以及后续发送给该消费者的消息，因为它无法接收到，为了保证消息在发送过程中不丢失，rabbitmq引入消息应答机制，消息应答就是，消费者在接收到消息并且处理该消息之后，告诉rabbimq它已经处理了，rabbitmq可以把该消息删除了 2.自动应答 消
rabbitmq自动及手动ACK
诚的博客
04-01 3848
mq的ack主要是确认消息被消费者消费完成后通知服务器将队列里面的消息清除。 而如果不配置Ack的话呢，我测试过他会自动的忽略，也就是说此时的服务是no_ack=true的模式，就是说只要我发现你是消费了这个数据，至于异常不异常的，我不管了。通知Ack机制就是这么来的，更加灵活的，我们需要Ack不自动，而是手动，这样做的好处，就是使得我们开发人员更加人性化或者灵活的来处理我们的业务罗杰代码，更加方便的处理异常的问题以及数据的返回处理等。下面是通话机制的四条原则： Basic.Ack 发回给 Ra...
Rabbitmq的一些笔记
m0_65300193的博客
03-02 2882
一些概念： 消息队列三大功能： 流量消峰：超过极限之后，后续的访问人员需要等待；可以避免宕机，但是需要更多的时间； 应用解耦：可以使系统之间解耦，一个系统调用别的系统的时候不会因为被调用的系统故障而一起发生故障；这样在调用的时候，会通过队列去访问别的系统，那么需要调用的系统只需要将这样的一个请求交给了队列则就完成了他的操作，后续的出错不会影响它。 异步处理：可以使得模块之间调用的时候，调用的模块不再需要等待被调用的模块执行结束，而是被调用的模块执行结束以后由队列去通知调用的模块； MQ的四大核心概念.
springboot整合RabbitMQ实现死信/死信队列及实现源码及教程
06-28
springboot整合RabbitMQ实现死信/死信队列及实现源码及教程，参考博客：https://blog.csdn.net/qq_29914837/article/details/93334313
RabbitMQ消息确认（ACK）机制实战
03-02
对RabbitMQ消息确认（ACK）原理的理解及实践
SpringBoot集成RabbitMQ的方法(死信队列)
08-26
主要介绍了SpringBoot集成RabbitMQ的方法(死信队列)，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
Spring RabbitMQ死信机制原理实例详解
08-24
主要介绍了Spring RabbitMQ死信机制原理实例详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
RabbitMQ死信队列应用1
08-03
1、什么是死信队列 2、死信队列应用场景 3、延迟消息概念 4、死信队列使用流程图 5、死信队列应用（管理控制台） 6、死信队列应用（Java代码）
RabbitMQ spring boot TTL延时消费
最新发布
熊孩子的博客
04-24 583
RabbitMQ spring boot TTL延时消费
Java技术学习|消息队列|初级RabbitMQ
anncyuyan的博客
04-24 824
是非常初级的学习，听说后续的高级课程会涉及到微服务之类的，所以等学完微服务再回来学。还有redis的高级部分也涉及了微服务，所以也都暂时停止学习了。
rabbitmq手动ack
09-06
在RabbitMQ中，手动ACK（acknowledge）是一种确认消息已被消费者正确处理的方式。通过手动ACK，消费者可以控制消息的确认时机，以确保消息被处理完成后再进行确认，以避免消息丢失或重复消费的问题。 根据引用和引用的配置信息，可以看出设置手动ACK的方式是在消费者的配置中添加如下参数： spring.rabbitmq.listener.simple.acknowledge-mode=manual 这样配置后，消费者在消费消息后需要手动调用ACK方法来确认消息的处理结果。这样可以确保消息只有在消费者确认处理完成后才会从队列中删除，避免了消息的丢失。 需要注意的是，在手动ACK模式下，如果消费者没有确认消息，消息将一直被标记为未处理状态，可能会导致消息堆积或重复消费的问题。因此，消费者需要谨慎处理消息并及时确认，以确保消息的可靠处理。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* *2* [RabbitMQ手动ACK与死信队列](https://blog.csdn.net/QingXu1234/article/details/130904397)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_1"}}] [.reference_item style="max-width: 50%"] - *3* [15.RabbitMQ 消费端手动ACK消息确认机制](https://blog.csdn.net/Stubborn_bull/article/details/118963624)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_1"}}] [.reference_item style="max-width: 50%"] [ .reference_list ]

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

LoneWalker、

你的鼓励是我最大的动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值