RabbitMQ 工作队列

工作队列（又称：任务队列——Task Queues）是为了避免等待一些占用大量资源、时间的操作。当我们把任务（Task）当作消息发送到队列中，一个运行在后台的工作者（worker）进程就会取出任务然后处理。当你运行多个工作者（workers），任务就会在它们之间共享。

这个概念在网络应用中是非常有用的，它可以在短暂的 HTTP 请求中处理一些复杂的任务。

消息持久化

        如果你没有特意告诉 RabbitMQ，那么在它退出或者崩溃的时候，将会丢失所有队列和消息。为了确保信息不会丢失，有两个事情是需要注意的：我们必须把 “队列” 和 “消息” 设为持久化。  首先，为了不让队列消失，需要把队列声明为持久化（durable）。

# 持久化一个队列，名为 task_queue
channel.queue_declare(queue='task_queue', durable=True)

并且这个 queue_declare 必须在生产者（producer）和消费者（consumer）对应的代码中修改。这时候，我们就可以确保在 RabbitMq 重启之后 queue_declare 队列不会丢失。另外，我们需要把我们的消息也要设为持久化——将 delivery_mode 的属性设为 2:

#!/usr/bin/env python3
import pika
import sys

connection = pika.BlockingConnection(pika.ConnectionParameters(
        host='localhost'))
channel = connection.channel()

# 持久化一个队列，名为 task_queue
channel.queue_declare(queue='task_queue', durable=True)

message = ' '.join(sys.argv[1:]) or "Hello World!"
channel.basic_publish(exchange='',
                      routing_key='task_queue',
                      body=message,
                      properties=pika.BasicProperties(
                         # 消息持久化
                         delivery_mode = 2,
                      ))
print(" [x] Sent %r" % message)

# 关闭连接
connection.close()

注意：消息持久化

将消息设为持久化并不能完全保证不会丢失。以上代码只是告诉了 RabbitMq 要把消息存到硬盘，但从 RabbitMq 收到消息到保存之间还是有一个很小的间隔时间。因为 RabbitMq 并不是所有的消息都使用 fsync(2) —— 它有可能只是保存到缓存中，并不一定会写到硬盘中。并不能保证真正的持久化，但已经足够应付我们的简单工作队列。如果你一定要保证持久化，你需要改写你的代码来支持事务（transaction）。

公平调度

比如有两个工作者（workers），处理奇数消息的比较繁忙，处理偶数消息的比较轻松。然而 RabbitMQ 并不知道这些，它仍然一如既往的派发消息。

这时因为 RabbitMQ 只管分发进入队列的消息，不会关心有多少消费者（consumer）没有作出响应。它盲目的把 n-th 条消息发给第 n-th 个消费者。

我们可以使用 basic.qos 方法，并设置 prefetch_count=1。这样是告 RabbitMQ ，在同一时刻，不要发送超过 1 条消息给一个工作者（worker），直到它已经处理了上一条消息并且作出了响应。这样，RabbitMQ 就会把消息分发给下一个空闲的工作者

如果所有的工作者都处理繁忙状态，你的队列就会被填满。你需要留意这个问题，要么添加更多的工作者（workers），要么使用其他策略。

 交换机

前面的教程中，我们发送消息到队列，并从中取出消息。现在是时候介绍 RabbitMQ 中完成的消息模型了。

让我们简单的概括一下之前的教程：

• 发布者（producer)：发布消息的应用程序
• 队列（queue）：用于消息存储的缓冲
• 消费者（consumer）：接收消息的应用程序

RabbitMQ 消息模型的核心理念是：发布者（producer）不会直接发送任何消息给队列。事实上，发布者（producer）甚至不知道消息是否已经被投递到队列。

发布者（producer）只需把消息发送给一个交换机（exchange）。交换机非常简单，它一边从发布者接收消息，一边把消息消息推送到队列。交换机必须知道如何处理它接收的消息，是应该推送到指定的队列还是多个队列，或者是直接忽略消息。这些规则是通过交换机类型（exchange type）来定义的。

