RabbitMQ高级特性

已于 2023-09-13 19:45:25 修改
阅读量197 收藏 1
点赞数
分类专栏： RabbitMQ 文章标签： java-rabbitmq rabbitmq java
于 2023-03-15 14:07:48 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_64686550/article/details/129553442
版权

目录

消息的可靠传递

Consumer Ack

消费端限流

TTL

死信队列

延迟队列

应用问题

消息补偿

幂等性保障

消息的可靠传递

在使用RabbitMQ的时候，作为消息发送方希望杜绝任何消息丢失或者投递失败场景，RabbitMQ为我们提供了两种方式用来控制消息的投递可靠性模式

  1. confirm确认模式
  2. return退回模式

rabbitmq整个消息投递的路径为：

producer-->rabbitmq broker-->exchange-->queue-->consumer

1.消息从producer到exchange则会返回一个confirmCallback

代码参考

/**
     * 确认模式：
     * 步骤：spring
     * 1. 确认模式开启：ConnectionFactory中开启publisher-confirms="true"
     * 2. 在rabbitTemplate定义ConfirmCallBack回调函数
	 * springboot:
     * 1.在yml中配置 #开启确认模式 publisher-confirm-type: correlated	
     */
    @Test
    public void testConfirm() {

        //2. 定义回调
        rabbitTemplate.setConfirmCallback(new RabbitTemplate.ConfirmCallback() {
            /**
             *
             * @param correlationData 相关配置信息
             * @param ack   exchange交换机 是否成功收到了消息。true 成功，false代表失败
             * @param cause 失败原因
             */
            @Override
            public void confirm(CorrelationData correlationData, boolean ack, String cause) {
                System.out.println("confirm方法被执行了....");

                if (ack) {
                    //接收成功
                    System.out.println("接收成功消息" + cause);
                } else {
                    //接收失败
                    System.out.println("接收失败消息" + cause);
                    //做一些处理，让消息再次发送。
                }
            }
        });

        //3. 发送消息
        rabbitTemplate.convertAndSend(EXCHANGE_NAME, "confirm", "message confirm....");
    }

2.消息从exchange-->queue投递失败则会返回一个returnCallback、

 /**
     * 回退模式： 当消息发送给Exchange后，Exchange路由到Queue失败是 才会执行 ReturnCallBack
     * 步骤：spring
     * 1. 开启回退模式:publisher-returns="true"
     * 2. 设置ReturnCallBack
     * 3. 设置Exchange处理消息的模式：
     * 1. 如果消息没有路由到Queue，则丢弃消息（默认）
     * 2. 如果消息没有路由到Queue，返回给消息发送方ReturnCallBack
     * springboot：yml中开启确认模式：  publisher-returns: true	
     */

    @Test
    public void testReturn() {

        //设置交换机处理失败消息的模式
        rabbitTemplate.setMandatory(true);

        //2.设置ReturnCallBack
        rabbitTemplate.setReturnCallback(new RabbitTemplate.ReturnCallback() {
            /**
             *
             * @param message   消息对象
             * @param replyCode 错误码
             * @param replyText 错误信息
             * @param exchange  交换机
             * @param routingKey 路由键
             */
            @Override
            public void returnedMessage(Message message, int replyCode, String replyText, String exchange, String routingKey) {
                System.out.println("return 执行了....");

                System.out.println(message);
                System.out.println(replyCode);
                System.out.println(replyText);
                System.out.println(exchange);
                System.out.println(routingKey);

                //处理
            }
        });


        //3. 发送消息
        rabbitTemplate.convertAndSend(EXCHANGE_NAME, "confirm", "message confirm....");
    }

yml整体配置

spring:
  rabbitmq:
    host: 192.168.5.129 #ip
    port: 5672
    username: guest
    password: guest
    virtual-host: /
    #开启确认模式
    publisher-confirm-type: correlated
    publisher-returns: true

Consumer Ack

ack指Acknowledge，确认：表示消费端收到消息后的确认方式

三种确认方式

  1. 自动确认：acknowledge="none":当消息一旦被Consumer接收到，则自动确认收到，并将相应message从RabbitMQ的消息缓存中移除，但是如果业务处理出现异常，那么该消息就会丢失
  2. 手动确认：acknowledge="manual"：在业务处理成功后，调用channel.basicAck(),收到签收，如果出现异常，则调用channel.basicNack()方法，让其自动重新发送消息
  3. 根据异常情况确认：acknowledge="auto"

Consumer方代码实现

