RabbitMQ高级特性

已于 2022-05-30 10:21:28 修改
阅读量799 收藏 1
点赞数 1
分类专栏： 消息中间件 文章标签： rabbitmq java 分布式
于 2022-05-30 09:40:48 首次发布
原文链接：https://www.bilibili.com/video/BV15k4y1k7Ep
版权

目录

消息的可靠投递

在这里插入图片描述

confirm 确认模式（针对生产者）

确认模式：
步骤：
1. 确认模式开启： publisher-confirm-type: correlated
2. 在rabbitTemplate定义ConfirmCallBack回调函数

首先是 开启确认模式：
在这里插入图片描述
然后是设置交换机和队列：

@Configuration
public class RabbitMQConfirmConfig {

    public static final String EXCHANGE_NAME = "test_exchange_confirm";
    public static final String QUEUE_NAME = "test_queue_confirm";

    //1.交换机
    @Bean("bootExchange")
    public Exchange bootExchange(){

        return ExchangeBuilder.topicExchange(EXCHANGE_NAME).durable(true).build();
    }


    //2.Queue 队列
    @Bean("bootQueue")
    public Queue bootQueue(){
        return QueueBuilder.durable(QUEUE_NAME).build();
    }

    //3. 队列和交互机绑定关系 Binding
    /*
        1. 知道哪个队列
        2. 知道哪个交换机
        3. routing key
     */
    @Bean
    public Binding bindQueueExchange(@Qualifier("bootQueue") Queue queue, @Qualifier("bootExchange") Exchange exchange){
        return BindingBuilder
                .bind(queue).to(exchange).with("confirm").noargs();
    }

最后测试代码：

   //1.注入RabbitTemplate
    @Autowired
    private RabbitTemplate rabbitTemplate;

    @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("test_exchange_confirm111", "confirm", "message confirm....");
    }

return 退回模式（针对生产者）

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

首先是yaml：
在这里插入图片描述
交换机和队列用上一个案列即可。

测试代码：

//1.注入RabbitTemplate
    @Autowired
    private RabbitTemplate rabbitTemplate;


    @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("test_exchange_confirm", "confirm", "message confirm....");
    }

总结：

在这里插入图片描述

Consumer Ack（针对消费者）

在这里插入图片描述

手动确认：

代码：

@Autowired
    private RabbitTemplate rabbitTemplate;


    @Test
    public void testack(){
       while (true){

       }
    }
    @RabbitListener(queues = "test_queue_confirm",ackMode ="MANUAL" )
    public void listener(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,false);
        } catch (Exception e) {
            //e.printStackTrace();

            //4.拒绝签收
            /*
            第三个参数：requeue：重回队列。如果设置为true，则消息重新回到queue，broker会重新发送该消息给消费端
             */
            channel.basicNack(deliveryTag,true,true);
            //channel.basicReject(deliveryTag,true);
        }
    }
Multiple 的解释

手动应答的好处是可以批量应答并且减少网络拥堵
multiple 的 true 和 false 代表不同意思
true 代表批量应答 channel 上未应答的消息
比如说 channel 上有传送 tag 的消息 5,6,7,8 当前 tag 是 8 那么此时
5-8 的这些还未应答的消息都会被确认收到消息应答
false 同上面相比
只会应答 tag=8 的消息 5,6,7 这三个消息依然不会被确认收到消息应答
在这里插入图片描述

Ack小结：

在这里插入图片描述

消息可靠性总结

在这里插入图片描述

消费端限流

在这里插入图片描述

代码：

只需要改这里的设置即可，其他的不用变
在这里插入图片描述
测试发送10条，消费者一直不手动应答，看看能持续接受那几条
在这里插入图片描述

小结：

在这里插入图片描述

TTL

在这里插入图片描述

队列里面统一过期

代码：

只需要在创建队列的时候添加这个参数即可：
在这里插入图片描述

单独消息过期时间：

代码：

// 消息后处理对象，设置一些消息的参数信息
        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);

注意！！：

消息过期后，只有消息在队列顶端，才会判断其是否过期(移除掉)
解释：
比如下面的代码 则不会被过期： 因为rabbitmq不会取 遍历找寻那个消息要过期了，那样会很慢，所以他直接只看第一个设置有没有过期时间，有就把他删除了，没有就算了。
在这里插入图片描述

死信队列

基础架构图：

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

产生原因：

在这里插入图片描述

