RabbitMQ高级应用

最新推荐文章于 2024-08-28 06:30:00 发布
转载 最新推荐文章于 2024-08-28 06:30:00 发布 · 221 阅读 · 1 ·
CC 4.0 BY-SA版权
原文链接：http://www.cnblogs.com/toov5/p/9940566.html
文章标签：

#大数据 #java

 

高级应用一： 手动模式和自动应答模式

 1. 了确保消息不会丢失，RabbitMQ支持消息应答。消费者发送一个消息应答，告诉RabbitMQ这个消息已经接收并且处理完毕了。RabbitMQ就可以删除它了。
   2. 如果一个消费者挂掉却没有发送应答，RabbitMQ会理解为这个消息没有处理完全，然后交给另一个消费者去重新处理。这样，你就可以确认即使消费者偶尔挂掉也不会丢失任何消息了。
   3. 没有任何消息超时限制；只有当消费者挂掉时，RabbitMQ才会重新投递。即使处理一条消息会花费很长的时间。
   4. 消息应答是默认打开的。我们通过显示的设置autoAsk=true关闭这种机制。现即自动应答开，一旦我们完成任务，消费者会自动发送应答。通知RabbitMQ消息已被处理，可以从内存删除。如果消费者因宕机或链接失败等原因没有发送ACK（不同于ActiveMQ，在RabbitMQ里，消息没有过期的概  念），则RabbitMQ会将消息重新发送给其他监听在队列的下一个消费者。

 

案例:
生产者端代码不变，消费者端代码这部分就是用于开启手动应答模式的。
channel.basicConsume(QUEUE_NAME, false, defaultConsumer);
注：第二个参数值为false代表关闭RabbitMQ的自动应答机制，改为手动应答。
在处理完消息时，返回应答状态，true表示为自动应答模式。
channel.basicAck(envelope.getDeliveryTag(), false);

 

应答模式： 自动签收~~~

自动应答： 不在乎消费者对消息处理是否成功，都会告诉队列删除消息。如果处理消息失败，实现自动补偿（队列投递过去 重新处理）。

 

手动应答： 消费者处理完业务逻辑，手动返回ack（通知）告诉队列处理完了，队列进而删除消息。

 

生产者代码不变，消费者：

package com.toov5.Consumer;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.DefaultConsumer;
import com.rabbitmq.client.Envelope;
import com.rabbitmq.client.AMQP.BasicProperties;
import com.toov5.utils.MQConnectionUtils;

public class Consumer {
  
     //队列名称
        private static final String QUEUE_NAME = "test_queue";
        
        public static void main(String[] args) throws IOException, TimeoutException {
            System.out.println("消费者启动..........");
            //创建新的连接
        Connection connection = MQConnectionUtils.newConnection();
           //创建Channel
            Channel channel = connection.createChannel();
            // 消费者关联队列
            channel.queueDeclare(QUEUE_NAME, false, false, false, null);
            
              DefaultConsumer defaultConsumerr = new DefaultConsumer(channel) {
                  //监听获取消息
                    @Override
                    public void handleDelivery(String consumerTag, Envelope envelope, BasicProperties properties,
                            byte[] body) throws IOException {
                        String msg =new String(body,"UTF-8");
                        System.out.println("消费者获取生产者消息："+msg);
                    }
              };
            //牵手模式设置  默认自动应答模式  true:自动应答模式  
              channel.basicConsume(QUEUE_NAME, false, defaultConsumerr);//    fanse手动应答          
              
//            //关闭通道和连接
//             channel.close();
//             connection.close();
        }
}

手动应答。此时 消息队列的消息 一直没有被清除掉

如下修改：

package com.toov5.Consumer;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.DefaultConsumer;
import com.rabbitmq.client.Envelope;
import com.rabbitmq.client.AMQP.BasicProperties;
import com.toov5.utils.MQConnectionUtils;

public class Consumer {
  
     //队列名称
        private static final String QUEUE_NAME = "test_queue";
        
        public static void main(String[] args) throws IOException, TimeoutException {
            System.out.println("消费者启动..........");
            //创建新的连接
        Connection connection = MQConnectionUtils.newConnection();
           //创建Channel
            final Channel channel = connection.createChannel();
            // 消费者关联队列
            channel.queueDeclare(QUEUE_NAME, false, false, false, null);
            
              DefaultConsumer defaultConsumerr = new DefaultConsumer(channel) {
                  //监听获取消息
                    @Override
                    public void handleDelivery(String consumerTag, Envelope envelope, BasicProperties properties,
                            byte[] body) throws IOException {
                        String msg =new String(body,"UTF-8");
                        System.out.println("消费者获取生产者消息："+msg);
                        channel.basicAck(envelope.getDeliveryTag(), false);  //手动应答 告诉消息队列服务器 消费成功
                    }
              };
            //牵手模式设置  默认自动应答模式  true:自动应答模式  
              channel.basicConsume(QUEUE_NAME, false, defaultConsumerr);//    fanse手动应答          
              
//            //关闭通道和连接
//             channel.close();
//             connection.close();
        }
}

 

 这样就消费完毕了

 

