Rabbitmq进阶

Rabbitmq进阶 1. 什么是消息中间件

消息（Message）是指在应用间传送的数据，消息类型可以是文本字符串、JSON 或者内嵌对象

消息队列中间件（Message Queue Middleware，简称为 MQ）是指利用高效可靠的消息传递机制进行与平台无关的数据交流，并基于数据通信来进行分布式系统的集成。通过提供消息传递和消息排队模型，它可以在分布式环境下扩展进程间的通信

MQ 一般有两种传递模式：点对点（P2P，Point-to-Point）模式和发布/订阅（Pub/Sub）模式。点对点模式是基于队列的，消息生产者发送消息到队列，消息消费者从队列中接收消息，队列的存在使得消息的异步传输成为可能。发布订阅模式定义了如何向一个内容节点发布和订阅消息，这个内容节点称为主题（topic），主题可以认为是消息传递的中介，消息发布者将消息发布到某个主题，而消息订阅者则从主题中订阅消息。主题使得消息的订阅者与消息的发布者相互保持独立，不需要进行接触即可保证消息的传递，发布/订阅模式在消息的一对多广播时采用

面向消息的中间件（简称为 MOM，Message Oriented Middleware）提供了以松耦合的灵活方式集成应用程序的一种机制。它们提供了基于存储和转发的应用程序之间的一部数据传输，即应用程序彼此不直接通信，而是与作为中介的 MQ 通信。MQ 提供了有保证的消息发送，应用程序开发人员无需了解远程过程调用（RPC）和网络通信协议的细节

MQ 适用于需要可靠的数据传输的分布式环境。采用 MQ 的系统中，不同的对象之间通过传递消息来激活对方的时间，以完成相应的 *** 作。发送者将消息发送给消息服务器，消息服务器将消息存放在若干队列中，在合适的时候再将消息转发给接收者。MQ 能在不同平台之间通信，它常被用来屏蔽各种平台及协议之间的特性，实现应用程序之间的协同，其优点在于能够在客户和服务器之间提供同步和异步的连接，并且在任何时刻都可以将消息进行传送或者存储转发，这也是它比远程过程调用更进步的原因

以图 1-1 为例，应用程序 A 与应用程序 B 通过使用 MQ 的应用程序编程接口（API，Application Program Interface）发送消息来进行通信

MQ 将消息路由给应用程序 B，这样消息就可以存在于完全不同的计算机上。消息中间件负责处理网络通信，如果网络连接不可用，MQ会存储消息，直到连接变得可用，再将消息转发给应用程序 B。灵活性的另一方面体现在，当应用程序 A 发送其消息时，应用程序 B 甚至可以处于不运行状态，MQ 将保留这份消息，直到应用程序 B 开始执行并消费消息，这样还防止了应用程序 A 因为等待应用程序 B 消费消息而出现阻塞。

2. 消息中间件的作用

解耦: 在项目启动之初来预测将来会碰到什么需要是极其困难的。消息中间件在处理过程中插入了一个隐含的、基于数据的接口层，两边的处理过程都要实现这一接口，这允许你独立地扩展或修改两边的处理过程，只要确保它们遵守同样的接口约束即可
冗余（存储）： 有些情况下，处理数据的过程会失败。消息中间件可以把数据进行持久化，直到它们已经被完全处理，通过这一方式可以规避数据丢失的风险
扩展性： 因为消息中间件解耦了应用的处理过程，所以提高消息入队和处理的效率是很容易的，只要另外增加处理过程即可，不需要改变代码，也不需要调节参数
削峰： 在访问量剧增的情况下，应用仍然需要继续发挥作用，但是这样的突发流量并不常见。如果以能处理这类峰值为标准而投入硬件资源，无疑是巨大的浪费。使用消息中间件使得关键组件能够支撑突发访问压力，不会因为突发的超负荷请求而完全崩溃
可恢复性： 当系统一部分组件失效时，不会影响到整个系统。消息中间件降低了进程间的耦合度，所以即使一个处理消息的进程挂掉，加入消息中间件中的消息仍然可以在系统恢复后进行处理
顺序保证： 在大多数使用场景下，数据处理的顺序很重要，大部分消息中间件支持一定程度上的顺序性
缓冲： 在任何重要的系统中，都会存在需要不同处理时间的元素。消息中间件通过一个缓冲层来帮助任务最高效率地执行，写入消息中间件的处理会尽可能快速。该缓冲层有助于控制和优化数据流经过系统的速度
异步通信： 在很多时候，应用不想也不需要立即处理消息。消息中间件提供了异步处理机制，允许应用把一些消息放入消息中间件中，但并不立即处理它，在之后需要的时候再慢慢处理