@Component
    public class ACKListener implements ChannelAwareMessageListener {
        @RabbitListener(queues = "boot_queue")
        @Override
        public void onMessage(Message message, Channel channel) throws Exception {
            Thread.sleep(1000);
            long deliveryTag = message.getMessageProperties().getDeliveryTag();
            try {
                //1.接收转换消息
                System.out.println(new String(message.getBody()));
                //2.处理业务逻辑
                System.out.println("处理业务逻辑");
                //            int i=3/0;异常部分
                //3.手动签收
                channel.basicAck(deliveryTag,true);
            } catch (Exception e) {
                //            e.printStackTrace();
                System.out.println("业务处理失败！");
                //4.拒绝签收
                /*
* b1:requeue:重回队列，如何设置为true,则消息重新回到队列，broker重新发送该消息到客户端
* */
                channel.basicNack(deliveryTag,true,true);
            }
        }
    }

yml配置

spring:
  rabbitmq:
    host: 192.168.5.129 #ip
    port: 5672
    username: guest
    password: guest
    virtual-host: /
    listener:
      simple:
          #设置手动签收
          acknowledge-mode: manual

总结

  1. 在yml中设置acknowledge属性，设置ack方式none：自动确认，manual：手动确认
  2. 如果在消费端没有出现异常，则调用channel.basicAck()方法确认签收消息
  3. 如果出现异常，则在catch中调用basic或basic Reject，拒绝消息，让mq重新发送消息

消费端限流

主要问题：在面对mq高请求的情况下，系统可能会宕机的风险

yml配置：

spring:
  rabbitmq:
    host: 192.168.5.129 #ip
    port: 5672
    username: guest
    password: guest
    virtual-host: /
    listener:
      simple:
          acknowledge-mode: manual #设置手动签收，当手动签收之后，拉取新消息
          prefetch: 1  #最大从队列中拉取得消息个数

代码设置手动签收即可：

@Component
public class QosListener implements ChannelAwareMessageListener {
    @RabbitListener(queues = "boot_queue")
    @Override
    public void onMessage(Message message, Channel channel) throws Exception {
        //1.获取消息
        System.out.println(new String(message.getBody()));
        //2.处理业务逻辑

        //3.签收
        channel.basicAck(message.getMessageProperties().getDeliveryTag(),true);

    }
}

总结：

  1. 在yml中配置prefetch属性设置消费端一次拉去多少消息
  2. 消费端的确认模式一定为手动确认，acknowledge:manual

TTL

ttl全程Time To Live（存活时间/过期时间）,当消息到达存活时间后，还没有被消费，会被自动清除

RabbitMQ可以对消息设置过期时间，也可以对整个队列设置过期时间

队列整体过期

 //2.Queue队列
    @Bean("ttlQueue")
    public Queue ttlQueue(){
        return QueueBuilder.durable(TTL_QUEUE_NAME).withArgument("x-message-ttl",10000).build();
    }

消息单独过期

 /**
     * TTL:过期时间
     * 消息单独过期
     *
     *
     * 如果设置了消息的过期时间，也设置了队列的过期时间，它以时间短的为准。
     * 队列过期后，会将队列所有消息全部移除。
     * 消息过期后，只有消息在队列顶端，才会判断其是否过期(移除掉)
     *
     */
    @Test
    public void testTtl() {

      // 消息后处理对象，设置一些消息的参数信息
        MessagePostProcessor messagePostProcessor = new MessagePostProcessor() {

            @Override
            public Message postProcessMessage(Message message) throws AmqpException {
                //1.设置message的信息
                message.getMessageProperties().setExpiration("5000");//消息的过期时间
                //2.返回该消息
                return message;
            }
        };


        //消息单独过期
        //rabbitTemplate.convertAndSend("test_exchange_ttl", "ttl.hehe", "message ttl....",messagePostProcessor);


        for (int i = 0; i < 10; i++) {
            if(i == 5){
                //消息单独过期
                rabbitTemplate.convertAndSend("test_exchange_ttl", "ttl.hehe", "message ttl....",messagePostProcessor);
            }else{
                //不过期的消息
                rabbitTemplate.convertAndSend("test_exchange_ttl", "ttl.hehe", "message ttl....");

            }

        }


    }

总结：

  1. 设置消息队列过期使用参数：x-message-ttl，单位ms，会对整个消息队列统一过期
  2. 设置消息过期时间使用参数，expiration.单位ms，当该消息在队列头部时（消费者消费的时候），会单独判断这一消息是否过期
  3. 如果两者都进行了设置，以时间短的为准

死信队列

当消息成为Dead message后，可以被重新发送到另一个交换机，这个交换机就是死信队列DLX

