RabbitMQ高级特性

最新推荐文章于 2023-09-05 21:49:28 发布
最新推荐文章于 2023-09-05 21:49:28 发布
阅读量810 收藏
点赞数 1
分类专栏： 分布式消息队列 文章标签： rabbitmq java 分布式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yemuxiaweiliang/article/details/121345036
版权

RabbitMQ高级特性

TTL

  • TTL 全称 Time To Live（存活时间/过期时间）。
  • 当消息到达存活时间后，还没有被消费，会被自动清除。
  • RabbitMQ可以对消息设置过期时间，也可以对整个队列（Queue）设置过期时间。
    在这里插入图片描述

案例

此处只需要启动生产端程序，然后观察指定的时间之后，消息是否被清除即可验证该功能

  • 修改生产端配置，并增加测试用例
<rabbit:queue name="test_queue_ttl" id="test_queue_ttl">
    <!--设置queue的参数-->
    <rabbit:queue-arguments>
        <!--x-message-ttl指队列的过期时间-->
        <entry key="x-message-ttl" value="10000" value-type="java.lang.Integer"></entry>
    </rabbit:queue-arguments>

</rabbit:queue>

<rabbit:topic-exchange name="test_exchange_ttl" >
    <rabbit:bindings>
        <rabbit:binding pattern="ttl.#" queue="test_queue_ttl"></rabbit:binding>
    </rabbit:bindings>
</rabbit:topic-exchange>

 @Test
 public void testTtl() {


     for (int i = 0; i < 10; i++) {
         // 发送消息
         rabbitTemplate.convertAndSend("test_exchange_ttl", "ttl.baiqi", "message ttl....");
     }
 }

在这里插入图片描述
在这里插入图片描述

TTL 小结

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

死信队列

死信队列，英文缩写：DLX 。Dead Letter Exchange（死信交换机），当消息成为Dead message后，可以被重新发送到另一个交换机，这个交换机就是DLX。
在这里插入图片描述

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

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

队列绑定死信交换机

给队列设置参数： x-dead-letter-exchange 和 x-dead-letter-routing-key
在这里插入图片描述

案例

  • 生产端配置和单元用例
<!--
        死信队列：
            1. 声明正常的队列(test_queue_dlx)和交换机(test_exchange_dlx)
            2. 声明死信队列(queue_dlx)和死信交换机(exchange_dlx)
            3. 正常队列绑定死信交换机
                设置两个参数：
                    * x-dead-letter-exchange：死信交换机名称
                    * x-dead-letter-routing-key：发送给死信交换机的routingkey
    -->

<!--
    1. 声明正常的队列(test_queue_dlx)和交换机(test_exchange_dlx)
-->

<rabbit:queue name="test_queue_dlx" id="test_queue_dlx">
    <!--3. 正常队列绑定死信交换机-->
    <rabbit:queue-arguments>
        <!--3.1 x-dead-letter-exchange：死信交换机名称-->
        <entry key="x-dead-letter-exchange" value="exchange_dlx" />

        <!--3.2 x-dead-letter-routing-key：发送给死信交换机的routingkey-->
        <entry key="x-dead-letter-routing-key" value="dlx.hehe" />

        <!--4.1 设置队列的过期时间 ttl-->
        <entry key="x-message-ttl" value="10000" value-type="java.lang.Integer" />
        <!--4.2 设置队列的长度限制 max-length-->
        <entry key="x-max-length" value="10" value-type="java.lang.Integer" />
    </rabbit:queue-arguments>
</rabbit:queue>

<rabbit:topic-exchange name="test_exchange_dlx">
    <rabbit:bindings>
        <rabbit:binding pattern="test.dlx.#" queue="test_queue_dlx"></rabbit:binding>
    </rabbit:bindings>
</rabbit:topic-exchange>


<!--
   2. 声明死信队列(queue_dlx)和死信交换机(exchange_dlx)
-->

<rabbit:queue name="queue_dlx" id="queue_dlx"></rabbit:queue>
<rabbit:topic-exchange name="exchange_dlx">
    <rabbit:bindings>
        <rabbit:binding pattern="dlx.#" queue="queue_dlx"></rabbit:binding>
    </rabbit:bindings>