代码实现：

  死信队列：
            1. 声明正常的队列(test_queue_dlx)和交换机(test_exchange_dlx)
            2. 声明死信队列(queue_dlx)和死信交换机(exchange_dlx)
            3. 正常队列绑定死信交换机
                设置两个参数：
                    * x-dead-letter-exchange：死信交换机名称
                    * x-dead-letter-routing-key：发送给死信交换机的routingkey

逻辑代码：

@Configuration
public class RabbitMQDeadConfig {

    public static final String EXCHANGE_NAME = "test_exchange_dlx";
    public static final String QUEUE_NAME = "test_queue_dlx";
    public static final String DEAD_EXCHANGE_NAME = "exchange_dlx";
    public static final String DEAD_QUEUE_NAME = "queue_dlx";

    //1.正常交换机
    @Bean("bootExchange")
    public Exchange bootExchange(){
        return ExchangeBuilder.topicExchange(EXCHANGE_NAME).durable(true).build();
    }

    //2.正常Queue 队列
    @Bean("bootQueue")
    public Queue bootQueue(){

        //还有和死刑交换机进行绑定
        return QueueBuilder.durable(QUEUE_NAME)
                .ttl(1000*10)  //设置ttl时间 模拟死刑
                .deadLetterExchange(DEAD_EXCHANGE_NAME) //绑定死刑交换机
                .deadLetterRoutingKey("#.dlx.#")  //设置死刑key
                .build();
    }

    //3. 队列和交互机绑定关系 Binding
    /*
        1. 知道哪个队列
        2. 知道哪个交换机
        3. routing key
     */
    @Bean
    public Binding bindQueueExchange(@Qualifier("bootQueue") Queue queue, @Qualifier("bootExchange") Exchange exchange){
        return BindingBuilder
                .bind(queue).to(exchange).with("test.#").noargs();
    }


    //1.死刑交换机
    @Bean("deadExchange")
    public Exchange deadExchange(){
        return ExchangeBuilder.topicExchange(DEAD_EXCHANGE_NAME).durable(true).build();
    }

    //2.死刑Queue 队列
    @Bean("deadQueue")
    public Queue deadQueue(){
        //设置ttl时间 模拟死刑
        return QueueBuilder.durable(DEAD_QUEUE_NAME).build();
    }

    //3. 死刑队列和死刑机绑定关系 Binding
    /*
        1. 知道哪个队列
        2. 知道哪个交换机
        3. routing key
     */
    @Bean
    public Binding binddeadQueueExchange(@Qualifier("deadQueue") Queue queue, @Qualifier("deadExchange") Exchange exchange){
        return BindingBuilder
                .bind(queue).to(exchange).with("#.dlx.#").noargs();
    }


}

测试代码：

  for (int i = 0; i < 20; i++) {
            rabbitTemplate.convertAndSend("test_exchange_dlx","test.dlx.haha","我是一条消息，我会死吗？");
        }

总结：

在这里插入图片描述

！！延迟队列：

应用场景：下订单30分钟之内需要确认这种。
延迟队列：TTL+死性队列
在这里插入图片描述

代码：

就是上面的TTl+死刑队列相组合即可完成

总结：

在这里插入图片描述

目录

应用问题

以下问题主要是思路的讲解 建议看视频很短的：
视频链接

消息可靠性保障–消息补偿

主要是 确保消息能够百分百传送到，
在这里插入图片描述

消息幂等性保障

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

集群问题

免费资料下载

补充：

镜像队列：
搭建集群，一般可能主节点挂了，他队列里面的信息，从节点就无法访问了，于是需要搭建镜像队列。
负载均衡-HAProxy
集群搭建好了，我们向哪个IP写代码比较合适嘞？所以这时候需要一个管理所有的IP的插件，我们向插件写，他自动取分配可用的IP地址。