有几个可供选择的交换机类型：直连交换机（direct），主题交换机（topic），头交换机（headers）和扇形交换机（fanout）。

我们在这里主要说明最后一个 -- 扇形交换机。先创建一个 fanout 类型的交换机，命名为 logs ：

channel.exchange_declare(exchange='logs',
                         type='fanout')

 完整的代码为

#!/usr/bin/env python3
import pika

connection = pika.BlockingConnection(
    pika.ConnectionParameters(host='localhost'))
channel = connection.channel()

channel.exchange_declare(exchange='logs', exchange_type='fanout')

connection.close()

这段代码在之后的 emit_log.py 和 receive.py 中都要使用。等下我们要列出交换机，因此可以保存为 create_exchange.py ，并使用 python3 create_exchange.py 执行它。

扇形交换机（fanout）很简单，你可能从名字上就能猜测出来，它把消息发送给所有的队列，这正是我们日志系统所需要的。

交换机列表

rabbitmqctl 能够列出服务器上所有的交换机：

sudo service rabbitmq-server start

sudo rabbitmqctl list_exchanges

这个列表中有一些叫做 amq.* 的交换机。这些都是默认创建的，不过这时候你还不需要它们。

可以看到我们之前执行了 python3 create_exchange.py，已经创建了类型为 fanout 的 logs 交换机。

匿名的交换机

前面的教程中我们对交换机一无所知，但仍然能够发送消息到队列中。因为我们使用了命名为空字符串（""）默认的交换机。

之前我们是这么发送消息的：

channel.basic_publish(exchange='',routing_key='hello',body=message)

exchange 参数就是交换机的名字。空字符串代表默认或者匿名交换机：消息将会根据指定的 routing_key 分发到指定的队列。

现在，我们就可以发送消息到一个具体名字的交换机了：

channel.basic_publish( exchange='logs', routing_key='hello',body=message)

临时队列

你还记得我们使用的队列名吗：hello 和 task_queue。

给一个队列命名是很重要的。我们需要把工作者（workers）指向正确的队列。如果你打算在发布者（producers）和消费者（consumers）之间共享队列的话，给队列命名是十分重要的。

但是这并不适合我们的日志系统。我们打算接收所有的日志消息，而不仅仅是一小部分。我们关心的是最近的消息而不是久的。为了解决这个问题，我们需要做两件事情。

第一步，当我们连接上 RabbitMQ 的时候，我们需要一个全新的，空的队列。我们可以手动创建一个随机的队列名，或者让服务器为我们选择一个随机的队列名（推荐）。我们只需要在调用 queue_declare 方法的时候，不提供 queue 参数就可以了：

result = channel.queue_declare()

这时候我们可以通过 result.method.queue 获得已经生成的随机队列名。它可能是这样子的：amq.gen-U0srCoW8TsaXjNh73pnVAw==。

第二步，当与消费者（consumer）断开连接的时候，这个队列应当被立即删除。 exclusive 标识符即可达到此目的。

绑定

我们已经创建了一个扇形交换机（ fanout ）和一个队列。现在我们需要告诉交换机如何发送消息给我们的队列。

交换机和队列之间的联系我们称之为绑定（ binding ）。

channel.queue_bind(exchange='logs',queue=result.method.queue)

现在，logs 交换机将会把消息加到我们的队列中。

发布日志消息的程序看起来和之前的没有太大区别。最重要的改变就是我们把消息发送给 logs 交换机而不是匿名交换机。在发送的时候我们需要提供 routing_key 参数，但是它的值会被扇形交换机（fanout exchange）忽略。以下是 emit_log.py 脚本，编写源代码文件 ：

#!/usr/bin/env python3
import pika
import sys

connection = pika.BlockingConnection(
    pika.ConnectionParameters(host='localhost'))
channel = connection.channel()

channel.exchange_declare(exchange='logs', exchange_type='fanout')

message = ' '.join(sys.argv[1:]) or "info: Hello World!"
channel.basic_publish(exchange='logs', routing_key='', body=message)
print(" [x] Sent %r" % message)
connection.close()