消息成为私信的三种情况：

  1. 队列长度到达限制
  2. 消费者拒接消费消息，basicNack/basicReject，并且不把消息重新放入原目标队列，requeue=false
  3. 原队列存在消息过期设置，消息到达超时时间未被消费

队列绑定死信交换机

给队列设置参数： x-dead-letter-exchange 和 x-dead-letter-routing-key

代码实现：

producer：

config文件：

 /*死信队列*/
    /*
    * 1.1声明正常的队列test_queue和交换机test_exchange_dlx
    * */
    //1.交换机
    @Bean("test_exchange_dlx")
    public Exchange testExchangeDLX(){
        //durable:是否持久化
        return ExchangeBuilder.topicExchange(TEST_EXCHANGE_DLX_NAME).durable(true).build();
    }
    //2.Queue队列
    @Bean("test_Queue_dlx")
    public Queue testQueueDLX(){
        /*
        * x-dead-letter-exchange:绑定的死信交换机
        * x-dead-letter-routing-key:死信交换机绑定的死信队列
        * x-message-ttl：队列存活时间
        * x-max-length:队列最大长度
        * 
        * */
        return QueueBuilder.durable(TEST_QUEUE_DLX_NAME).withArgument("x-dead-letter-exchange","exchange_dlx").withArgument("x-dead-letter-routing-key","dlx.#").withArgument("x-message-ttl",10000).withArgument("x-max-length",10).build();
    }
    @Bean
    public Binding bindTestDLXQueueExchange(@Qualifier("test_Queue_dlx")Queue queue,@Qualifier("test_exchange_dlx") Exchange exchange){
        return BindingBuilder.bind(queue).to(exchange).with("test.dlx.#").noargs();
    }


    /*
    * 1.2声明死信队列
    *
    * */

    @Bean("exchange_dlx")
    public Exchange ExchangeDLX(){
        //durable:是否持久化
        return ExchangeBuilder.topicExchange(EXCHANGE_DLX_NAME).durable(true).build();
    }
    //2.Queue队列
    @Bean("Queue_dlx")
    public Queue QueueDLX(){
        return QueueBuilder.durable(QUEUE_DLX_NAME).build();
    }
    @Bean
    public Binding bindDLXQueueExchange(@Qualifier("Queue_dlx")Queue queue,@Qualifier("exchange_dlx") Exchange exchange){
        return BindingBuilder.bind(queue).to(exchange).with("dlx.#").noargs();
    }

 Test测试类

 @Test
    public void testDLX(){
        //测试过期时间

        rabbitTemplate.convertAndSend(TEST_EXCHANGE_DLX_NAME,"test.dlx.haha","我是一条消息，我会死吗！！！");
        //  测试长度限制，消息私信
        for(int i=0;i<20;i++){
            rabbitTemplate.convertAndSend(TEST_EXCHANGE_DLX_NAME,"test.dlx.haha","我是一条消息，我会死吗！！！");
        }

        //测试消息拒收
        rabbitTemplate.convertAndSend(TEST_EXCHANGE_DLX_NAME,"test.dlx.haha","我是一条消息，我会死吗！！！");

    }

Consumer: 仅仅用来测试最后的消息拒收
 

@Component
public class DLXListener implements ChannelAwareMessageListener {
    @RabbitListener(queues = "test_queue_dlx")
    @Override
    public void onMessage(Message message, Channel channel) throws Exception {
        long deliveryTag = message.getMessageProperties().getDeliveryTag();
        try {
            //1.接收转换消息
            System.out.println(new String(message.getBody()));
            //2.处理业务逻辑
            System.out.println("处理业务逻辑");
            //出现异常，让信息跑到死信队列
            int i=3/0;
            //3.手动签收
            channel.basicAck(deliveryTag,true);
        } catch (Exception e) {
//            e.printStackTrace();
            System.out.println("出现异常，拒绝接收！");
            //4.拒绝签收
            /*
            * b1:requeue:重回队列，如何设置为true,则消息重新回到队列，broker重新发送该消息到客户端，这里设置为false，不让回原队列，去死信交换机
            * */
            channel.basicNack(deliveryTag,true,false);
        }
    }
}

总结：

  1. 死信交换和死信交换机和普通的没有区别
  2. 当消息成为死信后，如果该队列绑定了私信交换机，则消息会被私信交换机重新路由到死信队列
  3. 消息成为死信的三种情况：
    1. 队列消息长度到达限制
    2. 消费者拒接消费信息，并且不重回队列
    3. 原队列存在消息过期设置，消息到达时间未被消费

延迟队列

