Python RabbitMQ原理和使用场景以及模式

RabbitMQ 是实现了高级消息队列协议（AMQP）的开源消息代理软件。

一、RabbitMQ 原理简介

1. RabbitMQ 角色

  • 生产者：消息的创建者，负责创建和推送数据到消息服务器；
  • 消费者：消息的接收方，用于处理数据和确认消息；
  • 代理：就是RabbitMQ本身，负责消息的传递。

2. 连接 RabbitMQ 方式

客户端通过 TCP 连接到 RabbitMQ Server。
连接成功后 RabbitMQ 会创建一个 AMQP 信道。
信道是创建在 TCP 上的虚拟连接，AMQP 命令都是通过信道发送出去的，每个信道都会有一个唯一的 ID，不论是发布消息，订阅队列或者介绍消息都是通过信道完成的。

3. RabbitMQ 中的关键词

  • Producer （生产者）：消息生产者
  • Consumer（消费者）：消息的消费者
  • Connection（连接）：就是一个TCP的连接，Producer 和 Consumer 都是通过 TCP 连接到 RabbitMQ Server 的。
  • Channel（信道）：他是虚拟连接，他建立在 Connection 的 TCP 连接中。也就是说他是消息推送使用的通道；
  • Exchange（交换器）：是生产者发布消息的通道，接收生产者消息并将消息路由到消息队列；
  • Queue（队列）：是消费者接受消息的通道，用于存储生产者的消息；
  • RoutingKey（路由键）：用于把生成者的数据分配到交换器上；
  • BindingKey（绑定键）：用于把交换器的消息绑定到队列上；

4. RabbitMQ 消息持久化

RabbitMQ 会将持久化的消息写入磁盘上的持久化日志文件，等消息被消费之后，RabbitMQ 会把这条消息标识为等待垃圾回收。

RabbitMQ 默认情况下是关闭消息持久化的。需要在创建队列的时候设置。

设置如下：

  • 队列持久化 durable=True 消息的生产者和接收者都需要设置队列持久化
# durable=True 队列持久化
channel.queue_declare(queue='test', durable=True)

只做队列持久化是不行的还需要在加上消息持久化

  • 消息持久化 delivery_mode=2 
channel.basic_publish(
    exchange="",
    routing_key="test", 
    body="hello world",
    properties=pika.BasicProperties(delivery_mode=2,) 
)
  • 消息持久化的缺点
    因为要写入硬盘要比写入内存性能较低很多，从而降低了服务器的吞吐量。

4. RabbitMQ 虚拟主机

  • 虚拟主机概念

虚拟主机是 RabbitMQ 创建的虚拟消息服务器。为了在一个 RabbitMQ 上实现多用户隔离。为此提供了一个虚拟主机（virtual hosts - vhosts）的概念。

二、RabbitMQ 模式

前三个说的是 RabbitMQ 的 Exchange 的类型。RPC 是消费者和生产者互通的一种方式。

1. Direct 直连交换机

当一个绑定了 routing_key = 1 的消息被发送给直连交换机时，交换机会把消息发送给绑定了routing_key = 1的队列。

直连交换机经常用来循环分发任务给多个消费者。然后消息的负载均衡是发生在消费者之间的，而不是队列之间。
如下例：

消息生产者

import pika

config = pika.ConnectionParameters(
    host='127.0.0.1',
    credentials=pika.PlainCredentials('test', 'test'),
)

# 创建 MQ 连接
conn = pika.BlockingConnection(config)
channel = conn.channel()

# 在频道中创建一个队列
channel.exchange_declare(exchange='ceshi', type='direct')

# 发送消息到指定队列
# exchange 指定交换器
# routing_key 设置路由键
# body 发送的内容
channel.basic_publish(
    exchange='ceshi',
    routing_key='1',
    body='Hello World!'
)

conn.close()

消息消费者

import pika

