RabbitMQ开发手册

合集下载

Rabbitmq基本API使用

Rabbitmq基本API使⽤⼀、⽣产者1. 创建ConnectionFactory⼯⼚（地址、⽤户名、密码、vhost）2. 创建Connection3. 创建信道（Channel）4. 创建 exchange（指定名称、类型-DIRECT("direct"), FANOUT("fanout"), TOPIC("topic"), HEADERS("headers");、是否持久化）5. 发送消息（指定：exchange、发送的routingKey ，发送到的消息）基础的⽣产者：public class TestProducer {public final static String EXCHANGE_NAME = "direct_logs";public static void main(String[] args)throws IOException, TimeoutException {/* 创建连接,连接到RabbitMQ*/ConnectionFactory connectionFactory = new ConnectionFactory();connectionFactory.setHost("192.168.112.131");connectionFactory.setVirtualHost("my_vhost");connectionFactory.setUsername("admin");connectionFactory.setPassword("admin");Connection connection = connectionFactory.newConnection();/*创建信道*/Channel channel = connection.createChannel();/*创建交换器*/channel.exchangeDeclare(EXCHANGE_NAME,"direct");//channel.exchangeDeclare(EXCHANGE_NAME,BuiltinExchangeType.DIRECT);/*⽇志消息级别，作为路由键使⽤*/String[] routekeys = {"king","queue","prince"};for(int i=0;i<3;i++){String routekey = routekeys[i%3];String msg = "Hellol,RabbitMq"+(i+1);/*发布消息，需要参数：交换器，路由键，其中以⽇志消息级别为路由键*/channel.basicPublish(EXCHANGE_NAME,routekey,null,msg.getBytes());System.out.println("Sent "+routekey+":"+msg);}channel.close();connection.close();}}View Code⼆、消费者1. 创建ConnectionFactory⼯⼚（地址、⽤户名、密码、vhost）2. 创建Connection3. 创建信道（Channel）4. 声明⼀个 exchange（指定名称、类型、是否持久化）5. 创建⼀个队列（指定：名称，是否持久化，是否独占，是否⾃动删除，其他参数）6. 队列、exchange通过routeKey进⾏绑定7. 消费者接收消息（队列名称，是否⾃动ACK）基本的消费者：public class TestConsumer {public static void main(String[] argv)throws IOException, TimeoutException {ConnectionFactory factory = new ConnectionFactory();factory.setHost("192.168.112.131");factory.setVirtualHost("my_vhost");factory.setUsername("admin");factory.setPassword("admin");// 打开连接和创建频道，与发送端⼀样Connection connection = factory.newConnection();final Channel channel = connection.createChannel();channel.exchangeDeclare(TestProducer.EXCHANGE_NAME,"direct");/*声明⼀个队列*/String queueName = "focuserror";channel.queueDeclare(queueName,false,false,false,null);/*绑定，将队列和交换器通过路由键进⾏绑定*/String routekey = "king";/*表⽰只关注error级别的⽇志消息*/channel.queueBind(queueName,TestProducer.EXCHANGE_NAME,routekey);System.out.println("waiting for message........");/*声明了⼀个消费者*/final Consumer consumer = new DefaultConsumer(channel){@Overridepublic void handleDelivery(String consumerTag,Envelope envelope,AMQP.BasicProperties properties,byte[] body) throws IOException {String message = new String(body, "UTF-8");System.out.println("Received["+envelope.getRoutingKey()+"]"+message);}};/*消费者正式开始在指定队列上消费消息*/channel.basicConsume(queueName,true,consumer);}}View Code三、消息持久化1. exchange 需要持久化2. 发送消息设置参数为 MessageProperties.PERSISTENT_TEXT_PLAIN3. 队列需要设置参数为持久化1、//TODO 创建持久化交换器 durable=truechannel.exchangeDeclare(EXCHANGE_NAME,"direct",true);2、//TODO 发布持久化的消息(delivery-mode=2)channel.basicPublish(EXCHANGE_NAME,routekey,MessageProperties.PERSISTENT_TEXT_PLAIN,msg.getBytes());3、//TODO 声明⼀个持久化队列(durable=true)// autoDelete=true 消费者停⽌了，则队列会⾃动删除//exclusive=true独占队列，只能有⼀个消费者消费String queueName = "msgdurable";channel.queueDeclare(queueName,true,false,false,null);四、如何⽀持事务（防⽌投递消息的时候消息丢失-效率特别低，不建议使⽤，可以使⽤⽣产者ACK机制）1. 启动事务2. 成功提交3. 失败则回滚//TODO//加⼊事务channel.txSelect();try {for(int i=0;i<3;i++){String routekey = routekeys[i%3];// 发送的消息String message = "Hello World_"+(i+1)+("_"+System.currentTimeMillis());channel.basicPublish(EXCHANGE_NAME, routekey, true,null, message.getBytes());System.out.println("----------------------------------");System.out.println(" Sent Message: [" + routekey +"]:'"+ message + "'");Thread.sleep(200);}//TODO//事务提交channel.txCommit();} catch (IOException e) {e.printStackTrace();//TODO//事务回滚channel.txRollback();} catch (InterruptedException e) {e.printStackTrace();}View Code五、消费消息⼿动ACK，如果异常则使⽤拒绝的⽅式，然后异常消息推送到-死信队列批量ack的时候如果其中有⼀个消息出现异常，则会导致消息丢失（⽇志处理的时候可以使⽤批量）1 /*消费者正式开始在指定队列上消费消息，第⼆个参数false为⼿动应答*/channel.basicConsume(queueName,false,consumer);2 收到消息以后，⼿动应答数据接收成功channel.basicAck(envelope.getDeliveryTag(),false);3 收到消息，如果处理失败则拒绝消息：DeliveryTag是消息在队列中的标识channel.basicReject(envelope.getDeliveryTag(),false);4 决绝的参数说明//TODO Reject⽅式拒绝(这⾥第2个参数决定是否重新投递),不要重复投递，因为消息重复投递后处理可能依然异常//channel.basicReject(envelope.getDeliveryTag(),false);//TODO Nack⽅式的拒绝（第2个参数决定是否批量,第3个参数是否重新投递）channel.basicNack(envelope.getDeliveryTag(), false, true);View Code六、创建队列的参数解析：场景，延迟队列，保存带有时效性的订单，⼀旦订单过期，则信息会转移到死信队列//TODO /*⾃动过期队列--参数需要Map传递*/String queueName = "setQueue";Map<String, Object> arguments = new HashMap<String, Object>();arguments.put("x-expires",10*1000);//消息在队列中保存10秒后被删除//TODO 队列的各种参数/*加⼊队列的各种参数*/// autoDelete=true 消费者停⽌了，则队列会⾃动删除//exclusive=true独占队列，只能有⼀个消费者消费channel.queueDeclare(queueName,true,true, false,arguments);七、发送消息以后带有应答的队列1. 声明⼀个回应队列2. 声明⼀个回应消息的消费者3. 声明⼀个属性对象（指定队列，会唯⼀的id）4. ⽣产者发送消息给消费者（带着回应队列）5. 消费者接收到消息以后根据对应的信息，给予回应⽣产者端：1、//TODO 响应QueueName ，消费者将会把要返回的信息发送到该QueueString responseQueue = channel.queueDeclare().getQueue();//TODO 消息的唯⼀idString msgId = UUID.randomUUID().toString();2、/*声明了⼀个消费者*/final Consumer consumer = new DefaultConsumer(channel){@Overridepublic void handleDelivery(String consumerTag,Envelope envelope,AMQP.BasicProperties properties,byte[] body) throws IOException {String message = new String(body, "UTF-8");System.out.println("Received["+envelope.getRoutingKey()+"]"+message);}};//TODO 消费者应答队列上的消息channel.basicConsume(responseQueue,true,consumer);3、//TODO 设置消息中的应答属性AMQP.BasicProperties properties = new AMQP.BasicProperties.Builder().replyTo(responseQueue).messageId(msgId).build();4、String msg = "Hello,RabbitMq";//TODO 发送消息时，把响应相关属性设置进去channel.basicPublish(EXCHANGE_NAME,"error",properties,msg.getBytes());View Code消费者端：String message = new String(body, "UTF-8");System.out.println("Received["+envelope.getRoutingKey()+"]"+message);//TODO 从消息中拿到相关属性（确定要应答的消息ID,）AMQP.BasicProperties respProp= new AMQP.BasicProperties.Builder().replyTo(properties.getReplyTo()).correlationId(properties.getMessageId()).build();//TODO 消息消费时，同时需要⽣作为⽣产者⽣产消息（以OK为标识）channel.basicPublish("", respProp.getReplyTo() ,respProp ,("OK,"+message).getBytes("UTF-8"));⼋、死信队列 - 下列消息会放到死信队列1. 消息被否定确认，使⽤ channel.basicNack 或 channel.basicReject ，并且此时requeue 属性被设置为false。

rabbitmq+学习手册

Redhat、iMatix 等联合制定了 AMQP 的公开标准。 Introduction: RabbitMQ is a complete and highly reliable enterprise messaging system based on the emerging AMQP
standard. It is licensed under the open source Mozilla Public License and has a platform-neutral distribution, plus platform-specific packages and bundles for easy installation.
rabbitmq 学习-1-AMQP介绍
本文档来自网上.[ 看否网正使用rabbitmq做爬虫队列,欢迎大家交流q
AMQP，即Advanced Message Queuing Protocol，高级消息队列协议，是应用层协议的一个开放标准，为面向消息的中间件设计。
若下载的是rabbitmq-server-generic-unix-1.7.2.tar.gz，可以直接解压，像windows上一样启动，然后使用即可
rabbitmq 学习-3-初试1
本例是一个简单的异步发送消息实例 1，发送端 @Test(groups = { "sunjun" }) public class RabbitmqTest {
rabbitmq 学习-2-安装
Windows 1，下载下载erlang：下载rabbitmq：/download.html 2，安装先安装erlang，C:\Program Files\erl5.7.5 设置环境变量：ERLANG_HOME=C:\Program Files\erl5.7.5 解压rabbitmq，进入dos下， >cd C:\rabbitmq_server-1.7.2\sbin >rabbitmq-service install 3，启动 >cd C:\rabbitmq_server-1.7.2\sbin >rabbitmq-service start 或都直接双击C:\rabbitmq_server-1.7.2\sbin\rabbitmq-service.bat Linux 1，下载erlang for linux版本，安装

RabbitMQ入门教程（PHP版）使用rabbitmq-delayed-message-。。。

RabbitMQ⼊门教程（PHP版）使⽤rabbitmq-delayed-message-。

延迟任务应⽤场景场景⼀：物联⽹系统经常会遇到向终端下发命令，如果命令⼀段时间没有应答，就需要设置成超时。

场景⼆：订单下单之后30分钟后，如果⽤户没有付钱，则系统⾃动取消订单。

场景三：过1分钟给新注册会员的⽤户，发送注册邮件等。

php 使⽤rabbitmq-delayed-message-exchange插件实现延迟功能1.安装下载后解压，并将其拷贝⾄(使⽤Linux Debian/RPM部署)rabbitmq服务器⽬录：/usr/local/rabbitmq/plugins中（ windows安装⽬录\rabbitmq_server-version\plugins ）.2.启⽤插件使⽤命令rabbitmq-plugins enable rabbitmq_delayed_message_exchang启⽤插件rabbitmq-plugins enable rabbitmq_delayed_message_exchang输出如下：The following plugins have been enabled:rabbitmq_delayed_message_exchange通过rabbitmq-plugins list查看已安装列表,如下：...[ ] rabbitmq_delayed_message_exchange 20171215-3.6.x...3.机制解释安装插件后会⽣成新的Exchange类型x-delayed-message，该类型消息⽀持延迟投递机制,接收到消息后并未⽴即将消息投递⾄⽬标队列中，⽽是存储在mnesia(⼀个分布式数据系统)表中，检测消息延迟时间，如达到可投递时间时并将其通过x-delayed-type类型标记的交换机类型投递⾄⽬标队列。

4.php实现过程消费者 delay_consumer2.php:<?php//header('Content-Type:text/html;charset=utf8;');$params = array('exchangeName' => 'delayed_exchange_test','queueName' => 'delayed_queue_test','routeKey' => 'delayed_route_test',);$connectConfig = array('host' => 'localhost','port' => 5672,'login' => 'guest','password' => 'guest','vhost' => '/');//var_dump(extension_loaded('amqp'));//exit();try {$conn = new AMQPConnection($connectConfig);$conn->connect();if (!$conn->isConnected()) {//die('Conexiune esuata');//TODO 记录⽇志echo 'rabbit-mq 连接错误:', json_encode($connectConfig);exit();}$channel = new AMQPChannel($conn);if (!$channel->isConnected()) {// die('Connection through channel failed');//TODO 记录⽇志echo 'rabbit-mq Connection through channel failed:', json_encode($connectConfig);exit();}$exchange = new AMQPExchange($channel);//$exchange->setFlags(AMQP_DURABLE);//声明⼀个已存在的交换器的，如果不存在将抛出异常，这个⼀般⽤在consume端$exchange->setName($params['exchangeName']);$exchange->setType('x-delayed-message'); //x-delayed-message类型/*RabbitMQ常⽤的Exchange Type有三种：fanout、direct、topic。

rabbitmq 使用手册

rabbitmq 使用手册RabbitMQ 是一个开源的消息代理软件，它实现了高效的消息传递机制，可以在分布式系统中进行消息的发布和订阅。

下面是 RabbitMQ 的使用手册的详细精确说明：1. 安装 RabbitMQ：首先，你需要下载并安装 RabbitMQ。

你可以从RabbitMQ 官方网站上下载适合你操作系统的安装包，并按照官方文档中的说明进行安装。

2. 启动 RabbitMQ 服务器：安装完成后，你可以启动 RabbitMQ 服务器。

在大多数操作系统中，你可以通过命令行执行以下命令来启动RabbitMQ：```rabbitmq-server```如果一切正常，你将会看到 RabbitMQ 服务器成功启动的日志信息。

3. 创建和管理队列：RabbitMQ 使用队列来存储消息。

你可以使用 RabbitMQ 的管理界面或者命令行工具来创建和管理队列。

以下是一些常用的队列操作命令：- 创建队列：```rabbitmqadmin declare queue name=<queue_name>```- 查看队列列表：```rabbitmqadmin list queues```- 删除队列：```rabbitmqadmin delete queue name=<queue_name>```4. 发布和消费消息：使用 RabbitMQ，你可以将消息发布到队列中，并从队列中消费消息。

以下是一些常用的消息操作命令：- 发布消息：```rabbitmqadmin publish routing_key=<routing_key>payload=<message>```- 消费消息：```rabbitmqadmin get queue=<queue_name>```- 确认消息已被消费：```rabbitmqadmin ack delivery_tag=<delivery_tag> ```5. 设置消息交换机和绑定：RabbitMQ 使用消息交换机来将消息路由到队列。

RabbitMQ-最完整最全教程

RabbitMQ-Day1学习目标1. 消息队列介绍2. 安装RabbitMQ3. 编写RabbitMQ的入门程序4. RabbitMQ的5种模式讲解5. SpringBoot整合RabbitMQ1消息队列概述1.1消息队列MQMQ全称为Message Queue，消息队列是应用程序和应用程序之间的通信方法。

为什么使用MQ？在项目中，可将一些无需即时返回且耗时的操作提取出来，进行异步处理，而这种异步处理的方式大大的节省了服务器的请求响应时间，从而提高了系统的吞吐量。

开发中消息队列通常有如下应用场景：1.2AMQP 和JMSMQ是消息通信的模型；实现MQ的大致有两种主流方式：AMQP、JMS。

1.2.1AMQPAMQP高级消息队列协议，是一个进程间传递异步消息的网络协议，更准确的说是一种binary wire-level protocol（链接协议）。

这是其和JMS的本质差别，AMQP不从API层进行限定，而是直接定义网络交换的数据格式。

1.2.2JMSJMS即Java消息服务（JavaMessage Service）应用程序接口，是一个Java平台中关于面向消息中间件（MOM）的API，用于在两个应用程序之间，或分布式系统中发送消息，进行异步通信。

1.2.3AMQP 与JMS 区别JMS是定义了统一的接口，来对消息操作进行统一；AMQP是通过规定协议来统一数据交互的格式JMS限定了必须使用Java语言；AMQP只是协议，不规定实现方式，因此是跨语言的。

JMS规定了两种消息模式；而AMQP的消息模式更加丰富1.3消息队列产品目前市面上成熟主流的MQ有Kafka 、RocketMQ、RabbitMQ，我们这里对每款MQ做一个简单介绍。

1.4RabbitMQ介绍RabbitMQ是由erlang语言开发，基于AMQP（Advanced Message Queue 高级消息队列协议）协议实现的消息队列，它是一种应用程序之间的通信方法，消息队列在分布式系统开发中应用非常广泛。

rabbitmq的使用方法

rabbitmq的使用方法RabbitMQ是一个开源的消息代理软件，用于实现异步消息传递。

以下是使用RabbitMQ的一些基本方法：1. 安装和配置：首先，你需要从RabbitMQ的官网下载并安装RabbitMQ 服务器。

安装完成后，你可以通过浏览器访问RabbitMQ的管理界面，进行基本的配置。

2. 创建队列：在RabbitMQ中，消息被存储在队列中。

你可以使用RabbitMQ的管理界面或者通过编程的方式创建队列。

例如，使用Python 的pika库，你可以这样创建一个队列：```pythonimport pikaconnection = (('localhost'))channel = ()_declare(queue='hello')()```3. 发送消息：一旦你创建了队列，你就可以开始发送消息到这个队列。

同样使用pika库，你可以这样发送消息：```pythonimport pikaconnection = (('localhost'))channel = ()_publish(exchange='', routing_key='hello', body='Hello World!') ()```4. 接收消息：要接收消息，你需要创建一个消费者来从队列中获取消息。

消费者可以是任何能够处理RabbitMQ消息的应用程序。

例如，你可以创建一个Python消费者来接收消息：```pythonimport pikaconnection = (('localhost'))channel = ()_declare(queue='hello')def callback(ch, method, properties, body):print(f" [x] Received {body}")_consume(queue='hello', on_message_callback=callback,auto_ack=True)print(' [] Waiting for messages. To exit press CTRL+C')_consuming()```5. 确认消息处理：在RabbitMQ中，你可以选择自动确认（auto_ack）或手动确认（manual_ack）消息处理。

rabbitmq使用手册

rabbitmq使用手册RabbitMQ是一种开源的消息队列中间件，采用AMQP协议，被广泛应用于构建可靠、高效的分布式系统。

本手册将详细介绍RabbitMQ 的安装、配置、使用和常见问题解决方案，帮助读者快速上手使用RabbitMQ。

第一章安装与配置1.1 环境准备在开始安装RabbitMQ之前，需要确保系统满足以下要求：操作系统（例如Linux、Windows）、Erlang运行时环境以及RabbitMQ软件包。

1.2 安装RabbitMQ按照文档提供的方式，在所选的操作系统上安装RabbitMQ。

安装过程中需注意版本兼容性和安全配置。

1.3 配置RabbitMQ在安装完成后，需要对RabbitMQ进行适当的配置。

主要包括网络配置、认证与授权、虚拟主机、交换机和队列的创建等。

第二章消息发布与订阅2.1 消息生产者通过使用RabbitMQ的API，开发者可以编写生产者代码将消息发布到RabbitMQ的交换机上。

这里需要注意消息的序列化和指定交换机名称。

2.2 消息消费者RabbitMQ的消费者通过订阅交换机的队列来接收消息，可以使用RabbitMQ的API编写消费者代码，并实现消息的处理逻辑。

2.3 消息确认机制RabbitMQ提供了消息的确认机制，确保消息在传输过程中的可靠性。

开发者可以选择隐式确认或显式确认来保证消息的消费状态。

第三章消息路由与过滤3.1 路由模式RabbitMQ支持多种路由模式，如直接路由、主题路由和广播路由。

开发者可以根据实际需求选择最适合的路由模式。

3.2 消息过滤通过使用RabbitMQ的消息过滤功能，可以根据消息的属性进行过滤，只有满足条件的消息才会被消费者接收。

第四章高级特性与扩展4.1 持久化使用RabbitMQ的持久化机制，可以确保消息在服务器重启后依然存在，防止消息丢失。

4.2 集群与高可用通过搭建RabbitMQ集群，可以提高系统的可用性和扩展性。

在集群中，消息将自动在节点之间进行复制。

RabbitMQ消息服务用户手册(1)

RabbitMQ消息服务用户手册1架构设计1.1服务架构概述架构：RabbitMQ Cluster + Queue HA + Haproxy + Keepalived解释：3台rabbitMQ服务器构建broker集群，允许任意2台服务器故障而服务不受影响，在此基础上，通过Queue HA （queue mirror）实现队列的高可用，在本例中镜像到所有服务器节点（即1个master，2个slave）；为保证客户端访问入口地址的唯一性，通过haproxy做4层代理来提供MQ服务，并通过简单的轮询方式来进行负载均衡，设置健康检查来屏蔽故障节点对客户端的影响；使用2台haproxy并且通过keepalived实现客户端访问入口的高可用机制。

1.2服务架构设计1.3服务节点分配1.4官方文档手册集群配置文档：/clustering.html镜像队列文档：/ha.html集群操作文档：/man/rabbitmqctl.1.man.html中文版AMQP用户手册：Spring AMQP文档：/qbna350816/category/55056.html?Show=All 事务文档：/qbna350816/archive/2016/08/13/431567.html2 集群搭建2.1 集群节点安装1、安装依赖包PS:安装rabbitmq 所需要的依赖包2、下载安装包3、安装服务命令4、修改集群用户与连接心跳检测5、安装管理插件6、服务指令2.2 文件同步步骤PS:选择71、72、73任意一个节点为Master （这里选择71为Master ），也就是说我们需要把71的Cookie 文件同步到72、73节点上去，进入/var/lib/rabbitmq 目录下，把/var/lib/rabbitmq/.erlang.cookie 文件的权限修改为777，原来是400；然后把.erlang.cookie 文件copy 到各个节点下；最后把所有cookie 文件权限还原为400即可。

c++ crabbitmqclient实例

C++ RabbitMQ Client 实例一、简介RabbitMQ 是一个在 AMQP 协议基础上完成的开源消息代理软件。

C++ RabbitMQ Client 是一个封装了 RabbitMQ C 语言客户端库的C++ 库，它提供了 C++ 风格的 API，方便 C++ 开发者使用RabbitMQ。

二、安装1. 下载 RabbitMQ C 语言客户端库需要下载 RabbitMQ C 语言客户端库，可以从 RabbitMQ 冠方全球信息站或 GitHub 上获取。

2. 安装 RabbitMQ C 语言客户端库解压下载的压缩包，并按照其中的文档进行编译和安装。

3. 下载 C++ RabbitMQ ClientC++ RabbitMQ Client 源码可以从 GitHub 上获取。

4. 安装 C++ RabbitMQ Client将 C++ RabbitMQ Client 源码解压后，按照其中的文档进行编译和安装。

三、示例代码以下是一个简单的使用 C++ RabbitMQ Client 发送和接收消息的示例代码：```cpp#include <SimpleAmqpClient/SimpleAmqpClient.h>int m本人n(){// 连接 RabbitMQAmqpClient::Channel::ptr_t connection = AmqpClient::Channel::Create("localhost");// 定义一个 exchangeconst std::string exchange_name = "exchange_name"; connection->DeclareExchange(exchange_name, AmqpClient::Channel::EXCHANGE_TYPE_DIRECT);// 定义一个 queueconst std::string queue_name = "queue_name";connection->DeclareQueue(queue_name);connection->BindQueue(queue_name, exchange_name, "routing_key");// 发送消息const std::string message = "Hello, RabbitMQ!";connection->BasicPublish(exchange_name, "routing_key", AmqpClient::BasicMessage::Create(message));// 接收消息std::string consumer_tag = connection->BasicConsume(queue_name, "");AmqpClient::Envelope::ptr_t envelope;if (connection->BasicConsumeMessage(consumer_tag, envelope)){std::string received_message = envelope->Message()->Body();std::cout << "Received message: " << received_message << std::endl;}// 关闭连接connection->Close();return 0;}```四、运行示例代码1. 编译示例代码使用 C++ 编译器编译上述示例代码。

rabbitmq使用手册

RabbitMQ使用手册一、简介RabbitMQ是一个开源的消息代理软件，它实现了AMQP（高级消息队列协议）。

RabbitMQ可以在分布式系统中可靠地传递消息，并提供了多种消息传递模式。

通过使用RabbitMQ，应用程序可以解耦和简化其组件之间的通信。

二、安装与配置RabbitMQ可以通过包管理器（如APT或YUM）或直接从源代码进行安装。

安装完成后，您需要配置RabbitMQ服务器，包括设置用户、创建虚拟主机和配置交换机等。

三、生产者与消费者在RabbitMQ中，生产者负责创建并发送消息，而消费者负责接收和处理这些消息。

生产者需要先连接到RabbitMQ服务器，然后创建一个通道，并使用该通道发送消息到一个队列中。

消费者也需要连接到服务器，创建一个通道，然后从队列中接收消息。

四、消息路由RabbitMQ通过交换机和队列来实现消息路由。

交换机负责接收生产者发送的消息，并根据绑定的队列将消息转发给它们。

队列是存储消息的地方，消费者可以从队列中获取并处理消息。

五、可靠性RabbitMQ提供了多种可靠性机制，以确保消息在传输过程中不会丢失或重复。

例如，您可以使用持久化队列和交换机来确保即使在服务器重启后，消息也不会丢失。

此外，您还可以使用确认机制来确保消息被成功处理。

六、插件与扩展RabbitMQ提供了许多插件和扩展，以支持更多的功能和协议。

例如，您可以使用RabbitMQ的插件来支持延迟消息、主题交换、集群等。

此外，还有一些第三方插件可以与RabbitMQ集成，以支持其他协议和功能。

七、监控与管理RabbitMQ提供了丰富的监控和管理工具，以帮助您了解系统的运行状况和性能。

您可以使用RabbitMQ的管理插件来查看队列的统计信息、监视内存使用情况、查看日志等。

此外，您还可以使用第三方工具来进一步扩展监控和管理功能。

rabbitmq系统使用教程

rabbitmq系统使用教程RabbitMQ是使用Erlang语言开发的开源消息队列系统，基于AMQP协议来实现。

AMQP的主要特征是面向消息、队列、路由(包括点对点和发布)、可靠性、安全。

AMQP协议更多用在企业系统内，对数据一致性、稳定性和可靠性要求很高的场景，对性能和吞吐量的要求还在其次。

MQ全称为Message Queue, 消息队列(MQ)是一种应用程序对应用程序的通信方法。

应用程序通过读写出入队列的消息(针对应用程序的数据)来通信，而无需专用连接来链接它们。

消息传递指的是程序之间通过在消息中发送数据进行通信，而不是通过直接调用彼此来通信，直接调用通常是用于诸如远程过程调用的技术。

排队指的是应用程序通过队列来通信。

队列的使用除去了接收和发送应用程序同时执行的要求。

解耦当发送短信执行成功后页面才执行倒计时60秒，假如在发送短信时网速原因，导致短信一直被阻塞，那么倒计时也会被一直延迟，这样及其影响用户体验感。

这时候就可以使用RabbitMQ了，将发送短信和倒计时解耦，基于消息的模型，关心的是“通知”，而非“处理”。

像下订单、邮件通知、缓存刷新等操作都可以使用消息队列进行优化。

异步提升效率场景说明：用户需发送短信验证码时，点击发送短信，第三方平台发送短信至用户手机成功，执行倒计时60秒。

传统的做法有两种 1.串行的方式;2.并行方式：(1) 串行方式：将用户点击发送短信，第三方平台发送短信至用户手机成功，执行倒计时60秒。

以上三个任务全部完成后，返回给客户端(响应150ms)。

(2) 并行方式：在用户点击发送短信成功后，第三方平台发送短信的同时，执行倒计时60秒。

与串行的差别是，并行的方式可以提高处理的时间(响应100ms)。

(3) 引入消息队列，将不是必须的业务逻辑，异步处理(55ms)。

改造后的架构如下：流量削峰流量削锋(流量错峰)也是消息队列中的常用场景，一般在秒杀或团抢活动中使用广泛。

rabbitMQ教程（三）一篇文章看懂rabbitMQ

rabbitMQ教程（三）⼀篇⽂章看懂rabbitMQ⼀、rabbitMQ是什么： RabbitMQ,遵循AMQP协议，由内在⾼并发的erlanng语⾔开发，⽤在实时的对可靠性要求⽐较⾼的消息传递上。

学过websocket的来理解rabbitMQ应该是⾮常简单的了，websocket是基于服务器和页⾯之间的通信协议，⼀次握⼿，多次通信。

⽽rabbitMQ就像是服务器之间的socket，⼀个服务器连上MQ监听，⽽另⼀个服务器只要通过MQ发送消息就能被监听服务器所接收。

但是MQ和socket还是有区别的，socket相当于是页⾯直接监听服务器。

⽽MQ就是服务器之间的中转站，例如邮箱，⼀个⼈投递信件给邮箱，另⼀个⼈去邮箱取，他们中间没有直接的关系，所以耦合度相⽐socket⼩了很多。

上图是最简单的MQ关系，⽣产者-MQ队列-消费者⼆、MQ使⽤场景：别啥固定式使⽤场景了，说的透彻⼀点，他就是服务器之间通信的，前⾯博⽂中提到的Httpclient也可以做到，但是这个相对于其他通信在中间做了⼀个中间仓库。

好处1：降低了两台服务器之间的耦合，哪怕是⼀台服务器挂了，另外⼀台服务器也不会报错或者休克，反正他监听的是MQ，只要服务器恢复再重新连上MQ发送消息，监听服务器就能再次接收。

好处2：MQ作为⼀个仓库，本⾝就提供了⾮常强⼤的功能，例如不再是简单的⼀对⼀功能，还能⼀对多，多对⼀，⾃⼰脑补保险箱场景，只要有特定的密码，谁都能存，谁都能取。

也就是说能实现群发消息和以此衍⽣的功能。

好处3：现在普遍化的持久化功能，当MQ挂掉可以存储在磁盘等下重启恢复。

（需要设置）三、专业术语介绍：1. ⽣产者：在现实⽣活中就好⽐制造商品的⼯⼚，他们是商品的⽣产者。

⽣产者只意味着发送。

发送消息的程序称之为⼀个⽣产者。

2. 队列：rabbitMQ就像⼀个仓库，⼀个仓库⾥⾯可以有很多队列，每个队列才是服务器之间消息通信的载体。

rabbitmq文档整理

Rabbitmq初识rabbitmqRabbitMQ是流行的开源消息队列系统，用erlang语言开发。

RabbitMQ是AMQP（高级消息队列协议）的标准实现。

如果不熟悉AMQP，直接看RabbitMQ的文档会比较困难。

不过它也只有几个关键概念，这里简单介绍几个概念说明：Broker：简单来说就是消息队列服务器实体。

Exchange：消息交换机，它指定消息按什么规则，路由到哪个队列。

Queue：消息队列载体，每个消息都会被投入到一个或多个队列。

Binding：绑定，它的作用就是把exchange和queue按照路由规则绑定起来。

Routing Key：路由关键字，exchange根据这个关键字进行消息投递。

vhost：虚拟主机，一个broker里可以开设多个vhost，用作不同用户的权限分离。

producer：消息生产者，就是投递消息的程序。

consumer：消息消费者，就是接受消息的程序。

channel：消息通道，在客户端的每个连接里，可建立多个channel，每个channel代表一个会话任务。

由Exchange，Queue，RoutingKey三个才能决定一个从Exchange到Queue的唯一的线路。

消息队列的使用过程大概如下：（1）客户端连接到消息队列服务器，打开一个channel。

（2）客户端声明一个exchange，并设置相关属性。

（3）客户端声明一个queue，并设置相关属性。

（4）客户端使用routing key，在exchange和queue之间建立好绑定关系。

（5）客户端投递消息到exchange。

exchange接收到消息后，就根据消息的key和已经设置的binding，进行消息路由，将消息投递到一个或多个队列里。

exchange也有几个类型，完全根据key进行投递的叫做Direct交换机，例如，绑定时设置了routing key为”abc”，那么客户端提交的消息，只有设置了key为”abc”的才会投递到队列。

android端rabbitmq的用法

android端rabbitmq的用法RabbitMQ是一个开源的消息中间件，它实现了高效的消息传递机制，被广泛应用于分布式系统中。

在Android开发中，我们可以利用RabbitMQ来实现消息的异步传递和处理，提高应用的性能和可靠性。

首先，我们需要在Android项目中引入RabbitMQ的依赖库。

可以通过在build.gradle文件中添加以下代码来实现：```dependencies {implementation 'com.rabbitmq:amqp-client:5.12.0'}```接下来，我们需要创建一个RabbitMQ的连接和通道。

在Android 中，由于网络请求需要在后台线程中执行，我们需要使用异步任务来处理RabbitMQ的连接和通道的创建。

可以通过以下代码来实现：```javaprivate class ConnectTask extends AsyncTask<Void, Void, Void> {private ConnectionFactory factory;private Connection connection;private Channel channel;@Overrideprotected Void doInBackground(Void... params) { try {factory = new ConnectionFactory();factory.setHost("your_rabbitmq_host");factory.setPort(5672);factory.setUsername("your_username");factory.setPassword("your_password");connection = factory.newConnection();channel = connection.createChannel();} catch (Exception e) {e.printStackTrace();}return null;}}```在上述代码中，我们需要替换"your_rabbitmq_host"、"your_username"和"your_password"为实际的RabbitMQ主机地址、用户名和密码。

RabbitMQ入门讲义

生产者流转过程示意图
消费者流转过程示意图
RABBITMQ组成部分
• Broker: 消息队列服务进程，包含两个部分Exchange和Queue； • Exchange: 消息队列交换机，按一定的规则将消息路由转发到某个队列，对消息进行过滤； • Queue: 存储消息的队列，消息到达队列并转发给指定的消费方； • Producer: 消息生产者发送消息到MQ； • Consumer: 消息消费者接收MQ转发的消息。。
消息队列的适用场景
任务异步处理 • 把不需要同步处理并且耗时较长的操作由消息队列通知消息接收方进行异步处理，提高了应用程序的响应时间。
应用程序解耦合 • MQ相当于一个代理，生产者通过MQ与消费者交互，它将应用程序进行解耦合。
削峰填谷
• 如订单系统。
AMQP-高级消息队列协议
• AMQP是一个提供统一消息服务的应用层标准高级消息队列协议，是应用层协议的一个开放标准，为面向消息的中间件设计。
为什么使用RABBITMQ
• 消息队列是应用程序与应用程序之间的通信方法。 • 在项目中, 可以将一些无需即时返回并且耗时的操作提取出来, 进行异步处理, 节省服务器的请求
响应时间, 从而提高了系统的吞吐量。 • 使用简单, 功能强大； • 基于AMQP 0-9-1协议； • 社区活跃, 文档丰富； • 高并发性能好, 这主要得益于erlang语言； • SpringBoot默认已集成RabbitMQ。
• 每个消费者监听自己的队列, 并且可以设置多个路由键； • 生产者将消息发给交换机, 发送消息时需要指定路由键, 由交换机根据路由键来转发消息到指定的
队列。。
通配符模式
• 每个消费者监听自己的队列，并且设置带通配符的路由键。 • 符号#: 匹配一个或多个词； • 符号*: 只能匹配一个词。 • 案例: 根据用户的通知设置去通知用户。。

rabbitmq,python使用方法

一、介绍RabbitMQRabbitMQ是使用AMQP（高级消息队列协议）的开源消息代理软件。

它可以用来处理高度的消息量，同时支持多种消息传输协议，如：AMQP、MQTT、STOMP等。

RabbitMQ的消息队列机制可以用来实现应用程序之间的异步通信，可以更好地解耦，提高系统的可扩展性和灵活性。

二、RabbitMQ的安装和部署1. 安装Erlang在安装RabbitMQ之前，首先需要安装Erlang，因为RabbitMQ是使用Erlang语言开发的。

在Linux环境下，可以通过apt或yum包管理器安装Erlang；在Windows环境下，可以通过下载安装包进行安装。

2. 安装RabbitMQ安装完成Erlang之后，可以下载RabbitMQ安装包，并按照冠方文档进行安装。

安装完成后，可以通过浏览器访问网络协议xxx，使用默认用户名和密码guest/guest登入RabbitMQ的管理界面。

3. 配置RabbitMQ在安装和部署完RabbitMQ之后，可以根据实际需要进行配置，如配置虚拟主机、用户、权限、队列等。

三、Python使用RabbitMQ1. 安装pika库在Python中使用RabbitMQ，通常会使用pika库来进行操作。

可以通过pip命令来安装pika库：`pip install pika`2. 连接RabbitMQ在Python中可以通过pika库来连接RabbitMQ，示例代码如下：```pythonimport pikaconnection =pika.BlockingConnection(pika.ConnectionParameters('localhost')) channel = connection.channel()```3. 发送消息通过pika库，可以很方便地向RabbitMQ发送消息，示例代码如下：```pythonchannel.queue_declare(queue='hello')channel.basic_publish(exchange='', routing_key='hello',body='Hello, RabbitMQ!')print(" [x] Sent 'Hello, RabbitMQ!'")```4. 接收消息通过pika库，可以很方便地从RabbitMQ接收消息，示例代码如下：```pythondef callback(ch, method, properties, body):print(" [x] Received r" body)channel.basic_consume(queue='hello',on_message_callback=callback, auto_ack=True)print(' [*] W本人ting for messages. To exit press CTRL+C') channel.start_consuming()```四、总结通过以上内容的介绍，我们了解了RabbitMQ的基本概念，安装和部署方法，以及在Python中使用RabbitMQ的方法。

rabbitmq 大纲

rabbitmq 大纲RabbitMQ概述简介RabbitMQ是一个开源的消息代理服务器，用于在软件应用程序之间可靠、高效地传递消息。

它是一个分布式系统，支持多种编程语言和协议，使其成为各种应用程序和微服务的理想选择。

核心概念RabbitMQ的中心概念包括：交换器：指定消息应被路由到的目标队列。

队列：存储消息的缓冲区，直到它们被消费者处理。

绑定：将交换器与队列关联，从而定义消息流。

消息：通过RabbitMQ传输的实际数据。

工作原理RabbitMQ通过以下步骤传输消息：1. 生产者将消息发布到交换器。

2. 交换器根据绑定的规则将消息路由到一个或多个队列。

3. 消费者从队列中读取消息并处理它们。

特点RabbitMQ具有以下特点：高可靠性：提供持久化和复制功能，以确保消息的安全性。

可扩展性：支持水平和垂直扩展，以满足不断增长的需求。

灵活的路由：支持多种路由模式，包括主题和头部匹配。

多协议：支持AMQP、MQTT和STOMP等协议。

丰富的工具和库：提供一系列工具和库，简化开发和管理。

用例RabbitMQ在以下场景中得到了广泛应用：微服务通信：在松散耦合的微服务之间可靠地传输消息。

异步任务处理：安排和处理长时间运行的任务，而不会阻塞应用程序。

事件流处理：实时处理大量事件数据，例如来自传感器或日志。

消息队列：提供可靠的消息存储和转发机制。

集成功能：集成来自不同来源的数据和应用程序。

优点使用RabbitMQ的优点包括：增加可靠性：通过持久化和复制防止数据丢失。

提高性能：并行处理消息，提高吞吐量。

提高可伸缩性：轻松扩展基础设施以满足需求增长。

降低复杂性：通过消息队列抽象隐藏应用程序之间的通信细节。

增强安全性：提供访问控制和加密功能来保护消息。

结论RabbitMQ是一个功能强大且可靠的消息代理服务器，为软件应用程序之间的消息传递提供了高效且可扩展的解决方案。

它广泛用于各种用例，从微服务通信到事件流处理，并凭借其灵活性、可扩展性和可靠性获得了广泛认可。

rabbitmq项目使用实例

rabbitmq项目使用实例RabbitMQ是一个开源的消息代理软件，它实现了高级消息队列协议（AMQP）标准，可以在分布式系统中扮演消息代理的角色，用于在应用程序之间传递消息。

下面我将从多个角度介绍RabbitMQ项目的使用实例。

1. 安装和配置：首先，你需要安装RabbitMQ服务器。

安装完成后，你可以通过RabbitMQ的管理界面进行一些基本的配置，比如创建虚拟主机、用户和权限等。

你也可以通过命令行工具进行配置，比如创建队列、交换机，绑定队列等操作。

2. 生产者和消费者：在一个典型的RabbitMQ项目中，你通常会有生产者和消费者两种角色。

生产者负责向RabbitMQ发送消息，而消费者则从RabbitMQ接收消息并进行处理。

你需要编写相应的代码来实现这些功能，比如使用RabbitMQ的客户端库来连接到RabbitMQ服务器，并发送/接收消息。

3. 消息队列的使用：RabbitMQ的核心功能之一就是消息队列。

你可以创建队列，并将消息发送到队列中。

消费者可以订阅队列，并在有消息到达时进行处理。

这种模式非常适合解耦生产者和消费者，以及实现异步处理。

4. 交换机和路由：RabbitMQ中的交换机用于接收来自生产者的消息，并将消息路由到一个或多个队列。

你可以根据消息的路由键（routing key）来指定消息的路由规则，以及选择不同的路由算法，比如直接交换、主题交换等。

5. 错误处理和可靠性：在实际项目中，你需要考虑消息的可靠性和错误处理。

RabbitMQ提供了一些机制来处理这些情况，比如确认机制（acknowledgment）和消息持久化。

你可以确保消息在发送和接收过程中不会丢失，并且可以处理一些异常情况。

总的来说，RabbitMQ在实际项目中可以应用于很多场景，比如微服务架构中的服务间通信、异步任务处理、日志收集等。

通过合理的配置和代码编写，你可以充分利用RabbitMQ的功能，实现高效的消息传递和处理。

rabbitmq五种模式详解（含实现代码）

rabbitmq五种模式详解（含实现代码）⼀、五种模式详解1.简单模式(Queue模式)当⽣产端发送消息到交换机,交换机根据消息属性发送到队列,消费者监听绑定队列实现消息的接收和消费逻辑编写.简单模式下,强调的⼀个队列queue只被⼀个消费者监听消费.1.1 结构⽣产者:⽣成消息,发送到交换机交换机:根据消息属性,将消息发送给队列消费者:监听这个队列,发现消息后,获取消息执⾏消费逻辑1.2应⽤场景常见的应⽤场景就是⼀发,⼀接的结构例如:⼿机短信邮件单发2.争抢模式(Work模式)强调的也是后端队列与消费者绑定的结构2.1结构⽣产者:发送消息到交换机交换机:根据消息属性将消息发送给队列消费者:多个消费者,同时绑定监听⼀个队列,之间形成了争抢消息的效果2.2应⽤场景抢红包资源分配系统3.路由模式(Route模式 Direct定向)从路由模式开始，关⼼的就是消息如何到达的队列，路由模式需要使⽤的交换机类型就是路由交换机（direct）3.1 结构⽣产端：发送消息，在消息中处理消息内容，携带⼀个routingkey交换机：接收消息，根据消息的routingkey去计算匹配后端队列的routingkey队列：存储交换机发送的消息消费端：简单模式⼯作争抢3.2应⽤场景短信聊天⼯具邮箱。

⼿机号/邮箱地址，都可以是路由key4.发布订阅模式(Pulish/Subscribe模式 Fanout⼴播)不计算路由的⼀种特殊交换机4.1结构4.2应⽤场景消息推送⼴告5.主题模式(Topics模式 Tpoic通配符)路由key值是⼀种多级路径。

中国.四川.成都.武侯区5.1结构⽣产端：携带路由key，发送消息到交换机队列：绑定交换机和路由不⼀样，不是⼀个具体的路由key，⽽可以使⽤*和#代替⼀个范围| * | 字符串，只能表⽰⼀级 || --- | --- || # | 多级字符串 |交换机：根据匹配规则，将路由key对应发送到队列消息路由key:北京市.朝阳区.酒仙桥北京市.#: 匹配true上海市.浦东区.*: 没匹配false新疆.乌鲁⽊齐.#5.2 应⽤场景做物流分拣的多级传递.6.完整结构⼆、代码实现1.创建SpringBoot⼯程1.1 ⼯程基本信息1.2 依赖信息1.3 配置⽂件applicasion.properties# 应⽤名称=springboot-demo# Actuator Web 访问端⼝management.server.port=8801management.endpoints.jmx.exposure.include=*management.endpoints.web.exposure.include=*management.endpoint.health.show-details=always# 应⽤服务 WEB 访问端⼝server.port=8801######################### RabbitMQ配置 ######################### RabbitMQ主机spring.rabbitmq.host=127.0.0.1# RabbitMQ虚拟主机spring.rabbitmq.virtual-host=demo# RabbitMQ服务端⼝spring.rabbitmq.port=5672# RabbitMQ服务⽤户名ername=admin# RabbitMQ服务密码spring.rabbitmq.password=admin# RabbitMQ服务发布确认属性配置## NONE值是禁⽤发布确认模式，是默认值## CORRELATED值是发布消息成功到交换器后会触发回调⽅法## SIMPLE值经测试有两种效果，其⼀效果和CORRELATED值⼀样会触发回调⽅法，其⼆在发布消息成功后使⽤rabbitTemplate调⽤waitForConfirms或waitForConfirmsOrDie⽅法等待broker节点返回发送结果，根据返回结果来判定下⼀步的逻辑，要注意的点是wa spring.rabbitmq.publisher-confirm-type=simple# RabbitMQ服务开启消息发送确认spring.rabbitmq.publisher-returns=true######################### simple模式配置 ######################### RabbitMQ服务消息接收确认模式## NONE：不确认## AUTO：⾃动确认## MANUAL：⼿动确认spring.rabbitmq.listener.simple.acknowledge-mode=manual# 指定最⼩的消费者数量spring.rabbitmq.listener.simple.concurrency=1# 指定最⼤的消费者数量spring.rabbitmq.listener.simple.max-concurrency=1# 开启⽀持重试spring.rabbitmq.listener.simple.retry.enabled=true2.简单模式2.1 创建SimpleQueueConfig 简单队列配置类package com.gmtgo.demo.simple;import org.springframework.amqp.core.Queue;import org.springframework.context.annotation.Bean;import org.springframework.context.annotation.Configuration;/*** @author ⼤帅*/@Configurationpublic class SimpleQueueConfig {/*** 定义简单队列名.*/private final String simpleQueue = "queue_simple";@Beanpublic Queue simpleQueue() {return new Queue(simpleQueue);}}2.2 编写⽣产者package com.gmtgo.demo.simple;import lombok.extern.slf4j.Slf4j;import org.springframework.amqp.rabbit.core.RabbitTemplate;import org.springframework.beans.factory.annotation.Autowired;import ponent;/*** @author ⼤帅*/@Slf4j@Componentpublic class SimpleProducer {@Autowiredprivate RabbitTemplate rabbitTemplate;public void sendMessage() {for (int i = 0; i < 5; i++) {String message = "简单消息" + i;("我是⽣产信息:{}", message);rabbitTemplate.convertAndSend( "queue_simple", message);}}}2.3 编写消费者package com.gmtgo.demo.simple;import com.rabbitmq.client.Channel;import lombok.extern.slf4j.Slf4j;import org.springframework.amqp.core.Message;import org.springframework.amqp.rabbit.annotation.RabbitListener;import ponent;import java.io.IOException;/*** @author ⼤帅*/@Slf4j@Componentpublic class SimpleConsumers {@RabbitListener(queues = "queue_simple")public void readMessage(Message message, Channel channel) throws IOException {channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);("我是消费信息:{}", new String(message.getBody()));}}2.4 编写访问类package com.gmtgo.demo.simple;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.web.bind.annotation.RequestMapping;import org.springframework.web.bind.annotation.RestController;/*** @author ⼤帅*/@RestController@RequestMapping(value = "/rabbitMq")public class SimpleRabbitMqController {@Autowiredprivate SimpleProducer simpleProducer;@RequestMapping(value = "/simpleQueueTest")public String simpleQueueTest() {simpleProducer.sendMessage();return "success";}}2.5 测试启动项⽬访问 simpleQueueTest访问地址:结果：3.Work队列3.1 编写⼯作配置package com.gmtgo.demo.work;import org.springframework.amqp.core.Queue;import org.springframework.context.annotation.Bean;import org.springframework.context.annotation.Configuration;/*** @author ⼤帅*/@Configurationpublic class WorkQueueConfig {/*** 队列名.*/private final String work = "work_queue";@Beanpublic Queue workQueue() {return new Queue(work);}}3.2 编写⽣产者package com.gmtgo.demo.work;import lombok.extern.slf4j.Slf4j;import org.springframework.amqp.rabbit.core.RabbitTemplate;import org.springframework.beans.factory.annotation.Autowired;import ponent;/*** @author ⼤帅*/@Slf4j@Componentpublic class WorkProducer {@Autowiredprivate RabbitTemplate rabbitTemplate;public void sendMessage() {for (int i = 0; i < 10; i++) {String message = "⼯作消息" + i;("我是⽣产信息:{}", message);rabbitTemplate.convertAndSend("work_queue", message);}}}3.3 编写消费者1package com.gmtgo.demo.work;import com.rabbitmq.client.Channel;import lombok.extern.slf4j.Slf4j;import org.springframework.amqp.core.Message;import org.springframework.amqp.rabbit.annotation.RabbitListener;import ponent;import java.io.IOException;/*** @author ⼤帅*/@Slf4j@Componentpublic class WorkConsumers1 {@RabbitListener(queues = "work_queue")public void readMessage(Message message, Channel channel) throws IOException { channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);("我是消费信息1:{}", new String(message.getBody()));}}3.4 编写消费者2package com.gmtgo.demo.work;import com.rabbitmq.client.Channel;import lombok.extern.slf4j.Slf4j;import org.springframework.amqp.core.Message;import org.springframework.amqp.rabbit.annotation.RabbitListener;import ponent;import java.io.IOException;/*** @author ⼤帅*/@Slf4j@Componentpublic class WorkConsumers2 {@RabbitListener(queues = "work_queue")public void readMessage(Message message, Channel channel) throws IOException { channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);("我是消费信息2:{}", new String(message.getBody()));}}3.5 编写测试⽅法package com.gmtgo.demo.work;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.web.bind.annotation.RequestMapping;import org.springframework.web.bind.annotation.RestController;/*** @author ⼤帅*/@RestController@RequestMapping(value = "rabbitMq")public class WorkRabbitMqController {@Autowiredprivate WorkProducer workProducer;@RequestMapping(value = "workQueueTest")public String workQueueTest() {workProducer.sendMessage();return "success";}}3.6 测试启动项⽬访问 workQueueTest访问地址结果：控制台打印，发现10条消息偶数条消费者1获取，奇数条消费者2获取，并且平均分配。