高级应用二： 公平队列

目前消息转发机制是平均分配，这样就会出现俩个消费者，奇数的任务很耗时，偶数的任何工作量很小，造成的原因就是近当消息到达队列进行转发消息。并不在乎有多少任务消费者并未传递一个应答给RabbitMQ。仅仅盲目转发所有的奇数给一个消费者，偶数给另一个消费者。

为了解决这样的问题，我们可以使用basicQos方法，传递参数为prefetchCount= 1。这样告诉RabbitMQ不要在同一时间给一个消费者超过一条消息。
换句话说，只有在 消费者空闲的时候会发送下一条信息。调度分发消息的方式，也就是告诉RabbitMQ每次只给消费者处理一条消息，也就是等待消费者处理完毕并自己对刚刚处理的消息进行确认之后，才发送下一条消息，防止消费者太过于忙碌，也防止它太过去清闲。
通过 设置channel.basicQos(1);

 

 

服务器能力不同，能者多劳。 均摊模式的话，都处理相同数量的

 消息队列 发出去的消息被消费完了 然后收到 ack包 才可以继续发给他

 公平队列原理：队列服务器向消费者发送消息的时候，消费者采用手动应答模式，队列服务器必须要收到消费者发送ack结果通知，才会发送下一个消息。（快的处理的多，消费的多）

producer：

package com.toov5.Producer;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.toov5.utils.MQConnectionUtils;

public class Producer {
    // 队列名称
    private static final String UEUE_NAME = "test_queue";

    public static void main(String[] args) throws IOException, TimeoutException {
        // 创建新的连接
        Connection connection = MQConnectionUtils.newConnection();
        // 创建Channel
        Channel channel = connection.createChannel();
        // 创建队列
        channel.queueDeclare(UEUE_NAME, false, false, false, null);
        channel.basicQos(1); // 保证 取一个消费  队列给消费者发送消息时候 一个消息
        for (int i = 0; i < 10; i++) {
            // 创建message
            String msg = "toov5_message";
            System.out.println("生产者投递消息" + msg + i);
            // 生产者发送消息
            channel.basicPublish("", UEUE_NAME, null, msg.getBytes());
        }
        // 关闭通道和连接
        channel.close();
        connection.close();

    }
}

 

Consumer1

package com.toov5.Consumer;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

import com.rabbitmq.client.AMQP.BasicProperties;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.DefaultConsumer;
import com.rabbitmq.client.Envelope;
import com.toov5.utils.MQConnectionUtils;

public class Consumer1 {
  
     //队列名称
        private static final String QUEUE_NAME = "test_queue";
        
        public static void main(String[] args) throws IOException, TimeoutException {
            System.out.println("消费者启动..........1");
            //创建新的连接
        Connection connection = MQConnectionUtils.newConnection();
           //创建Channel
            final Channel channel = connection.createChannel();
            // 消费者关联队列
             channel.queueDeclare(QUEUE_NAME, false, false, false, null);
             channel.basicQos(1);
              DefaultConsumer defaultConsumerr = new DefaultConsumer(channel) {
                  //监听获取消息
                    @Override
                    public void handleDelivery(String consumerTag, Envelope envelope, BasicProperties properties,
                            byte[] body) throws IOException {
                        String msg =new String(body,"UTF-8");
                        System.out.println("消费者获取生产者消息："+msg);
                        try {
                            //模拟应答等待时间
                            Thread.sleep(1000);
                        } catch (Exception e) {
                            
                        }finally {
                           channel.basicAck(envelope.getDeliveryTag(), false);  //手动应答 告诉消息队列服务器 消费成功
                        }
                    }
              };
            //牵手模式设置  默认自动应答模式  true:自动应答模式  
              channel.basicConsume(QUEUE_NAME, false, defaultConsumerr);//    fanse手动应答          

        }
}

 

Consumer2

package com.toov5.Consumer;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

import com.rabbitmq.client.AMQP.BasicProperties;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.DefaultConsumer;
import com.rabbitmq.client.Envelope;
import com.toov5.utils.MQConnectionUtils;

public class Consumer2 {
  