config = pika.ConnectionParameters(
    host='127.0.0.1',
    port=5672,
    credentials=pika.PlainCredentials('test', 'test'),
)

# 创建 MQ 连接
conn = pika.BlockingConnection(config)
channel = conn.channel()

# 如果使用exchange， 这里检测 exchange 是否存在，如不存在创建。存在检测是否正确且是否符合 exchange_type 类型
channel.exchange_declare(exchange='ceshi', exchange_type='direct')

# 在频道中创建一个队列
channel.queue_declare(queue='hello')

# 将队列绑定到指定的 exchange
# routing_key 类似密钥，只接收 routing_key 正确的信息
channel.queue_bind(exchange='ceshi', queue='hello', routing_key='1')

# 回调函数四个必须的参数 body 是传入的内容
# channel: BlockingChannel
# method: spec.Basic.Deliver
# properties: spec.BasicProperties
# body: str or unicode
def callback(channel, method, properties, body):
    print channel
    print method
    print properties
    print body

# 指定队列调用的函数
# no_ack 参数 True 时处理完成后没有返回信息。False 时在处理完后应答
channel.basic_consume(
    callback,
    queue='hello',
    no_ack=False
)
print 'waiting ...'
channel.start_consuming()

\color{red}{注意}：在修改消费者的routing_key后，需要重新创建队列。

2. Fanout 扇型交换机（订阅者模式）

他回将消息发送给绑定到它身上的所有队列，而不理会绑定的路由键。

如果 N 个队列绑定到某个扇型交换机上，当有消息发送给此扇型交换机时，交换机会将消息的拷贝分别发送给这所有的N个队列。

扇型交换机实现消息的广播。

以下几个应用场景

  • 体育比赛用它来给手机客户端发送比分数据
  • 广播各种状态和产品的更新
  • 在群聊时分发消息给群聊中的用户

消息生产者

#!coding=utf-8
import pika

config = pika.ConnectionParameters(
    host='127.0.0.1',
    credentials=pika.PlainCredentials('test', 'test'),
)

conn = pika.BlockingConnection(config)
channel = conn.channel()

# 修改 type 为 fanout
channel.exchange_declare(exchange='ceshi2', type='fanout')

channel.basic_publish(
    exchange='ceshi2',
    routing_key='',
    body='Hello World!'
)

conn.close()

在生产者中只需要修改 exchange_declare 他的 type 为 fanout 即可

消息消费者

#! coding=utf-8
import pika

config = pika.ConnectionParameters(
    host='127.0.0.1',
    port=5672,
    credentials=pika.PlainCredentials('test', 'test'),
)

conn = pika.BlockingConnection(config)
channel = conn.channel()
channel.exchange_declare(exchange='ceshi2', exchange_type='fanout')

# 订阅者模式
# 生成随机 queue_name
# 订阅者之间的 queue name 不能重复
result = channel.queue_declare(exclusive=True)
queue_name = result.method.queue
channel.queue_bind(exchange='ceshi2', queue=queue_name, routing_key='')

def callback(channel, method, properties, body):
    print channel
    print method
    print properties
    print body

channel.basic_consume(
    callback,
    queue=queue_name,
    no_ack=False
)
print 'waiting ...'
channel.start_consuming()

3. Topic 主题交换机（模糊匹配）

通过发送者和接收者之间的 routing_key 相互匹配，将消息路由给一个或多个队列。

主题交换机通常用来实现消息的多路由广播

以下应用场景

  • 发布不同分类或者不同标签的新闻（例如，发送游戏类新闻和体育类新闻）
  • 系统中不同种类服务的调用（例如：发布系统和付费系统的调用）

例如：
接收者(消费者) routing_key='a.*'
发送者（生产者） routing_key = 'a.b.c.d'
结果：匹配失败

因为：
* 表示匹配一个单词
# 表示匹配0个或多个单词

消息生产者

#!coding=utf-8
import pika