</rabbit:topic-exchange>

 /**
  * 发送测试死信消息：
  *  1. 过期时间
  *  2. 长度限制
  *  3. 消息拒收
  */
 @Test
 public void testDlx(){
     //1. 测试过期时间，死信消息
     rabbitTemplate.convertAndSend("test_exchange_dlx","test.dlx.hehe","死信消息测试1，开始...");

     //2. 测试长度限制后，消息死信
    /* for (int i = 0; i < 20; i++) {
         rabbitTemplate.convertAndSend("test_exchange_dlx","test.dlx.hehe","死信消息测试2，开始...");
     }*/

     //3. 测试消息拒收
     //rabbitTemplate.convertAndSend("test_exchange_dlx","test.dlx.baiqi","死信消息测试3，开始...");

 }
  • 消费端配置以及监听器
<!--定义监听器容器  acknowledge="manual"  prefetch="1"  -->
<rabbit:listener-container connection-factory="connectionFactory" acknowledge="manual">

    <!--定义监听器，监听正常队列-->
    <rabbit:listener ref="dlxListener" queue-names="test_queue_dlx"></rabbit:listener>
</rabbit:listener-container>

package com.baiqi.listener;

import com.rabbitmq.client.Channel;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.listener.api.ChannelAwareMessageListener;
import org.springframework.stereotype.Component;


@Component
public class DlxListener implements ChannelAwareMessageListener {

    @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.拒绝签收，不重回队列 requeue=false
            channel.basicNack(deliveryTag,true,false);
        }
    }
}
  • 测试过期消息进入死信队列，这种情况只启动发送端即可。不用启动消费端。
    在这里插入图片描述
    在这里插入图片描述
  • 测试长度限制后，消息死信，队列长度为10.现在发送20个消息，必定有10个消息进入死信队列
    在这里插入图片描述
  • 测试消息拒收
package com.baiqi.listener;

import com.rabbitmq.client.Channel;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.listener.api.ChannelAwareMessageListener;
import org.springframework.stereotype.Component;


@Component
public class DlxListener implements ChannelAwareMessageListener {

    @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.拒绝签收，不重回队列 requeue=false
            channel.basicNack(deliveryTag,true,false);
        }
    }
}

在这里插入图片描述

在这里插入图片描述

死信队列小结

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

延迟队列

延迟队列，即消息进入队列后不会立即被消费，只有到达指定时间后，才会被消费。
需求：

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

实现方式：

  • 定时器
  • 延迟队列

在这里插入图片描述

定时任务的时效性问题

在这里插入图片描述

RabbitMQ中实现延迟队列

在RabbitMQ中并未提供延迟队列功能。
但是可以使用：TTL+死信队列 组合实现延迟队列的效果。
在这里插入图片描述

案例

  • 发送端配置和单元用例
<!--
        延迟队列：
            1. 定义正常交换机（order_exchange）和队列(order_queue)
            2. 定义死信交换机（order_exchange_dlx）和队列(order_queue_dlx)
            3. 绑定，设置正常队列过期时间为30分钟
    -->
<!-- 1. 定义正常交换机（order_exchange）和队列(order_queue)-->
<rabbit:queue id="order_queue" name="order_queue">
    <!--3. 绑定，设置正常队列过期时间为30分钟-->
    <rabbit:queue-arguments>
        <entry key="x-dead-letter-exchange" value="order_exchange_dlx" />
        <entry key="x-dead-letter-routing-key" value="dlx.order.cancel" />
        <entry key="x-message-ttl" value="10000" value-type="java.lang.Integer" />
    </rabbit:queue-arguments>
</rabbit:queue>

<rabbit:topic-exchange name="order_exchange">
    <rabbit:bindings>
        <rabbit:binding pattern="order.#" queue="order_queue"></rabbit:binding>
    </rabbit:bindings>
</rabbit:topic-exchange>

<!--2. 定义死信交换机（order_exchange_dlx）和队列(order_queue_dlx)-->
<rabbit:queue id="order_queue_dlx" name="order_queue_dlx"></rabbit:queue>