     //队列名称
        private static final String QUEUE_NAME = "test_queue";
        
        public static void main(String[] args) throws IOException, TimeoutException {
            System.out.println("消费者启动..........2");
            //创建新的连接
        Connection connection = MQConnectionUtils.newConnection();
           //创建Channel
            final Channel channel = connection.createChannel();
            // 消费者关联队列
             channel.queueDeclare(QUEUE_NAME, false, false, false, null);
              channel.basicQos(1);
              DefaultConsumer defaultConsumerr = new DefaultConsumer(channel) {
                  //监听获取消息
                    @Override
                    public void handleDelivery(String consumerTag, Envelope envelope, BasicProperties properties,
                            byte[] body) throws IOException {
                        String msg =new String(body,"UTF-8");
                        System.out.println("消费者获取生产者消息："+msg);
                        try {
                            //模拟应答等待时间
                            Thread.sleep(300);
                        } catch (Exception e) {
                            
                        }finally {
                        channel.basicAck(envelope.getDeliveryTag(), false);  //手动应答 告诉消息队列服务器 消费成功
                        }
                    }
              };
            //牵手模式设置  默认自动应答模式  true:自动应答模式  
              channel.basicConsume(QUEUE_NAME, false, defaultConsumerr);//    fanse手动应答          
        }
}

运行结果：

睡眠少的（执行快的） 指定的多

 注意 每个消费者 必须要应答 一下！ 队列服务器没有收到应答 就不会发送下一个给消费者~

 

转载于:https://www.cnblogs.com/toov5/p/9940566.html