即消息进入队列后不会立即被消费，只有到达指定时间后，才会被消费

业务场景：

  1. 下单后，30分钟未支付，取消订单，回滚库存
  2. 新用户注册7天后，发送短信问候

代码实现：TTL+DLX

/*
    * 延迟队列
    * */

    /*1.1正常队列*/
    //1.Exchange交换机
    @Bean("order_exchange")
    public Exchange orderExchange(){
        //durable:是否持久化
        return ExchangeBuilder.topicExchange(ORDER_EXCHANGE_NAME).durable(true).build();
    }
    //2.Queue队列
    @Bean("order_queue")
    public Queue orderQueue(){
        //设置ttl和DLx 这里如果代码创建队列的话 ttl的类型会默认为String 因此报错
        return QueueBuilder.durable(ORDER_QUEUE_NAME).withArgument("x-message-ttl",10000).withArgument("x-dead-letter-exchange","order_exchange_dlx").withArgument("x-dead-letter-routing-key","dlx.order.cancel").build();
    }

    @Bean
    public Binding bindOrderQueueExchange(@Qualifier("order_queue")Queue queue,@Qualifier("order_exchange") Exchange exchange){
        return BindingBuilder.bind(queue).to(exchange).with("order.#").noargs();
    }

    /*1.2死信队列*/

    @Bean("order_exchange_dlx")
    public Exchange orderDLXExchange(){
        //durable:是否持久化
        return ExchangeBuilder.topicExchange(ORDER_EXCHANGE_DLX_NAME).durable(true).build();
    }
    //2.Queue队列
    @Bean("order_queue_dlx")
    public Queue orderDLXQueue(){
        return QueueBuilder.durable(ORDER_QUEUE_DLX_NAME).build();
    }

    @Bean
    public Binding bindOrderDLXQueueExchange(@Qualifier("order_queue_dlx")Queue queue,@Qualifier("order_exchange_dlx") Exchange exchange){
        return BindingBuilder.bind(queue).to(exchange).with("dlx.order.#").noargs();
    }

总结：

  1. 延迟队列 指消息进入队列后，可以被延迟一定时间，再进行消费
  2. RabbitMQ没有提供延迟队列功能，但是可以使用：TTL+DLX来实现延迟队列效果

应用问题

消息补偿

消息补偿机制

幂等性保障

幂等性指一次和多次请求某一个资源，对于资源本身应该具有相同的结果，也就是说，其任意多次执行对资源本身所产生的影响与一次执行的影响相同

在MQ中，消费多条相同的消息，得到于消费该消息一次相同的结果

乐观锁机制：保证出现错误后，导致某些sql语句不会执行n次