<rabbit:topic-exchange name="order_exchange_dlx">
    <rabbit:bindings>
        <rabbit:binding pattern="dlx.order.#" queue="order_queue_dlx"></rabbit:binding>
    </rabbit:bindings>
</rabbit:topic-exchange>

/*
 * 测试延时消息
 * */
@Test
public  void testDelay() throws InterruptedException {
    //1.发送订单消息。 将来是在订单系统中，下单成功后，发送消息
    rabbitTemplate.convertAndSend("order_exchange","order.msg","订单信息：id=1,time=2020年12月...");


    //2.打印倒计时10秒
    for (int i = 10; i > 0 ; i--) {
        System.out.println(i+"...");
        Thread.sleep(1000);
    }

}
  • 消费端配置及代码
<!--定义监听器容器  acknowledge="manual"  prefetch="1"  -->
<rabbit:listener-container connection-factory="connectionFactory" acknowledge="manual">
    <!--延迟队列效果实现：  一定要监听的是 死信队列！！！-->
    <rabbit:listener ref="orderListener" queue-names="order_queue_dlx"></rabbit:listener>
</rabbit:listener-container>

package com.baiqi.listener;

import com.rabbitmq.client.Channel;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.listener.api.ChannelAwareMessageListener;
import org.springframework.stereotype.Component;


@Component
public class OrderListener implements ChannelAwareMessageListener {

    @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("处理业务逻辑...");
            System.out.println("根据订单id查询其状态...");
            System.out.println("判断状态是否为支付成功");
            System.out.println("取消订单，回滚库存....");
            //3. 手动签收
            channel.basicAck(deliveryTag,true);
        } catch (Exception e) {
            //e.printStackTrace();
            System.out.println("出现异常，拒绝接受");
            //4.拒绝签收，不重回队列 requeue=false
            channel.basicNack(deliveryTag,true,false);
        }
    }
}
  • 案例演示
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

延迟队列小结

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

消息幂等性保障

出现非幂等性的情况

  • 1、生产者已把消息发送到mq，在mq给生产者返回ack的时候网络中断，故生产者未收到确定信息，生产者认为消息未发送成功，但实际情况是，mq已成功接收到了消息，在网络重连后，生产者会重新发送刚才的消息，造成mq接收了重复的消息
  • 2、消费者在消费mq中的消息时，mq已把消息发送给消费者，消费者在给mq返回ack时网络中断，故mq未收到确认信息，该条消息会重新发给其他的消费者，或者在网络重连后再次发送给该消费者，但实际上该消费者已成功消费了该条消息，造成消费者消费了重复的消息；

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

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

  • 1、mq接收生产者传来的消息：
    mq内部会为每条消息生成一个全局唯一、与业务无关的消息id，当mq接收到消息时，会先根据该id判断消息是否重复发送，mq再决定是否接收该消息。
  • 2、消费者消费mq中的消息：
    也可利用mq的该id来判断，或者可按自己的规则生成一个全局唯一id，每次消费消息时用该id先判断该消息是否已消费过

消息积压

  • 消费者宕机积压
  • 消费者消费能力不足积压
  • 发送者发流量太大

上线更多的消费者,进行正常消费
上线专门的队列消费服务,
将消息先批量取出来,记录数据库,再慢慢处理