一篇文章带你看懂RabbitMQ的高级应用
wdj_yyds的博客
05-05 2159
RabbitMQ高级应用 1、消息可靠性投递  在使用 RabbitMQ 的时候，生产者在进行消息投递的时候如果想知道消息是否成功的投递到对应的交换机和队列中，有两种方式可以用来控制消息投递的可靠性模式 。  由上图的整个消息的投递过程来看，生产者的消息进入到中间件中会首先到达交换机，然后再从交换机传递到队列中去，也就是分为两步走战略。那么消息的丢失情况也就是会出现在这两个阶段中，RabbitMQ 贴心的为我们提供了针对于这两个部分的可靠新传递模式： confirm 模式。 return.
RabbitMQ 高级功能
Casual_Lei的博客
07-11 1841
RabbitMQ 是一个广泛使用的开源消息代理，它支持多种消息传递协议，可以在分布式系统中用于可靠的消息传递。除了基本的消息队列功能外，RabbitMQ 还提供了一些高级功能，增强了其在高可用性、扩展性和灵活性方面的能力。
【RabbitMQ】应用
最新发布
bit me的博客
08-28 1654
七种工作模式以及springboot整合
RebbitMQ 消息队列（高级应用）
wangjunlei666的博客
02-25 598
其中自动确认是指，消息一旦被consumer接收，则自动确认收到，并将相应message从rabbitmq的消息缓存中移除，但在实际业务中，很可能消息收到了，但是业务出现了异常，那么该消息就会丢失，如果设置了手动去人方式，则需要在业务成功处理后，调用channel.basicAck（）方法，手动签收，让其重新发送消息。消息可靠性投递，consumer ACK，消费端限流，TTL，死信队列，延迟队列，日志与监控，消息可靠性与追踪，管理。ack指acknowledge，确认，表示消费端收到消息后的确认方式。
RabbitMQ入门到实战——高级篇
weixin_51005207的博客
01-11 1230
交换机、队列、发送的信息持久化使⽤LazyQueue（⾃动将所有消息持久化）投递给异常交换机，需要实现 RepublishMessageRecoverer。
RabbitMQ高级应用（三）消费端限流策略（basicQos）
孔明的博客
03-14 8490
高并发情况下，队列里面一瞬间就就积累了上万条数据，但是消费者无法同时处理这么多请求，这个时候当我们打开客户端，瞬间就有巨量的信息给推送过来、但是客户端是没有办法同时处理这么多数据的，结果就是消费者（客户端）挂掉了.... 这种场景下我们就需要对消费端进行限流 关键代码：channel.basicQos();
RabbitMQ高级篇
weixin_48103117的博客
10-14 1565
RabbitMQ快速进阶高级篇
RabbitMQ高级使用
weixin_49211575的博客
11-26 509
如何保证Rabbitmq不丢失消息的6大步【精通】 使用confirm来保障发送消息不丢 使用return来保障没有找到队列的消息不丢失 使用ack来保障消息的消费不丢失 exchanger、queue、消息都要设置持久化 要搭建高可用的服务器集群，保障消息有备份 使用死信队列来处理丢弃的消息 在如何使用Confirm发送消息? 开启confirm publisher-confirms=“true” <!-- 定义rabbitmq connectionFactory -->
Rabbitmq之高级特性——百分百投递消息&消息确认模式&消息返回模式实现
zuixiaoyao_001的博客
09-08 3801
　　rabbitmq的高级特性： 　　如何保障消息的百分之百成功？ 　　要满足4个条件：生产方发送出去，消费方接受到消息，发送方接收到消费者的确认信息，完善的消费补偿机制 　　解决方案，1）消息落库，进行消息状态打标 　　该解决方案需要对对数据库进行两次io操作，如果数据量很大，将会导致瓶颈的发生，本流程是首先将业务入库，发送消息前，将发送的消息入库消息状态可设置为0，两次写入数据库后...
RocketMQ源码分析 -- 顺序消费 (顺序消息)
cliuyang的专栏
10-22 533
目的： 从源码角度解读RocketMQ 是如何保证消息顺序消费的 RocketMQ 生产者 ---broker---消费者之间的关系如下图 如何保证消息有序，我们从两个方面解读： 一首先要保证消息发送方首先要保证发送消息有序，其次消费方要保证消费消息的顺序性 消息生产这保证消息有序 消息消费者保证消息有序 ConsumeMessageOrderlyService ...
RabbitMQ的高级使用
m0_57084845的博客
10-25 212
多个消费者绑定到一个队列，可以加快消息处理速度同一条消息只会被一个消费者处理。
RabbitMQ高级特性
BushRo
03-06 992
Confirm确认消息 Confirm消息确认机制：了消息的确认，是指生产者投递消息后，如果Broker收到消息，则会给我们生产者一个应答。生产者进行接收应答，用来确定这条消息是否正常的发送到Broker，这种方式也是消息的可靠性投递的核心保障！ 1.在channel上开启确认模式：channel.confirmselect() 2.在channel上添加监听：addC...
RabbitMQ的高级用法
shuyoujing的博客
08-09 833
RabbitMQ高级特性 消息可靠性投递 在使用RabbitMQ的时候,作为消息发送方希望杜绝任何消息都市,或者投递失败的场景,RabbitMQ为我么提供了两种方式来控制投递可靠性模式 confirm 确认模式 return 返回模式 RabbitMQ消息投递的路径是: producer —> rabbitmq boker —> queue —>consumer 消息从Producer到Exchange则返回一个ConfirmCallBack 消息从Exchange—>Qu
RabbitMQ高级操作
xiao_count的博客
11-09 172
./rabbitmqctl reset 移除所有数据，要在./rabbitmqctl stop后使用 ./rabbitmqctl join_cluster <clusternode> [--ram] 组成集群命令（ram内存级别） ./rabbitmqctl cluster_status 查看集群状态 ./rabbitmqctl change_cluster_node_type dis...
rabbitmq——高级特性
小智的博客
09-29 3212
rabbitmq,高级特性 目录 rabbitmq,高级特性 1.消息如何保障100% 的投递成功？        1.1 自定义消费者    1.2 消息的ack与重回队列    1.3 消息的限流    1.4 TTL消息    1.5 死信队列 2.幂等性概念详解 消费端，幂等性保障； （1）唯一id +  指纹码 机制， 利用数据库主键去重；  (2) 利用redis 的原...
RabbitMQ 高级篇 | 黑马
weixin_54232666的博客
04-12 985
RabbitMQ高级篇，包括消息可靠性投递和确认、限流、TTL、死信队列、延迟队列、优先级队列、惰性队列，这一篇就够了！
RabbitMQ的使用教程—高级篇
shi_AXing_a的博客
04-25 993
RabbitMQ的使用教程—高级篇一、死信队列二、延迟队列三、消息幂等性保障四、RabbitMQ集群1、普通集群2、镜像集群五、HaProxy负载均衡rabbitMQ集群 一、死信队列 1、什么是死信？ 简单来说，死信就是无法被消费的消息。 一般来说，生产者product将消息投递到broke获取消息队列queue中了，消费者consumer从消息队列取出消息进行消费，但是由于某些原因导致消息队列中的某些消息无法被消费，假如这些无法被消费的消息一直没有被处理，就会变成死信。 有死信，自然就有死信队列。 2、
深入探究RabbitMQ的高级特性及其应用
资源摘要信息: "RabbitMQ是一个流行的开源消息代理软件，它实现了高级消息队列协议（AMQP），并且通过插件可以支持其他消息协议，如MQTT。RabbitMQ主要用于在分布式系统中进行异步消息传递，具有高可用性、灵活的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值