不爱敲代码的懒羊羊
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
RabbitMQ实现ack-消息应答
Aldeo
02-22 839
1.yml配置   2.监听者 @RabbitListener(queues = "ack.test") public void handleMessage5(String data,Channel channel, Message message) { System.out.println("ack.test接收到的消息 : " + data); try { Thread.sleep...
@RabbitListener 消息队列 消息序列化
hudeyong926的专栏
03-22 2626
在一些场景下我们希望在消息发送到MQ之前或者接受消息前对消息做一些自定义处理,这个时候就需要自定义MessageConverter了。
Rabbit @RabbitListener消息队列注解
热门推荐
旭旭1998的博客
04-14 4万+
@RabbitListener(bindings = @QueueBinding( value = @Queue(value = queueName, durable = "true", ignoreDeclarationExceptions = "true"), exchange = @Exchange(value = EventConfig.exchangeGR, type = ExchangeTypes.FANOUT, durable = "true")
rabbitMQ实现延时队列
hanbingge123的博客
01-14 1335
0|1一、说明 在上一篇中，介绍了RabbitMQ中的死信队列是什么，何时使用以及如何使用RabbitMQ的死信队列。相信通过上一篇的学习，对于死信队列已经有了更多的了解，这一篇的内容也跟死信队列息息相关，如果你还不了解死信队列，那么建议你先进行上一篇文章的阅读。 这一篇里，我们将继续介绍RabbitMQ的高级特性，通过本篇的学习，你将收获： 什么是延时队列 延时队列使用场景 RabbitMQ中的TTL 如何利用RabbitMQ来实现延时队列 0|1二、本文大纲 以下是本文大纲： 本
@RabbitListener(quques=“ “）用法注意（RabbitMq）
qq_43237354的博客
07-15 1805
通过使用SpEL表达式，可以在运行时动态地获取和注入属性值，而不需要使用静态变量。注解中，指定的队列名称需要是常量。这意味着它必须是编译时确定的，而不能是在运行时动态计算的。是Spring表达式语言（SpEL）的一种写法，用于在Spring框架中动态获取属性值。这种写法，@rabbitListener会报错，队列名字我们没有使用常量。属性需要接受一个常量，以便在应用程序启动时就能确定要监听的队列。所以我们在配置文件里获得的变量，不可以直接使用。表示要引用的属性的键。注解中的队列名称中。
@RabbitListener的作用详解
IsAmant的博客
04-13 3004
@RabbitListener注解
rabbitmq的高级特性
最新发布
06-05
rabbitmq的高级特性
服务异步通信 - RabbitMQ的高级特性 - 高级篇相关软件
04-02
在实际应用中，配合如`rabbitmq-management`插件进行管理和监控，`spring-amqp`库进行编程集成，以及`rabbitmq-top`等工具进行性能分析，可以充分利用RabbitMQ的高级特性，构建高效稳定的异步通信系统。记住，理解并...
rabbitmq安装包
09-22
**RabbitMQ高级特性** 1. **工作队列（Work Queues）**: 用于分配任务到多个工作者，以提高处理效率。 2. **发布/订阅（Publish/Subscribe）**: 让多个消费者可以同时接收消息。 3. **路由（Routing）**: 基于...
RabbitMQ Server3.13.0
04-02
**高级特性** 1. **Work Queues**: 用于负载均衡，多个消费者可以从同一个队列中获取任务进行处理，防止同一任务被重复处理。 2. **Publish/Subscribe**: 通过主题交换机实现广播模式，所有订阅特定主题的消费者...
rabbitMQ课件.zip
10-26
**03RabbitMQ高级特性** RabbitMQ提供了许多高级特性，如： 1. **死信队列（Dead-Letter Queue）**: 当消息无法正常处理时，可以将其路由到死信队列，便于排查问题。 2. **延迟队列（Delayed Exchange）**: 可以...
rabbitmq完整例子
08-13
6. **RabbitMQ高级特性** - 消息确认：生产者和消费者都可以开启消息确认机制，确保消息的可靠传输。 - 消息持久化：通过设置，可以使消息在服务器重启后仍能恢复，保证高可用性。 - DLX（Dead Letter Exchange）...
RabbitMQ高级（消息可靠性、死信交换机、惰性队列、MQ集群部署）
06-30
在本篇中，我们将深入探讨 RabbitMQ 的几个高级特性：消息可靠性、死信交换机、惰性队列以及MQ集群部署。 ### 1. 消息可靠性 确保消息传递的可靠性是 RabbitMQ 的核心功能之一。这主要通过以下几种方式实现： - *...
rabbitmq-jar包
06-29
5. 高级特性： - **TTL（Time To Live）**: 可以设置消息或队列的存活时间，过期后自动删除。 - **死信队列（Dead Letter Queue）**: 错误或无法处理的消息会被转发到死信队列，以便后续排查问题。 - **确认模式...
RabbitMQ手动ACK与死信队列
菜鸟逆袭之路
05-27 6537
RabbitMQ手动ACK与死信队列
@RabbitListener常用总结
m0_67920613的博客
01-16 3420
是 Spring AMQP 提供的注解，用于简化 RabbitMQ 消息监听器的创建。通过在方法上添加注解，可以将方法注册为消息监听器，用于处理从 RabbitMQ 中接收到的消息。以下是。
springcloud：RabbitMQ快速上手（二）
55555的博客
05-13 644
0. 引言 上一章咱们讲解了什么是消息队列，已经为什么使用消息队列。并且阐述了我们入门选用RabbitMQ的原因。 同时为了践行我们“先讲核心，快速入门，循环学习，深入原理”的原则，我们先将RabbitMQ核心操作讲解，让大家能够快速上手RabbitMQ，能够在工作中直接应用上，后续我们再来补讲其中的原理和常见面试题 1. RabbitMQ介绍 rabbitmq是实现了高级消息队列协议（AMQP）的开源消息代理软件，使用erlang语言编写。erlang语言是一种面向并发的编程语言，所以其并发量远远大于ja
@RabbitListener详解
weixin_42599558的博客
02-14 2973
@RabbitListener 是用于在 Spring AMQP 中消息监听的注解。它允许在 Spring 应用程序中声明消息监听器。在使用 @RabbitListener 注解的方法上，可以接收来自 RabbitMQ 队列的消息。这些方法可以通过使用 @RabbitHandler 注解标记，并在方法中声明一个参数来表示要接收的消息。 例如： @RabbitListener(queues = "q...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值