3. Raabitmq简介

RabbitMQ 整体上是一个生产者与消费者模型，主要负责接收、存储和转发消息。可以把消息传递的过程想象成：当你将一个包裹送到邮局，邮局会暂存并最终将邮件通过邮递员送到收件人的手上，RabbitMQ 就好比邮局、邮箱和邮递员组成的一个系统。从计算机术语层面来说，RabbitMQ 模型更像是一种交换机模型

RabbitMQ 的整体模型架构如图 2-1 所示

3.1 生产者和消费者

Producer： 生产者，就是投递消息的一方

生产者创建消息，然后发布到 RabbitMQ 中。消息一般可以包含 2 个部分：消息体和标签。消息体也可以称之为 payload，在实际应用中，消息体一般是一个带有业务逻辑结构的数据，比如一个 JSON 字符串。当然可以进一步对这个消息体进行序列化 *** 作。消息的标签用来表述这条消息，比如一个交换器的名称和一个路由键。生产者把消息交由 RabbitMQ，RabbitMQ 之后会根据标签把消息发送给感兴趣的消费者

Consumer： 消费者，就是接收消息的一方

消费者连接到 RabbitMQ 服务器，并订阅到队列上。当消费者消费一条消息时，只是消费消息的消息体。在消息路由的过程中，消息的标签会被丢弃，存入到队列中的消息只有消息体，消费者也只会消费到消息体，也就不知道消息的生产者是谁，当然消费者也不需要知道

Broker： 消息中间件的服务节点

对于 RabbitMQ 来说，一个 RabbitMQ Broker 可以简单地看作一个 RabbitMQ 服务节点，或者 RabbitMQ 服务实例。大多数情况下也可以将一个 RabbitMQ Broker 看作一台 RabbitMQ 服务器

图 2-2 展示了生产者将消息存入 RabbitMQ Broker，以及消费者从 Broker 中消费数据的整个流程

首先生产者将业务方数据进行可能的包装，之后封装成消息，发送（AMQP 协议里这个动作对应的命令为 Basic.Publish）到 Broker 中。消费者订阅并接收消息（AMQP 协议里这个动作对应的命令为 Basic.Consume 或者 Basic.Get），经过可能的解包处理得到原始的数据，之后再进行业务处理逻辑。这个业务处理逻辑并不一定需要和接收消息的逻辑使用同一个线程。消费者进程可以使用一个线程去接收消息，存入到内存中，比如使用 Java 中的 BlockingQueue。业务处理逻辑使用另一个线程从内存中读取数据，这样可以将应用进一步解耦，提高整个应用的处理效率

3.2 队列

Queue： 队列，是 RabbitMQ 的内部对象，用于存储消息

RabbitMQ 中消息都只能存储在队列中，这一点和 Kafka 这种消息中间件相反。Kafka 将消息存储在 topic（主题）这个逻辑层面，而相对应的队列逻辑只是 topic 实际存储文件中的位移标识。RabbitMQ 的生产者生产消息并最终投递到队列中，消费者可以从队列中获取消息并消费

多个消费者可以订阅同一个队列，这时队列中的消息会被平均分摊（Round-Robin，即轮询）给多个消费者进行处理，而不是每个消费者都收到所有的消息并处理，如图 2-4 所示

RabbitMQ 不支持队列层面的广播消费，如果需要广播消费，需要在其上进行二次开发，处理逻辑会变得异常复杂，同时也不建议这么做。

3.3 交换器、路由键、绑定

Exchange： 交换器。在图 2-4 中我们暂时可以理解成生产者将消息投递到队列中，实际上这个在 RabbitMQ 中不会发生。真实情况是，生产者将消息发送到 Exchange（交换器，通常也可以用大写的 “X” 来表示），由交换器将消息路由到一个或者多个队列中。如果路由不到，或许会返回给生产者，或许直接丢弃。这里可以将 RabbitMQ 中的交换器看作一个简单的实体，更多的细节会在后面的章节中涉及

