rabbitMQ
什么是消息队列（MQ）
MQ全称为Message Queue 消息队列（MQ）是一种应用程序对应用程序的通信方法。MQ是消费-生产者模型的一个典型的代表，一端往消息队列中不断写入消息，而另一端则可以读取队列中的消息。这样发布者和使用者都不用知道对方的存在。
'''
生产者消费者模式是通过一个容器来解决生产者和消费者的强耦合问题。生产者和消费者彼此之间不直接通讯，而通过阻塞队列来进行通讯，所以生产者生产完数据之后不用等待消费者处理，直接扔给阻塞队列，消费者不找生产者要数据，而是直接从阻塞队列里取，阻塞队列就相当于一个缓冲区，平衡了生产者和消费者的处理能力。
'''
我们先不管消息(Message)这个词，来看看队列(Queue)。这一看，队列大家应该都熟悉吧。
队列是一种先进先出的数据结构。
消息队列可以简单理解为：把要传输的数据放在队列中。
为什么要用消息队列
消息队列主要解决应用解耦、异步消息、流量削锋等问题，实现高性能、高可用、可伸缩和最终一致性架构。目前使用较多的消息队列有ActiveMQ，RabbitMQ，ZeroMQ，Kafka，MetaMQ，RocketMQ。
应用解耦
场景：以电商平台为例，当产生订单后，需要订单系统调用库存系统。传统的做法就是订单系统直接调用库存系统，但有个缺点，假如库存系统无法访问，则订单减库存将失败，从而导致订单失败。所以，订单系统与库存系统解耦合。
订单系统：用户下单后，订单系统完成持久化处理，将消息写入消息队列，返回用户订单下单成功。
库存系统：订阅下单的消息，采用拉/推的方式，获取下单信息，库存系统根据下单信息，进行库存操作。
假如：在下单时库存系统不能正常使用。也不影响正常下单，因为下单后，订单系统写入消息队列就不再关心其他的后续操作了，实现订单系统与库存系统的应用解耦。
异步消息
场景说明：用户注册后，需要发注册邮件和注册短信。传统的做法有两种：
- 串行方式：将注册信息写入数据库成功后，发送注册邮件，再发送注册短信。以上三个任务全部完成后，返回给客户端。
- 并行方式：将注册信息写入数据库成功后，发送注册邮件的同时，发送注册短信。以上三个任务完成后，返回给客户端。与串行的差别是，并行的方式可以提高处理的时间。
假设三个业务节点每个使用50毫秒钟，不考虑网络等其他开销，则串行方式的时间是150毫秒，并行的时间可能是100毫秒。
问题来了，如何提高性能？答案是引入消息队列，如下图进行架构改造：
按照以上约定，用户的响应时间相当于是注册信息写入数据库的时间，也就是50毫秒。注册邮件，发送短信写入消息队列后，直接返回，因此写入消息队列的速度很快，基本可以忽略，因此用户的响应时间可能是50毫秒。因此架构改变后，异步的效率比串行提高了三倍，比并行提高了两倍。
流量削峰
场景：秒杀活动，一般会因为流量过大，导致流量暴增，应用挂掉。为解决这个问题，一般需要在应用前端加入消息队列。
其中：
- 消息队列发挥的作用：
- 可以控制活动的人数
- 可以缓解短时间内高流量压垮应用
- 用户的请求，服务器接收后，首先写入消息队列。假如消息队列长度超过最大数量，则直接抛弃用户请求或跳转到错误页面。
- 秒杀业务根据消息队列中的请求信息，再做后续处理。
rabbitmq的使用
简单模式
生产者：
1 链接rabbitmq
2 创建队列
3 向指定的队列插入数据
消费者
1 链接rabbitmq
2 监听模式
3 确定回调函数
producer.py 生产者
import pika
# 1 链接rabbitmq
connection = pika.BlockingConnection(pika.ConnectionParameters('127.0.0.1'))
channel = connection.channel()
# 2 创建队列
channel.queue_declare(queue='hello')
# 3 向指定队列插入数据
channel.basic_publish(exchange='', # 简单模式exchange为空
routing_key='hello', # 指定队列
body='Hello Yuan!')
print(" [x] Sent 'Hello Yuan!'")
consumer.py 消费者
import pika
connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()
# 创建队列，如果生产者创建了队列就不执行此代码，为了必须确保有 ‘hello’这个队列存在
channel.queue_declare(queue='hello')
# 确定回调函数
def callback(ch, method, properties, body):
print(" [x] Received %r" % body)
# 确定监听队列参数
channel.basic_consume(queue='hello',
auto_ack=True, # 默认应答
on_message_callback=callback)
print(' [*] Waiting for messages. To exit press CTRL+C')
# 正式监听
channel.start_consuming()
参数
应答参数
默认应答：如果在消费者运行的时候产生bug，就会导致生产者的数据已经取出而消费者没有拿到，从而产生数据丢失的问题。
解决办法：改为手动应答
auto_ack=False
然后在回调函数下加一句话：
ch.basic_ack(delivery_tag=method.delivery_tag) # 必须等待消息处理完成且没发生报错才做应答（手动ack
producer.py 生产者
import pika
# 1 链接rabbitmq
connection = pika.BlockingConnection(pika.ConnectionParameters('127.0.0.1'))
channel = connection.channel()
# 2 创建队列
channel.queue_declare(queue='hello')
# 3 向指定队列插入数据
channel.basic_publish(exchange='', # 简单模式exchange为空
routing_key='hello', # 指定队列
body='Hello Yuan!')
print(" [x] Sent 'Hello Yuan!'")
consumer.py 消费者
import pika
connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()
# 创建队列
channel.queue_declare(queue='hello')
# 确定回调函数
def callback(ch, method, properties, body):
print(" [x] Received %r" % body)
ch.basic_ack(delivery_tag=method.delivery_tag)
# 确定监听队列参数
channel.basic_consume(queue='hello',
auto_ack=False, # 默认应答改为手动应答
on_message_callback=callback)
print(' [*] Waiting for messages. To exit press CTRL+C')
# 正式监听
channel.start_consuming()
持久化参数
当生产者宕机之后数据无法被生产者监听拿到，所以需要持久化将数据存到磁盘，等生产重启的时候就会被消费者拿到数据
1、在生产者创建可持久化队列；2、插入数据时，指定属性为信息持久化
producer.py 生产者
import pika
# 1 链接rabbitmq
connection = pika.BlockingConnection(pika.ConnectionParameters('127.0.0.1'))
channel = connection.channel()
# 2 创可持久化队列,需要更换队列名
channel.queue_declare(queue='hello3',durable=True)
# 3 向指定队列插入数据
channel.basic_publish(exchange='', # 简单模式
routing_key='hello3', # 指定队列
body='Hello ALEX!',
properties=pika.BasicProperties(
delivery_mode=2, # make message persistent 信息持久化
)
)
print(" [x] Sent 'Hello ALEX!'")
consumer.py 消费者
import pika
connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()
# 创建可持久化队列
channel.queue_declare(queue='hello3',durable=True)
# 确定回调函数
def callback(ch, method, properties, body):
print(" [x] Received %r" % body)
ch.basic_ack(delivery_tag=method.delivery_tag)
# 确定监听队列参数
channel.basic_consume(queue='hello3',
auto_ack=False, # 默认应答改为手动应答
on_message_callback=callback)
print(' [*] Waiting for messages. To exit press CTRL+C')
# 正式监听
channel.start_consuming()
分发参数（公平分发）
当生产者把数据放入队列中，有多个生产者。默认会采取轮询的分发方式，假如a生产者启动，b生产者再启动，c生产者最后启动。
那么每次生产者放入一个数据，会按照a,b,c,a,b...的消费者启动顺序依次分发
问题是：假如消费者a启动，再启动b。a消费者处理很慢，b消费者处理很快。会出现，a拿到，b拿到。然后a还没处理忘，b完成了。数据又要给a，只能等a处理完
这种情况下，最好不要采用轮询分发，采用公平分发
改为公平分发模式(只要在消费者中添加 channel.basic_qos(prefetch_count=1) , 生产者代码不变 )
# producer.py
'''
当生产者把数据放入队列中，有多个生产者。默认会采取轮询的分发方式，假如a生产者启动，b生产者再启动，c生产者最后启动。
那么每次生产者放入一个数据，会按照a,b,c,a,b...的消费者启动顺序依次分发
问题是：假如消费者a启动，再启动b。a消费者处理很慢，b消费者处理很快。会出现，a拿到，b拿到。然后a还没处理忘，b完成了。数据又要给a，只能等a处理完
这种情况下，最好不要采用轮询分发，采用公平分发
'''
import pika
# 1 链接rabbitmq
connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()
# 2 创建队列
channel.queue_declare(queue='hello4')
# 3 向指定队列插入数据(向可持久队列插入数据，可以通过properties参数设定插入的数据是否要持久化,不加properties参数就是非持久化数据)
channel.basic_publish(exchange='', # 简单模式，可以设置交换机模式
routing_key='hello4', # 指定队列
body='Hello 111',
) # 向rabbitmq发送的内容
print(" [x] Sent 'Hello Alex!'")
# consumer.py
import pika
import time
connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()
# 创建队列
channel.queue_declare(queue='hello4')
# 确定回调函数
def callback(ch,method,properties,body): # body是拿到的数据
time.sleep(3) # 可以多开几个设定不同的时间,来测试效果
print(' [x] Received %r' % body)
ch.basic_ack(delivery_tag=method.delivery_tag)
# 公平分发
channel.basic_qos(prefetch_count=1)
# 确定监听队列参数(并没有真的监听，只是确定参数)
channel.basic_consume(queue='hello4', # 确定监听的队列
auto_ack=False, # 默认应答改为手动应答
on_message_callback=callback)
print(' [x] Waiting for messages. To exit press CTRL+C')
channel.start_consuming() # 开始监听，会hang住
交换机模式
发布订阅
发布订阅和简单的消息队列区别在于，发布订阅会将消息发送给所有的订阅者，而消息队列中的数据被消费一次便消失。所以，RabbitMQ实现发布和订阅时，会为每一个订阅者创建一个队列，而发布者发布消息时，会将消息放置在所有相关队列中。
1、生产者：连接mq，创建一个交换机，像交换机插入数据
2、消费者：连接mq，每一个消费者单独创建一个队列，用队列绑定交换机，确定回调函数，监听交换机
例如外卖系统，订单信息发给骑士系统，商家系统，后台系统
发布订阅模式代码
# producer.py
import pika
# 链接rabbitmq
connection = pika.BlockingConnection(pika.ConnectionParameters(
host='localhost'
))
channel = connection.channel()
# 声明一个名为logs，类型为fanout的交换机
channel.exchange_declare(exchange='logs', # 交换机的名字
exchange_type='fanout') # fanout:发布订阅模式参数
# 向logs交换机插入数据"info: Hello World!"
message = 'info: Hello World!'
channel.basic_publish(exchange='logs', # 名为logs的交换机
routing_key='',
body=message) # 要插入的数据
print(" [x] Sent %r" % message)
connection.close()
订阅者代码相比于简单模式，多了开头声明(创建交换机)，创建队列名字唯一，绑定队列到指定交换机上
# consumer.py
import pika
# 链接rabbitmq
connection = pika.BlockingConnection(pika.ConnectionParameters(host='localhost'))
channel = connection.channel()
# 声明一个名为logs，类型为fanout的交换机(当消费者先启动,没有交换机时，提前创建交换机，和简单模型里创建队列目的相同)
channel.exchange_declare(exchange='logs', # 交换机的名字
exchange_type='fanout') # fanout:发布订阅模式参数
# 创建队列
result = channel.queue_declare('',exclusive=True) # exclusive为True，系统随机创建一个唯一的名字
queue_name = result.method.queue # 获取创建队列的名字
print(queue_name)
# 将制定队列绑定到交换机上
channel.queue_bind(exchange='logs',
queue=queue_name)
print(' [x] Waiting for messages. To exit press CTRL+C')
def callback(ch,method,properties,body):
print(' [x] Received %r' % body)
channel.basic_consume(queue=queue_name,
auto_ack=True,
on_message_callback=callback)
channel.start_consuming() # 开始监听，会hang住
关键字模式
用于日志系统
案例代码
# producer.py
import pika
# 链接rabbitmq
connection = pika.BlockingConnection(pika.ConnectionParameters(
host='localhost'
))
channel = connection.channel()
# 声明一个名为logs，类型为fanout的交换机
channel.exchange_declare(exchange='logs2', # 交换机的名字
exchange_type='direct') # 关键字模式
# 向logs交换机插入数据"info: Hello World!"
message = 'error: Hello World!'
channel.basic_publish(exchange='logs2', # 名为logs的交换机
routing_key='error', # 发送消息的关键字，如果和消费者绑定交换机的关键字相同，消费者就会收到
body=message) # 要插入的数据
print(" [x] Sent %r" % message)
connection.close()
# consumer.py
import pika
# 链接rabbitmq
connection = pika.BlockingConnection(pika.ConnectionParameters(host='localhost'))
channel = connection.channel()
# 声明一个名为logs，类型为fanout的交换机(当消费者先启动,没有交换机时，提前创建交换机，和简单模型里创建队列目的相同)
channel.exchange_declare(exchange='logs2', # 交换机的名字
exchange_type='direct') # 交换机模式 关键字模式
# 创建队列
result = channel.queue_declare('',exclusive=True) # exclusive为True，系统创建一个唯一的名字
queue_name = result.method.queue # 获取创建队列的名字
print(queue_name)
# 将制定队列绑定到交换机上，绑定关键字，如果要绑定多个关键字要重复绑定语句，可以用for循环
channel.queue_bind(exchange='logs2',
queue=queue_name,
routing_key='error') # 绑定关键字
channel.queue_bind(exchange='logs2',
queue=queue_name,
routing_key='info') # 绑定关键字
channel.queue_bind(exchange='logs2',
queue=queue_name,
routing_key='warning') # 绑定关键字
print(' [x] Waiting for messages. To exit press CTRL+C')
def callback(ch,method,properties,body):
print(' [x] Received %r' % body)
channel.basic_consume(queue=queue_name,
auto_ack=True,
on_message_callback=callback)
channel.start_consuming() # 开始监听，会hang住
模糊匹配模式
在关键字绑定的基础上，可以多关键字进行模糊匹配。类似正则匹配，但是只有 # 和 * 。"#" 匹配一个或多个单词，"*" 匹配一个词
通配符交换机”与之前的路由模式相比，它将信息的传输类型的key更加细化，以“key1.key2.keyN....”的模式来指定信息传输的key的大类型和大类型下面的小类型，让消费者可以更加精细的确认自己想要获取的信息类型。而在消费者一段，不用精确的指定具体到哪一个大类型下的小类型的key，而是可以使用类似正则表达式(但与正则表达式规则完全不同)的通配符在指定一定范围或符合某一个字符串匹配规则的key，来获取想要的信息。
“通配符交换机”（Topic Exchange）将路由键和某模式进行匹配。此时队列需要绑定在一个模式上。符号“#”匹配一个或多个词，符号“”仅匹配一个词。因此“audit.#”能够匹配到“audit.irs.corporate”，但是“audit.”只会匹配到“audit.irs”。（这里与我们一般的正则表达式的“*”和“#”刚好相反，这里我们需要注意一下。）
下面是一个解释通配符模式交换机工作的一个样例
上面的交换机制类似于一个国际新闻讯息网站的机制.
# producer.py
import pika
# 链接rabbitmq
connection = pika.BlockingConnection(pika.ConnectionParameters(
host='localhost'
))
channel = connection.channel()
# 声明一个名为logs，类型为fanout的交换机
channel.exchange_declare(exchange='logs3', # 交换机的名字
exchange_type='topic') # 通配符模式
# 向logs交换机插入数据"info: Hello World!"
message = 'usa.weather....'
channel.basic_publish(exchange='logs3', # 名为logs的交换机
routing_key='usa.weather',
body=message) # 要插入的数据
print(" [x] Sent %r" % message)
connection.close()
# consumer.py
import pika
# 链接rabbitmq
connection = pika.BlockingConnection(pika.ConnectionParameters(host='localhost'))
channel = connection.channel()
# 声明一个名为logs，类型为fanout的交换机(当消费者先启动,没有交换机时，提前创建交换机，和简单模型里创建队列目的相同)
channel.exchange_declare(exchange='logs3', # 交换机的名字
exchange_type='topic') # 交换机模式 通配符模式
# 创建队列
result = channel.queue_declare('',exclusive=True) # exclusive为True，系统创建一个唯一的名字
queue_name = result.method.queue # 获取创建队列的名字
print(queue_name)
# 将制定队列绑定到交换机上，绑定关键字，如果要绑定多个关键字要重复绑定语句，可以用for循环
channel.queue_bind(exchange='logs3',
queue=queue_name,
routing_key='usa.#') # 绑定关键字
print(' [x] Waiting for messages. To exit press CTRL+C')
def callback(ch,method,properties,body):
print(' [x] Received %r' % body)
channel.basic_consume(queue=queue_name,
auto_ack=True,
on_message_callback=callback)
channel.start_consuming() # 开始监听，会hang住
浙公网安备 33010602011771号