config = pika.ConnectionParameters(
    host='127.0.0.1',
    credentials=pika.PlainCredentials('test', 'test'),
)

conn = pika.BlockingConnection(config)
channel = conn.channel()

# 修改 type 为 topic
channel.exchange_declare(exchange='ceshi3', type='topic')

channel.basic_publish(
    exchange='ceshi3',
    routing_key='a.b.c.d',
    body='Hello World!'
)

conn.close()

消息消费者

#! coding=utf-8
import pika

config = pika.ConnectionParameters(
    host='127.0.0.1',
    port=5672,
    credentials=pika.PlainCredentials('test', 'test'),
)

conn = pika.BlockingConnection(config)

channel = conn.channel()

channel.exchange_declare(exchange='ceshi3', exchange_type='topic')
channel.queue_declare(queue='hello')

# routing_key='a.*' 此时是无法接受到信息的，因为生产者发送的是 a.* a. 后面一个单词。修改 routing_key='a.#' 即可接受成功
channel.queue_bind(exchange='ceshi3', queue='hello', routing_key='a.*')


def callback(channel, method, properties, body):
    print channel
    print method
    print properties
    print body

channel.basic_consume(
    callback,
    queue='hello',
    no_ack=False
)
print 'waiting ...'
channel.start_consuming()

4. RPC

生产者发送消息给消费者，并接收消费者处理完的结果
原理：

  1. 生产者会创建一个新的队列，用来接收消费者返回的信息。
  2. 生产者在发送消息的同时，还会发送 1步骤中创建的队列名和一个 correlation_id 用来验证
  3. 当消费者处理完数据后，会把结果和correlation_id发送到 1步骤创建的队列中去
  4. 生产者会使用一个循环 while 来监测返回结果 self.response
  5. 生产者获取到数据后比对 correlation_id 是否一致，然后结束此次发送流程

消息生产者

#! coding=utf-8
import pika
import uuid


class RpcClient(object):
    def __init__(self):
        config = pika.ConnectionParameters(
            host='127.0.0.1',
            credentials=pika.PlainCredentials('test', 'test'),
        )

        self.conn = pika.BlockingConnection(config)
        self.channel = self.conn.channel()

        # 在频道中创建一个队列
        result = self.channel.queue_declare(exclusive=True)

        # 生成队列名
        self.queue_name = result.method.queue

        # 指定队列要调用的函数
        self.channel.basic_consume(
            self.on_request,
            no_ack=True,
            queue=self.queue_name
        )

    def on_request(self, channel, method, props, body):
        if self.corr_id == props.correlation_id:
            self.response = body

    def call(self, message):
        self.response = None
        self.corr_id = str(uuid.uuid4)

        # 发送消息到指定队列
        self.channel.basic_publish(
            exchange='',
            routing_key='rpc',
            # 消费者返回处理结果需要的队列信息(reply_to)和相关 id（correlation_id）.
            # 以便消费者知道返回给那个生产者
            properties=pika.BasicProperties(
                reply_to=self.queue_name,
                correlation_id=self.corr_id
            ),
            body=message
        )

        while self.response is None:
            # 是一个等待消息的阻塞过程，连接的任何消息都可以使它脱离阻塞状态
            self.conn.process_data_events()
        return self.response

fibonacci_rpc = RpcClient()

print "等待处理结果"

response = fibonacci_rpc.call('Hello World!')
print "处理完返回信息: %s" % response

消息消费者

#! coding=utf-8
import pika
import time


config = pika.ConnectionParameters(
    host='127.0.0.1',
    credentials=pika.PlainCredentials('test', 'test'),
)

conn = pika.BlockingConnection(config)
channel = conn.channel()

channel.exchange_declare(exchange='rpc')
channel.queue_declare(queue='rpc')