Code-zyc
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
RabbitMQ笔记
chen772209的博客
09-30 358
RabbitMQ笔记 第一种模型：直连模型： 一个生产者对应一个消费者 第二种模型：work queue： 一个生产者对应多个消费者： 这多个消费者默认是采用均分的策略来消费消息的。 但是也是可以通过一些设置来达到能者多劳的功能的。这个设置看那个笔记即可。 第三种模型：fanout（广播模型）： 实现了一条消息能被多个消费者消费 可以有多个消费者（每个消费者都绑定一个临时队列） 每个消费者有自己的queue（队列） 每个队列都要绑定到exchange（交换机） 生产者发送消息，=只能发送给交换机，交换机来
Rabbitmq消息队列详解
qq_52030824的博客
11-01 4426
Rabbitmq消息队列详解
RabbitMQ之交换机的讲解
2301_82242844的博客
05-06 993
/ 定义键.orange..rabbit”;// 创建队列@Bean@Bean@Bean// 创建交换机@Bean// 进行交换机和队列的绑定：设置bindingkey@Bean@Bean@Bean自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。深知大多数Java工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。
记录SpringAMQP通过实现BeanPostProcessor类，并重写实例化Bean的后置处理器，解决启动消费者服务队列不存在报错
qq_44609309的博客
06-12 167
参考文章中，并没有进行队列是否存在的判断，在实际过程中会发生因为队列已经存在而导致服务无法启动成功。通过RabbitAdmin类的getQueueProperties方法来判断队列是否存在。
rabbitmq中的queueDeclare方法
诚的博客
04-16 4043
queueDeclare Queue.DeclareOk queueDeclare() throws IOException; /** * Declare a queue * @see com.rabbitmq.client.AMQP.Queue.Declare * @see com.rabbitmq.client.AMQP.Queue.DeclareOk ...
如何保证RabbitMQ消息的可靠传输？
weixin_44227923的博客
11-14 900
消息不可靠的情况可能是消息丢失，劫持等原因； 丢失又分为：生产者丢失消息、消息列表丢失消息、消费者丢失消息； 生产者丢失消息：从生产者弄丢数据这个角度来看，RabbitMQ提供confirm模式来确保生产者不丢消息； confirm模式用的居多：一旦channel进入confirm模式，所有在该信道上发布的消息都将会被指派一个唯一的ID（从1开始），一旦消息被投递到所有匹配的队列之后；...
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 手动提交_RabbitMQ系列（四）RabbitMQ事务和Confirm发送方消息确认——深入解读 - 王磊的博客 - 博客园...
weixin_39860280的博客
12-21 212
RabbitMQ事务和Confirm发送方消息确认——深入解读RabbitMQ系列文章引言根据前面的知识( 深入了解RabbitMQ工作原理及简单使用 、 Rabbit的几种工作模式介绍与实践 )我们知道，如果要保证消息的可靠性，需要对消息进行持久化处理，然而消息持久化除了需要代码的设置之外，还有一个重要步骤是至关重要的，那就是保证你的消息顺利进入Broker(◇◇)，如图所示： 正常情况下，如果...
【C#】RabbitMQ高阶指南（三）（完）
catshitone的专栏
03-20 2979
续上一篇文章：【C#】RabbitMQ进阶指南 文章目录引言1. 存储机制1.1 队列的结构1.2 惰性队列（lazy queue）2. 内存和磁盘告警2.1 内存告警2.2 磁盘告警3. 流控3.1 流控原理4. 镜像队列 引言 本文将会在原理层面，进一步剖析并了解RabbitMQ的实现原理，可以帮助我们在实际工作中透过现象看到本质。比如一个队列的内部存储其实是由5个子队列来流转运作的，队列中的消息可以有4中不同的状态等，通过这些可以明白在使用RabbitMQ时尽量不要有过多的消息堆积，不然会影响整体性能
【C#】RabbitMQ进阶指南（二）
catshitone的专栏
02-27 2576
文章目录1. 消息何去何从1.1 备选交换机（Alternate Exchange,AE)2. 过期时间设置（Time to Live, TTL）2.1 设置消息的过期时间2.1.1 通过队列设置2.1.2 单独设置某个消息的ttl2.2 设置队列的过期时间3.死信队列（Dead-Letter-Exchange,DLX)4. 延迟队列5. 优先级队列6. 持久化7. 生产者确认7.1 事务机制7.2 发送方确认机制7.2.1 发布一条消息就等待一次确认结果7.2.2 批量发布N条消息等待一次确认结果7.2.
rabbitmq
spum_的博客
07-27 979
rabbitmq
检查Rabbitmq中队列及消息个数，还有清空的方法
weixin_34319374的博客
07-06 6461
rabbitmqctl list_queuesrabbitmqctl purge_queue kafka_queue   (不推荐)使用reset方式重置rabbitmq即清空掉rabbitmq所有的队列数据和配置(划重点) rabbitmqctl stop_app rabbitmqctl reset rabbitmqctl start_app...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值