交换器的具体示意如图 2-5 所示

RabbitMQ 中的交换器有四种类型，不同的类型有着不同的路由策略

RoutingKey：路由键。生产者将消息发给交换器的时候，一般会指定一个 RoutingKey，用来指定这个消息的路由规则，而这个 RoutingKey 需要与交换器类型和绑定键（BingdingKey）联合使用才能最终生效

在交换器类型和绑定键（BingingKey）固定的情况下，生产者可以在发送消息给交换器时，通过指定 RoutringKey 来决定消息流向哪里

Bingding：绑定。RabbitMQ 中通过绑定将交换器与队列关联起来，在绑定的时候一般会指定一个绑定键（BindingKey），这样 RabbitMQ 就知道如何正确地将消息路由到队列了，如图 2-6 所示
生产者将消息发送给交换器时，需要一个 RoutingKey 和 RoutingKey 相匹配时，消息会被路由到对应的队列中。在绑定多个队列到同一个交换器的时候，这些绑定允许使用相同的 BindingKey。BindingKey 并不是在所有的情况下都生效，它依赖于交换器类型，比如 fanout 类型的交换器就会无视 BindingKey，而是将消息路由到所有绑定到该交换器的队列中

沿用本章开头的比喻，交换器相当于投递包裹的邮箱，RoutingKey 相当于填写在包裹上的地址，BindingKey 相当于包裹的目的地，当填写在包裹上的地址和实际想要投递的地址相匹配时，那么这个包裹就会被正确投递到目的地，最后这个目的地的 “主人” —— 队列可以保留这个包裹。如果填写的地址出错，邮递员不能正确投递到目的地，包裹可能会会退给寄件人，也可能被丢弃。
indingKey 其实也属于路由键中的一种，官方解释为：the routing key to use for the binding

可以翻译为：在绑定的时候使用的路由键。大多数时候，包括官方文档和 RabbitMQ Java API 中都把 BindingKey 和 RoutingKey 看作 RoutingKey，为了避免混淆，可以这么理解：

• 在使用绑定的时候，其中需要的路由键是 BindingKey。涉及的客户端方法如：channel.exchangeBind、channel.queueBind，对应的 AMQP 命令为 Exchange.Bind、Queue.Bind
• 在发送消息的时候，其中需要的路由键是 RoutingKey。涉及的客户端方法如：channel.basicPublish，对应的 AMQP 命令为 Basic.Publish

由于某些历史原因，包括现存能搜集到的资料显示：大多数情况下习惯性地将 BindingKey 写成 RoutingKey，尤其是在使用 direct 类型的交换器的时候。本文后面的篇幅中也会将两者合称为路由键，读者需要注意区分其中的不同，可以根据上面的辨别方法进行有效的区分。

3.4 交换器类型

RabbitMQ 常用的交换器类型有 fanout、direct、topic、headers 这四种。AMQP 协议里还提到另外两种类型：System 和自定义，这里不予描述

fanout

它会把所有发送到该交换器的消息路由到所有与该交换器绑定的队列中

direct

direct 类型的交换器路由规则也很简单，它会把消息路由到那些 BindingKey 和 RoutingKey 完全匹配的队列中

topic

它的匹配规则稍微有点复杂，它约定：

• RoutingKey 为一个点号 “.” 分隔的字符串（被点号 “.” 分隔开的每一段独立的字符串称为一个单词），如 “com.rabbitmq.client”、“java.util.concurrent”、“com.hidden.client”

• BindingKey 和 RoutingKey 一样也是点号 “.”

• BindingKey 中可以存在两种特殊字符串 “” 和 “#”，用于做模糊匹配，其中 “” 用于匹配一个单词，“#” 用于匹配多规格单词（可以是零个）
  
  以图 2-8 中的配置为例：

• 路由键为 “com.rabbitmq.client” 的消息会同时路由到 Queue1 和 Queue2

• 路由键为 “com.hidden.client” 的消息只会路由到 Queue2 中

• 路由键为 “com.hidden.demo” 的消息只会路由到 Queue2 中