def on_request(channel, method, props, body):
    print '处理中, 收到内容：%s' % body

    # 发送消息到指定队列
    # exchange 指定 exchange
    # routing_key 设置为队列的名称
    # body 发送的内容
    channel.basic_publish(
        exchange='',
        # props.reply_to 是生产者发送过来 接收处理结果的 指定队列
        routing_key=props.reply_to,
        properties=pika.BasicProperties(correlation_id=props.correlation_id),
        body='处理完成'
    )
    # 告知 rabbit 消息已经处理完
    channel.basic_ack(delivery_tag=method.delivery_tag)

# 使用basic_qos设置prefetch_count=1，使得rabbitmq不会在同一时间给工作者分配多个任务，只有工作者完成任务之后，才会再次接收到任务
channel.basic_qos(prefetch_count=1)

# 接收的结果调用 on_request 函数处理
channel.basic_consume(on_request, queue='rpc')
print("waiting....")

# 开始接收信息，并进入阻塞状态，队列里有信息才会调用callback进行处理
channel.start_consuming()

conn.close()

三、RabbitMQ 使用场景

1. 任务相互依赖

例：

三个任务，任务1、任务2、任务3。他们之间有相互的制约。执行任务1的前提是要有任务2的结果。执行任务2需要任务3的结果。

一般会使用crontab来做计划任务。预估一下每个任务的完成时间。然后制定任务。当数量变大处理时间变成，就需要经常修改crontab任务。

使用 RabbitMQ 后每个任务结束时只需要发送一个结束信息即可

如：任务2订阅任务3的信息。当任务3完成后发送一个完成消息。任务2接收到完成消息后开始执行，在执行结束后发送任务2完成消息。任务1订阅任务2的消息，然后执行。

优点：
  • 任务执行时间发生变化，不需要修改 crontab 任务
  • 每个任务之间的预留时间没有了

2. 下发任务后不关心结果

例：

有三个用户A、B、C 他们分别发送文章，但后台会根据用户的级别做不同的操作。
A 是普通用户，系统发布。
B 是 VIP 用户，系统发布和推荐给关注这部分内容的客户。
C 是黑卡客户，系统发布、推荐给关注这部分内容的客户、在这个分类中置顶这篇文章。
文章发布服务只关心是否成功，剩下的操作都不关心。可以使用 RabbitMQ 服务将其他操作分离。

优点：
  • 减少发布时间，只操作发布，其他操作由别的系统执行。
  • 解耦，系统之间不在直接关联。
  • 新增发布以后的其他操作不需要在修改发布系统代码。

3. 任务执行时间很长还需要等待结果

例：

有一个操作 A。用户执行这个任务后，又非常需要结果。

解决方法：
  1. 用户调用操作 A。
  2. 操作 A 直接返回调用成功。此时只是调用成功。
  3. 操作 A 告诉后台应该执行什么程序。
  4. 后台执行完成后，将完成消息发送给 RabbitMQ。
  5. 用户订阅 RabbitMQ 中的操作 A 的消息。

为什么不是后台直接将结果发送给用户呢。因为一旦增加了订阅用户，就需要修改后台程序，这样很恶心。

四、开启 WEB 服务

RabbitMQ 自带管理后台，安装后需要配置开启

进入 RabbitMQ 安装目录中的 sbin 目录执行

rabbitmq-plugins enable rabbitmq_management

http://localhost:15672/

用户名密码均为guest

最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 158,736评论 4赞 362
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 67,167评论 1赞 291
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 108,442评论 0赞 243
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 43,902评论 0赞 204
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 52,302评论 3赞 287
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 40,573评论 1赞 216
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 31,847评论 2赞 312
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 30,562评论 0赞 197
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 34,260评论 1赞 241
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 30,531评论 2赞 245
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 32,021评论 1赞 258
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 28,367评论 2赞 253
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 33,016评论 3赞 235
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 26,068评论 0赞 8
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 26,827评论 0赞 194
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 35,610评论 2赞 274
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 35,514评论 2赞 269