yemuxiaweiliang
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
RabbitMQ -高级特性
chrismurphy的博客
09-19 360
消息的可靠性投递（确认模式/退回模式）｜Consumer Ack ｜ 消费端限流 ｜TTL ｜ 死信队列 ｜ 延迟队列（模拟30分钟未支付退单）
RabbitMQ-下-高级特性
DrewWong的博客
11-18 236
RabbitMQ 高级特性 1 消息的可靠投递 概述 1.1 生产者层面 Producer====>Exchange 针对Producer===》Exchange confirm模式 对Producer端发送消息的时候设置一个confirmCallback的监听，到达或者不到达MQ服务中间件Exchange，监听confirmCallback都会被执行。如果Exchange成功收到消息返回true,反着为false.也就是说不管消息有没有到达Exchange都会执行监听方法。 步骤： 生产者
Spring-Amqp MessageListener详解
weixin_33725270的博客
06-13 1542
为什么80%的码农都做不了架构师？>>> ...
Web | RabbitMQ | 高级应用
qq_43354104的博客
07-12 195
Web-RabbitMQ高级目录一、消息可靠性投递1. confirm 确认模式1.1 整合Springboot/Spring后中的实现第一步：开启第二步：设置回调函数1.2 Channel类第一步：开启第二步：设置回调函数1.3 总结2. Return 退回模式第一步：开启第二步：设置回调函数小结3. 对比二、消费端确认2.1 Spring1. 创建监听容器2. 创建监听器2.2 springboot1. 指定确认模式三、消费端限流四、TTL过期时间设置1. 规则2. 设置队列过期3. 设置消息过期五、
Spring整合RabbitMQ-配制文件方式-2-推模式消费者
bug_null的博客
09-05 585
除消息外，还提供了Channel这个对象，通过channel可以有更大的灵活性。再观察消息者，便能看到消费者队列中已经收到了发送的消息。这样监听者就会处于监听状态。普通的场景基本够用。在推模式中消息的即时性比拉模式会好。再启动生产者，向队列中发送消息。
SpringBoot RabbitMQ ChannelAwareMessageListener onMessage同步消息返回结果 rpc模式
lyll3269的博客
06-09 9408
说明 1、此例前提条件：你已实现rabbitmq消息的手动确认模式相关代码，已完成消息监听类和队列的绑定。 2、此例解决：实现ChannelAwareMessageListener接口进行消息监听，消息生产者发送同步消息，阻塞等待接收返回结果。参考官方文档：https://www.rabbitmq.com/tutorials/tutorial-six-java.html 3、使用@RabbitListener注解进行消息监听的同步消息处理更简单，可查看官方文档：https://www.rabbitmq
RabbitMQ（三）手动Ack确认
热门推荐
sun_tantan的博客
03-19 1万+
默认情况下 spring-boot-data-amqp 是自动ACK机制，就意味着 MQ 会在消息发送完毕后，自动帮我们去ACK，然后删除消息的信息。 这样依赖就存在这样一个问题： 如果消费者处理消息需要较长时间，最好的做法是消费端处理完之后手动去确认。 消费者： @Service("confirmListener") public class ConfirmListener implements...
Day96.RabbitMQ：高级特性: 消息可靠投递、Ack、死信队列、SpringBoot整合、集群_队列镜像
a111042555的博客
07-03 973
rabbitmq
rabbitmq的高级特性
06-05
rabbitmq的高级特性
rabbitmq高可用+高级特性
最新发布
07-04
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-消息可靠传递-消息确认机制，手动确认，针对消费者方向（七）
qq_42218187的博客
11-15 788
基于spring整合的rabbitmq <!--定义监听器容器，监听的是test_queue_confirm这个队列 acknowledge="manual"：手动签收 --> <rabbit:listener-container connection-factory="connectionFactory" acknowledge="manual"> <rabbit:listener ref="ackListener" queue
rabbitmq整合springboot:ChannelAwareMessageListener和@RabbitListener的使用
qq_41358574的博客
01-26 2963
rabbitmq两种监听器的写法
springboot-rabbitmq ack的问题？
java_seeking的博客
01-23 1041
如何手动ack - 网上的方式1：实现channelAwareMessageListener public class RabbitMsgReceiver implements ChannelAwareMessageListener{ public void onMessage(Message message, Channel channel) throw Exception{ S...
四：RabbitMQ 高级特性
Xx__WangQi的博客
04-14 664
目录 1、RabbitMQ 高级特性 1.1 消息的可靠投递 1.2 Consumer Ack 1.3 消费端限流 1.4 TTL 1.5 死信队列 1.6 延迟队列 1.7 消息幂等性保障 1.8 消息积压 1、RabbitMQ 高级特性 1.1 消息的可靠投递 在使用 RabbitMQ 的时候，作为消息发送方希望杜绝任何消息丢失或者投递失败场景。 RabbitMQ 为我们提供了两种方式用来控制消息的投递可靠性模式。 confirm 确认模式 return 退回模式 ..

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

yemuxiaweiliang

你的鼓励将是我创作的最大动力

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

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

打赏作者

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

抵扣说明：

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

余额充值