• 路由键为 “java.rabbitmq.demo” 的消息只会路由到 Queue1 中

• 路由键为 “java.util.concurrent” 的消息将会被丢弃或者返回给生产者（需要设置 mandatory 参数），因为它没有匹配任何路由键

headers

headers 类型的交换器不依赖于路由键和匹配规则来路由消息，而是根据发送的消息内容中的 headers 属性进行匹配。在绑定队列和交换器时制定一组键值对，当发送消息到交换器时，RabbitMQ 会获取到该消息的 headers（也是一个键值对的形式），对比其中的键值对是否完全匹配队列和交换器绑定时指定的键值对，如果完全匹配则消息会路由到该队列。headers 类型的交换器性能会很差，而且也不实用，基本上不会看到它的存在

3.5 RabbitMQ 运转流程

初始状态下，生产者发送消息的时候：

1. 生产者连接到 RabbitMQ Broker，建立一个连接（Connection），开启一个信道（Channel）
2. 生产者声明一个交换器，并设置相关属性，比如交换机类型、是否持久化等
3. 生产者声明一个队列并设置相关属性，比如是否排他、是否持久化、是否自动删除等
4. 生产者通过路由键将交换器和队列绑定起来
5. 生产者发送消息至 RabbitMQ Broker，其中包含路由键、交换器等信息
6. 相应的交换器根据接收到的路由键查找相匹配的队列
7. 如果找到，则将从生产者发送过来的消息存入相应的队列中
8. 如果没有找到，则根据生产者配置的属性选择丢弃还是会退给生产者
9. 关闭信道
10. 关闭连接

消费者接收消息的过程 ：

1. 消费者连接到 RabbitMQ Broker，建立一个连接（Connection），开启一个信道（Channel）
2. 消费者向 RabbitMQ Broker 请求消费相应队列中的消息，可能会设置相应的回调函数，以及做一些准备工作
3. 等待 RabbitMQ Broker 回应并投递相应队列中的消息，消费者接收消息
4. 消费者确认（ack）接收到的消息
5. RabbitMQ 从队列中删除相应已经被确认的消息
6. 关闭信道
7. 关闭连接
   

如图 2-9 所示，我们又引入了两个新的概念：Connection 和 Channel。我们知道无论是生产者还是消费者，都需要和 RabbitMQ Broker 建立连接，这个连接就是一条 TCP 连接，也就是 Connection。一旦 TCP 连接建立起来，客户端紧接着可以创建一个 AMQP 信道（Channel），每个信道都会被指派一个唯一的 ID。信道是建立在 Connection 之上的虚拟连接，RabbitMQ 处理的每条 AMQP 指令都是通过信道完成的

为什么需要引入信道？

我们完全可以直接使用 Connection 就能完成信道的工作，为什么还要引入信道呢？试想这样一个场景，一个应用程序中有很多个线程需要从 RabbitMQ 中消费消息，或者生产消息，那么必然需要建立很多个 Connection，也就是许多个 TCP 连接。然而对于 *** 作系统而言，建立和销毁 TCP 连接是非常昂贵的开销，如果遇到使用高峰，性能瓶颈也随之显现。RabbitMQ 采用类似 NIO 的做法，选择 TCP 连接复用，不仅可以减少性能开销，同时也便于管理。RabbitMQ 的 TCP 连接复用技术包含三大核心部分：Channel（信道）、Buffer（缓冲区）和 Selector（选择器）。NIO 基于 Channel 和 Buffer 进行 *** 作，数据总是从信道读取数据到缓冲区中，或者从缓冲区写入到信道中。Selector 用于监听多个信道的事件（比如连接打开，数据到达等）。因此，一个 Selector 单线程可以监听多个数据的信道。同时，RabbitMQ 可以确保每个线程的私密性，就像拥有独立的连接一样。当每个信道的流量不是很大时，复用单一的 Connection 可以在生产性能瓶颈的情况下有效地节省 TCP 连接资源。但是当信道本身的流量很大时，这时多个信道复用一个 Connection 就会产生性能瓶颈，进而使整体的流量被限制了。此时就需要开辟多个 Connection，将这些信道均摊到这些 Connection 中，至于这些相关的调优策略需要根据业务自身的实际情况进行调节

