RabbitMQ
Python实现的消息队列
一、消息队列介绍
MQ全称为Message Queue 消息队列（MQ）是一种应用程序对应用程序的通信方法。MQ是消费-生产者模型的一个典型的代表，一端往消息队列中不断写入消息，而另一端则可以读取队列中的消息。这样发布者和使用者都不用知道对方的存在。
生产者消费者模式是通过一个容器来解决生产者和消费者的强耦合问题。生产者和消费者彼此之间不直接通讯，而通过阻塞队列来进行通讯，所以生产者生产完数据之后不用等待消费者处理，直接扔给阻塞队列，消费者不找生产者要数据，而是直接从阻塞队列里取，阻塞队列就相当于一个缓冲区，平衡了生产者和消费者的处理能力。
我们先不管消息(Message)这个词，来看看队列(Queue)。这一看，队列大家应该都熟悉吧。
队列是一种先进先出的数据结构。
消息队列可以简单理解为：把要传输的数据放在队列中。
二、为什么需要MQ
消息队列中间件是分布式系统中重要的组件，主要解决应用解耦，异步消息，流量削锋等问题，实现高性能，高可用，可伸缩和最终一致性架构。目前使用较多的消息队列有ActiveMQ，RabbitMQ，ZeroMQ，Kafka，MetaMQ，RocketMQ。
接下来利用一个外卖系统的消息推送给大家解释下MQ的意义。
订单系统做为生产者将数据存放到消息队列中，消费者利用订阅模式从消息队列中取数据，从而实现解耦。
三、rabbitMQ
3.1、RabbitMQ介绍
RabbitMQ 是一个由 Erlang 语言开发的 AMQP 的开源实现。
rabbitMQ是一款基于AMQP协议的消息中间件，它能够在应用之间提供可靠的消息传输。在易用性，扩展性，高可用性上表现优秀。使用消息中间件利于应用之间的解耦，生产者（客户端）无需知道消费者（服务端）的存在。而且两端可以使用不同的语言编写，大大提供了灵活性。
3.2、RabbitMQ下载
1.重启rabbitmq服务通过两个命令来实现：
rabbitmqctl stop ：停止rabbitmq
rabbitmq-server restart : 重启rabbitmq
2.以服务方式启动
rabbitmq-service install 安装服务
rabbitmq-service start 开始服务
Rabbitmq-service stop 停止服务
3.Rabbitmq 管理插件启动，可视化界面
rabbitmq-plugins enable rabbitmq_management 启动
rabbitmq-plugins disable rabbitmq_management 关闭
4.Rabbitmq节点管理方式
Rabbitmqctl
5.插件启动
rabbitmq-plugins disable rabbitmq_delayed_message_exchange
rabbitmq-plugins enable rabbitmq_delayed_message_exchange
3.3 、rabbitMQ简单模式
# 简单模式
# 生产者：
# 1.连接rabbitmq
# 2.创建队列
# 3.向指定的队列插入数据
# 消费者：
# 1.连接rabbitmq
# 2.监听模式
# 3.确定回调函数
# 参数使用
# 1. 应答参数
channel.basic_consume(queue='hello',
auto_ack=Flase, # 默认应答改为手动应答
on_message_callback=callback)
def callback(ch, method, properties, body):
print(" [x] Received %r" % body)
ch.basic_ack(delivery_tag=method.delivery_tag)
# 2.持久化参数
#声明queue
channel.queue_declare(queue='hello2', durable=True) # 若声明过，则换一个名字
channel.basic_publish(exchange='',
routing_key='hello2',
body='Hello World!',
properties=pika.BasicProperties(
delivery_mode=2, # make message persistent
)
)
# 交换机模式
### 生产者
import pika
# 1.连接rabbitmq
connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()
# 2.创建队列(声明一个队列的名称)
channel.queue_declare(queue='hello')
# 3.向指定的队列插入数据
channel.basic_publish(exchange='', # exchange为空代表简单模式
routing_key='hello', # 指定队列
body='Hello World!') # 插入的数据
print(" [x] Sent 'Hello World!'")
### 消费者
import pika
# 1.连接rabbitmq
connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()
# 2.如果没有队列则创建队列，有队列则不执行(避免启动顺序先后问题)
channel.queue_declare(queue='hello')
# 3.确定回调函数
def callback(ch, method, properties, body):
print(" [x] Received %r" % body)
# 4.确定监听队列参数
channel.basic_consume(queue='hello',
auto_ack=True, # 默认应答
on_message_callback=callback)
print(' [*] Waiting for messages. To exit press CTRL+C')
# 5.正式监听启动
channel.start_consuming()
3.3 、参数
- 应答参数
auto_ack=False # 默认应答改为手动应答
ch.basic_ack(delivery_tag=method.delivery_tag) # 配置到回调函数中，逻辑执行完毕会删除队列中的那条数据
- 持久化参数
#声明queue
#创建可持久化队列
channel.queue_declare(queue='hello2', durable=True) # 若声明过，则换一个名字
channel.basic_publish(exchange='',
routing_key='hello2',
body='Hello World!',
properties=pika.BasicProperties(
delivery_mode=2, # make message persistent(让消息持久化)
)
)
- 分发参数
有两个消费者同时监听一个的队列。其中一个线程sleep2秒，另一个消费者线程sleep1秒，但是处理的消息是一样多。这种方式叫轮询分发（round-robin）不管谁忙，都不会多给消息，总是你一个我一个。想要做到公平分发（fair dispatch），必须关闭自动应答ack，改成手动应答。使用basicQos(perfetch=1)限制每次只发送不超过1条消息到同一个消费者，消费者必须手动反馈告知队列，才会发送下一个。
channel.basic_qos(prefetch_count=1) # 公平分发(在消费者中加上)
3.4 、交换机之发布订阅
发布订阅和简单的消息队列区别在于，发布订阅会将消息发送给所有的订阅者，而消息队列中的数据被消费一次便消失。所以，RabbitMQ实现发布和订阅时，会为每一个订阅者创建一个队列，而发布者发布消息时，会将消息放置在所有相关队列中。
# 生产者
import pika
# 1.连接rabbitmq
connection = pika.BlockingConnection(pika.ConnectionParameters(
host='localhost'))
channel = connection.channel()
# 2.声明一个名为logs类型为fanout的交换机
channel.exchange_declare(exchange='logs',
exchange_type='fanout') # fanout：发布订阅模式参数
# 3.向logs交换机插入数据
message = "info: Hello World!"
channel.basic_publish(exchange='logs',
routing_key='',
body=message)
print(" [x] Sent %r" % message)
connection.close()
# 消费者
import pika
# 1.连接rabbitmq
connection = pika.BlockingConnection(pika.ConnectionParameters(host='localhost'))
channel = connection.channel()
# 2.声明一个名为logs类型为fanout的交换机(如果没有则创建,有则不执行,避免启动顺序先后问题)
channel.exchange_declare(exchange='logs',
exchange_type='fanout')
# 3.创建队列
result = channel.queue_declare("",exclusive=True) # 随机取名
queue_name = result.method.queue # 拿到随机的名字
print(queue_name)
# 4.将指定队列绑定到交换机上
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,
auto_ack=True,
on_message_callback=callback)
channel.start_consuming()
3.5、交换机之关键字
# 生产者
import pika
connection = pika.BlockingConnection(pika.ConnectionParameters(
host='localhost'))
channel = connection.channel()
channel.exchange_declare(exchange='logs2',
exchange_type='direct') # 交换机模式改为 direct
message = "info: Hello Yuan!"
channel.basic_publish(exchange='logs2',
routing_key='info', # 绑定的关键字
body=message)
print(" [x] Sent %r" % message)
connection.close()
# 消费者
import pika
import sys
connection = pika.BlockingConnection(pika.ConnectionParameters(
host='localhost'))
channel = connection.channel()
channel.exchange_declare(exchange='logs2',
exchange_type='direct') # 交换机模式改为 direct
result = channel.queue_declare("",exclusive=True)
queue_name = result.method.queue
severities = sys.argv[1:]
if not severities:
sys.stderr.write("Usage: %s [info] [warning] [error]\n" % sys.argv[0])
sys.exit(1)
for severity in severities:
channel.queue_bind(exchange='logs2',
queue=queue_name,
routing_key=severity) # 绑定的关键字
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,
auto_ack=True,
on_message_callback=callback)
channel.start_consuming()
3.6、交换机之通配符
通配符交换机”与之前的路由模式相比，它将信息的传输类型的key更加细化，以“key1.key2.keyN….”的模式来指定信息传输的key的大类型和大类型下面的小类型，让消费者可以更加精细的确认自己想要获取的信息类型。而在消费者一段，不用精确的指定具体到哪一个大类型下的小类型的key，而是可以使用类似正则表达式(但与正则表达式规则完全不同)的通配符在指定一定范围或符合某一个字符串匹配规则的key，来获取想要的信息。
“通配符交换机”（Topic Exchange）将路由键和某模式进行匹配。此时队列需要绑定在一个模式上。符号“#”匹配一个或多个词，符号“”仅匹配一个词。因此“audit.#”能够匹配到“audit.irs.corporate”，但是“audit.”只会匹配到“audit.irs”。（这里与我们一般的正则表达式的“*”和“#”刚好相反，这里我们需要注意一下。） 下面是一个解释通配符模式交换机工作的一个样例
上面的交换机制类似于一个国际新闻讯息网站的机制。
# 生产者
import pika
connection = pika.BlockingConnection(pika.ConnectionParameters(
host='localhost'))
channel = connection.channel()
channel.exchange_declare(exchange='logs3',
exchange_type='topic') # 交换机模式，模糊匹配
message = "info: Hello ERU!"
channel.basic_publish(exchange='logs3',
routing_key='europe.weather',
body=message)
print(" [x] Sent %r" % message)
connection.close()
# 消费者
import pika
import sys
connection = pika.BlockingConnection(pika.ConnectionParameters(
host='localhost'))
channel = connection.channel()
channel.exchange_declare(exchange='logs3',
exchange_type='topic') # 交换机模式，模糊匹配
result = channel.queue_declare("",exclusive=True)
queue_name = result.method.queue
channel.queue_bind(exchange='logs3',
queue=queue_name,
routing_key="#.news")
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,
auto_ack=True,
on_message_callback=callback)
channel.start_consuming()py
浙公网安备 33010602011771号