正如你看到的那样，在连接成功以后，我们声明了一个交换机，这一个很重要的，因为不允许发布消息到不存在的交换机。

如果没有绑定队列到交换器，消息将会丢失。但这个没有所谓，如果没有消费者监听，那么消息就会被忽略。receive_logs.py 的代码，编写源代码文件：

#!/usr/bin/env python3
import pika

connection = pika.BlockingConnection(
    pika.ConnectionParameters(host='localhost'))
channel = connection.channel()

channel.exchange_declare(exchange='logs', exchange_type='fanout')

result = channel.queue_declare(queue='', exclusive=True)
queue_name = result.method.queue

channel.queue_bind(exchange='logs', queue=queue_name)

print(' [*] Waiting for logs. To exit press CTRL+C')


def callback(ch, method, properties, body):
    print(" [x] %r" % body)


channel.basic_consume(
    queue=queue_name, on_message_callback=callback, auto_ack=True)

channel.start_consuming()

绑定（ binding ）是指交换机（ exchange ）和队列（ queue ）的关系。可以简单理解为：这个队列（ queue ）对这个交换机（ exchange ）的消息感兴趣。

绑定的时候可以带上一个额外的 routing_key 参数。为了避免 basic_publish 的参数混淆，我们把它叫做绑定键（ binding key ）。以下是如何创建一个带绑定键的绑定。

channel.queue_bind(exchange=exchange_name,
                   queue=queue_name,
                   routing_key='black')

绑定键的意义取决于交换机（ exchange ）的类型。比如扇型交换机（ fanout exchanges ）会忽略这个值。

直连交换机

在上一节中，我们设计的日志系统广播所有的消息给所有的消费者（ consumers ）。我们打算扩展它，使其基于日志的严重程度进行消息过滤。例如我们也许只是希望将比较严重的错误（error）日志写入磁盘，对于警告（ warning ）或者信息（info）日志我们不写入磁盘，避免浪费磁盘空间。

我们使用的扇型交换机（ fanout exchange ）没有足够的灵活性 —— 它能做的仅仅是广播。

我们将会使用直连交换机（ direct exchange ）来代替。路由的算法很简单 —— 交换机将会对绑定键（ binding key ）和路由键（routing key ）进行精确匹配，从而确定消息该分发到哪个队列。

下图能够很好的描述这个场景：

在这个场景中，我们可以看到直连交换机 X 和两个消息队列进行了绑定。第一个队列使用 orange 作为绑定键，第二个队列有两个绑定键，一个使用 black 作为绑定键，另一个使用 green 。

这样以来，当路由键为 orange 的消息发布到交换机，就会被路由到 Q1 。路由键为 black 或者 green 的消息就会路由到 Q2。其他的所有消息都将会被丢弃。

多个队列使用相同的绑定键是合法的。这个例子中，我们可以添加一个 X 和 Q1 之间的绑定，使用 black 绑定键。这样一来，直连交换机就和扇形交换机的行为一样，会将消息广播到所有匹配的队列。带有 black 路由键的消息会同时发送到 Q1 和 Q2。

发送日志

        我们将会发送消息到一个直连交换机（不能使用之前的 fanout 交换机），把日志级别作为路由键。这样接收日志的脚本就可以根据严重级别来选择它想要处理的日志。我们先看看发送日志。

我们需要创建一个交换机（ exchange ）：

channel.exchange_declare(exchange='direct_logs',
                         type='direct')

然后我们发送一条消息：

channel.basic_publish(exchange='direct_logs',
                      routing_key=severity,
                      body=message)

我们先假设日志的 "严重级别" 的值为 info、warning、error 中的一个。

订阅

        处理接收消息的方式和之前差不多。但在本程中，我们将会为我们感兴趣的每个严重级别（info、warning、error）分别创建一个新的绑定。

result = channel.queue_declare(queue='', exclusive=True)
queue_name = result.method.queue

for severity in severities:
    channel.queue_bind(exchange='direct_logs',
                       queue=queue_name,
                       routing_key=severity)