信道在 AMQP 中是一个很重要的概念，大多数 *** 作都是在信道这个层面展开的

3.6 Rabbitmq特点

RabbitMQ 是采用 Erlang 语言实现 AMQP（Advanced Message Queuing Protocol，高级消息队列协议）的消息中间件，它最初起源于金融系统，用于在分布式系统中存储转发消息。RabbitMQ 发展到今天，被越来越多的人认可，这和它在易用性、扩展性、可靠性等方面的卓著表现是分不开的，RabbitMQ 的具体特点可以概括为以下几点：

• 可靠性：RabbitMQ 使用一些机制来保证可靠性，如持久化、传输确认及发布确认等
• 灵活的路由：在消息进入队列之前，通过交换器来路由消息。对于典型的路由功能，RabbitMQ 已经提供了一些内置的交换器来实现。针对更复杂的路由功能，可以将多个交换器绑定在一起，也可以通过插件来实现自己的交换器
• 扩展性：多个 RabbitMQ 节点可以组成一个集群，也可以根据实际业务情况动态地扩展集群中的节点
• 高可用性：队列可以在集群中的机器上设置镜像，使得在部分节点出现问题的情况下队列仍然可用
• 多种协议：RabbitMQ 除了原生支持 AMQP 协议，还支持 STOMP、MQTT 等多种消息中间件协议
• 多语言客户端：RabbitMQ 几乎支持所有常用语言，比如 Java、Python、Ruby、PHP、C#、JavaScript 等
• 管理界面：RabbitMQ 提供了一个易用的用户界面，使得用户可以监控和管理消息、集群中的节点等
• 插件机制：RabbitMQ 提供了许多插件，以实现从多方面进行扩展，当然也可以编写自己的插件

4. AMQP 协议介绍

可以这样说，RabbitMQ 就是 AMQP 协议的 Erlang 的实现。当然，RabbitMQ 还支持 STOMP（流文本面向消息协议，提供了一个可互 *** 作的连接格式，用于客户端与 Broker 进行交互）和 MQTT（消息队列遥测传输，IBM 开发的一个即时通信协议，该协议支持所有平台）。AMQP 的模型架构和 RabbitMQ 的模型架构是一样的，生产者将消息发送给交换器，交换器和队列绑定。当生产者发送消息时携带的 RoutingKey 与绑定时的 BindingKey 相匹配时，消息即被存入相应的队列之中，消费者可以订阅相应的队列来获取消息

RabbitMQ 中的交换器、交换器类型、队列、绑定、路由键等都是遵循的 AMQP 协议中相应的概念。AMQP 协议本身包括三层：

• Module Layer：位于协议最高层，主要定义了一些提供客户端调用的命令，客户端可以利用这些命令实现自己的业务逻辑。例如，客户端可以使用 Queue.Declare 命令声明一个队列或者使用 Basic.Consum 订阅消费一个队列中的消息
• Session Layer：位于中间层，主要负责将客户端的命令发送给服务器，再将服务端的应答返回给客户端，主要为客户端与服务器之间的通信提供可靠性同步机制和错误处理
• Transport Layer：位于最底层，主要传输二进制数据流，提供帧的处理、信道复用、错误检测和数据表示等

AMQP 说到底还是一个通信协议，通信协议都会涉及报文交互，从 low-level 层面举例来说，AMQP 本身是应用层的协议，其填充于 TCP 协议层的数据部分。而从 high-level 层面来说，AMQP 是通过协议命令进行交互的。AMQP 协议可以看作一系列结构化命令的集合，这里的命令代表一种 *** 作，类似于 HTTP 中的方法（GET、POST、PUT、DELETE 等）

4.1 AMQP 生产者流转过程

Connection connection = factory.newConnection();    //创建连接
Channel channel = connection.createChannel();       //创建信道
String message = "Hello World!";
channel.basicPublish(EXCHANGE_NAME, ROUTING_KEY, MessageProperties.PERSISTENT_TEXT_PLAIN, message.getBytes());
//关闭资源
channel.close();
connection.close();

当客户端与 Broker 建立连接的时候，会调用 factory.newConnection 方法，这个方法会进一步封装成 Protocol Header 0-9-1 的报文头发送给 Broker，以此通知 Broker 本次交互采用的是 AMQP 0-9-1 协议，紧接着 Broker 返回 Connection.Start 来建立连接，在连接的过程中涉及 Connection.Start/.Start-Ok、Conection.Tune/.Tune-Ok、Connection.Open/.Open-Ok 这 6 个命令的交互

当客户端调用 connection.createChannel 方法准备开启信道的时候，其包装 Channel.Open 命令发送给 Broker，等待 Channel.Open-Ok 命令

当客户端发送消息的时候，需要调用 channel.basicPublish 方法，对应的 AMQP 命令为 Basic.Publish，注意这个命令和前面涉及的命令略有不同，这个命令还包含了 Content Header 和 Content Body。Content Header 里面包含的 是消息体的属性，例如，投递模式、优先级等，而 Content Body 包含消息体本身

当客户端发送完消息需要关闭资源时，涉及 Channel.Close/.Close-Ok 与 Connection.Close/.Close-Ok 的命令交互

4.2 AMQP 消费者流转过程

Connection connection = factory.newConnection();    //创建连接
final Channel channel = connection.createChannel(); //创建信道
Consumer consumer = new DefaultConsumer(channel){//...省略具体实现};
channel.basicQos(64);   //设置客户端最多接收未被 ack 的消息的个数
channel.basicConsume(QUEUE_NAME, consumer);
//等待回调函数执行完毕之后，关闭资源
TimeUnit.SECONDS.sleep(5);
channel.close();
connection.close();

消费者客户端同样需要与 Broker 建立连接，与生产者客户端一样，协议交互同样涉及 Connection.Start/.Start-Ok、Connection.Tune/.Tune-Ok 和 Connection.Open/.Open-Ok 等，图 2-11 中省略了这些步骤

紧接着也少不了在 Connection 之上建立 Channel，和生产者客户端一样，协议涉及 Channel.Open/Open-Ok

如果在消费之前调用了 channel.basicQos(int prefetchCount) 的方法来设置消费者客户但最大能 “保持” 的未确认的消息数（即预取个数），那么协议流转会涉及到 Basic.Qos/.Qos-Ok 这两个 AMQP 命令

在真正消费之前，消费者客户端需要向 Broker 发送 Basic.Consume 命令（即调用 channel.basicConsume 方法）将 Channel 置为接收模式，之后 Broker 回执 Basic.Consume-Ok 以告诉消费者客户端准备好消费消息。紧接着 Broker 向消费者客户端推送（Push）消息，即 Basic.Deliver 命令，有意思的是这个和 Basic.Publish 命令一样会携带 Content Header 和 Content Body

消费者接收到消息并正确消费之后，向 Broker 发送确认，即 Basic.Ack 命令

在消费者停止消费的时候，主动关闭连接，这点和生产者一样，涉及 Channel.Close/.Close-Ok 和 Connection.Close/.Close-Ok

4.3 AMQP 命令概览

5. 使用python *** 作rabbitmq

生产

import pika

credentials = pika.PlainCredentials('xxx123', 'rst1qaz@WSX')

connection = pika.BlockingConnection(pika.ConnectionParameters(
    host='192.168.206.128', port=5672, credentials=credentials))  # socket连接 定义连接池
    
channel = connection.channel()  # 申明一个管道
channel.queue_declare(queue='test')   # 给管道里面申明一个queue（队列）

channel.basic_publish(
    exchange='', routing_key='test', body=bytes('Hello World'.encode()))  # 通过管道发送消息
print('send success msg to rabbitmq')

connection.close()

消费

import time
import pika

username = 'xxx123'
password = 'rst1qaz@WSX'
credentials = pika.PlainCredentials(username, password)
connection = pika.BlockingConnection(pika.ConnectionParameters(
    host='192.168.206.128', port=5672, credentials=credentials))
channel = connection.channel()
channel.queue_declare(queue='test')


def callback(ch, method, properties, body):
    # ch 是申明的管道的内存地址
    # method 把消息发送给的处理信息
    # properties 序列化
    # boby product端发来的信息
    print("[%s] Received %r" % (time.time(), body))


print('[*] Waiting for messages. To exit press CTRL+C')
channel.basic_consume('test', callback)
channel.start_consuming()

运行