devbox
小小林熬夜学编程
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

rabbitmq工作模式以及python版demo_python rabbitmq demo

作者：小小林熬夜学编程 | 2024-04-24 18:31:49

赞

踩

python rabbitmq demo

1. 基本概念

AMQP协议:  高级消息队列协议, 进程间传递异步消息的一个网络协议, rabbitmq是基于AMQP协议开发的.

大致工作流程: 生产者(Publisher) ---> 交换机(Exchange) ---> 队列(Queue) ---> 消费者(Consumer)

Broker: 代理, 由Exchange和Queue组成. 连接生产者消费者, 实现AMPQ协议中消息队列和路由功能的进程.

Virtual Host: 虚拟主机, 一个虚拟主机里可以有多个Exchange和Queue, 用于权限控制.

Exchange: 交换机, 接收生产者发送的消息, 并且根据routing_key把消息路由到指定的Queue中去.

Queue: 消息队列, 存储待消费的消息. 由headers和body组成, headers包含生产者添加的消息的各种属性参数, body是真正发送的数据内容.

Binding: 通过routing_key将Exchange与Queue绑定. routing_key不能使任意的字符串,一般用“.”分割开, 例如 “register.shanghai”, “register.beijing”, “register.#”正则时 *(星号)代表任意一个单词; #(hash)代表0个或者多个单词

Channel: 信道, 消费者与Broker通信的渠道, 建立在TCP连接上的虚拟连接. 一个TCP连接上可以建立好多信道, 减少系统开销提高性能.

2. 工作模式

概括:

1. 简单模式: 最简单的一对一.

2. 工作队列模式: 一对多. 一个生产者对应多个消费者, 但每条消息只能被其中的一个消费者消费.

轮询分发: 将消息轮流发给每个消费者, 一个消费者处理完才会发送下一个. 例: A消费第1,4,7...条消息, B消费第2,5,8...条消息, C消费第3,6,9...条消息.

公平分发: 只要有空闲的消费者就给发待处理的消息. 相对于轮询分发提高效率.

3. 发布/订阅模式: 一个生产者产生的消息, 可以同时被多个消费者消费. 生产者将消息发送给broker,由Exchange将消息转发到绑定在此交换机的每一个Queue中, 消费者监听自己的Queue进行消费.

4. 路由模式: 生产者将消息发送给broker, 由Exchange根据routing_key分发到不同的Queue中, 消费者也根据routing_key找到对应的Queue进行消费.

5. 主题模式: 在路由模式的基础上, routing_key支持正则匹配

6. RPC模式: 通过消息队列实现RPC功能, 客户端发送消息到消费队列, 服务端消费消息执行程序将结果再返回给客户端, 就是把结果发送消息到回调队列.

总结: 

简单模式, 工作队列模式 为一类: 不需要声明交换机就可以用, 更不需要指定交换机类型. 实际上是由消息代理事先声明好的空字符串的直连交换机. 新建的队列都会自动绑定到此交换机, routing_key与队列名相等.

发布/订阅模式, 路由模式, 主题模式 为一类: 需要声明交换机, 并且指定交换机类型. 

RPC模式 为一类: 双向生产消费模式.

3. python版demo

生产者

  1. import pika
  2. import json
  3. import datetime
  4. import time
  5. import random
  6.  
  7.  
  8. class TestPublisher(object):
  9.  
  10.     def __init__(self):
  11.         self.username = 'sanford'
  12.         self.password = '123456'
  13.         self.host = 'localhost'
  14.         self.port = 5672
  15.         self.virtual_host = 'sanford_host'
  16.  
  17.     def publisher_00(self, msg_type, data):
  18.         """
  19.         简单模式/工作队列模式
  20.         """
  21.         # 创建连接时的登录凭证
  22.         credentials = pika.PlainCredentials(username=self.username, password=self.password)
  23.  
  24.         # 参数设置
  25.         params = pika.ConnectionParameters(host=self.host,
  26.                                            port=self.port,
  27.                                            virtual_host=self.virtual_host,
  28.                                            credentials=credentials)
  29.  
  30.         # 创建阻塞式连接
  31.         connection = pika.BlockingConnection(params)
  32.  
  33.         # 创建信道
  34.         channel = connection.channel()
  35.  
  36.         # 声明队列 队列持久化: durable=True, 服务重启后队列依然存在
  37.         channel.queue_declare(queue='queue_00', durable=True)
  38.  
  39.         # 消息属性设置 消息持久化: delivery_mode=2
  40.         properties = pika.BasicProperties(headers={'msg-type': msg_type},
  41.                                           delivery_mode=2)
  42.  
  43.         # exchange为默认''时routing_key为queue
  44.         channel.basic_publish(exchange='',
  45.                               routing_key='queue_00',
  46.                               body=json.dumps(data),
  47.                               properties=properties)
  48.  
  49.         connection.close()
  50.  
  51.     def publisher_01(self, msg_type, data):
  52.         """
  53.         发布/订阅模式(fanout)
  54.         """
  55.         credentials = pika.PlainCredentials(username=self.username, password=self.password)
  56.         params = pika.ConnectionParameters(host=self.host,
  57.                                            port=self.port,
  58.                                            virtual_host=self.virtual_host,
  59.                                            credentials=credentials)
  60.         connection = pika.BlockingConnection(params)
  61.         channel = connection.channel()
  62.  
  63.         # 声明交换机指定类型 交换机持久化: durable=True, 服务重启后交换机依然存在
  64.         channel.exchange_declare(exchange='exchange_01', exchange_type='fanout', durable=True)
  65.  
  66.         properties = pika.BasicProperties(headers={'msg-type': msg_type},
  67.                                           delivery_mode=2)
  68.  
  69.         # 此模式不需要routing_key进行消费 可以设置为''
  70.         channel.basic_publish(exchange='exchange_01',
  71.                               routing_key='',
  72.                               body=json.dumps(data),
  73.                               properties=properties)
  74.  
  75.         connection.close()
  76.  
  77.     def publisher_02(self, msg_type, data):
  78.         """
  79.         路由模式(direct)
  80.         """
  81.         credentials = pika.PlainCredentials(username=self.username, password=self.password)
  82.         params = pika.ConnectionParameters(host=self.host,
  83.                                            port=self.port,
  84.                                            virtual_host=self.virtual_host,
  85.                                            credentials=credentials)
  86.         connection = pika.BlockingConnection(params)
  87.         channel = connection.channel()
  88.  
  89.         # 声明交换机指定类型 交换机持久化: durable=True, 服务重启后交换机依然存在
  90.         channel.exchange_declare(exchange='exchange_02', exchange_type='direct', durable=True)
  91.  
  92.         properties = pika.BasicProperties(headers={'msg-type': msg_type},
  93.                                           delivery_mode=2)
  94.  
  95.         # 指定routing_key
  96.         channel.basic_publish(exchange='exchange_02',
  97.                               routing_key='routing_key_02',
  98.                               body=json.dumps(data),
  99.                               properties=properties)
  100.  
  101.         connection.close()
  102.  
  103.     def publisher_03(self, msg_type, data):
  104.         """
  105.         主题模式(topic),实现分发,
  106.         """
  107.         credentials = pika.PlainCredentials(username=self.username, password=self.password)
  108.         params = pika.ConnectionParameters(host=self.host,
  109.                                            port=self.port,
  110.                                            virtual_host=self.virtual_host,
  111.                                            credentials=credentials)
  112.         connection = pika.BlockingConnection(params)
  113.         channel = connection.channel()
  114.  
  115.         # 声明交换机指定类型 交换机持久化: durable=True, 服务重启后交换机依然存在
  116.         channel.exchange_declare(exchange='exchange_03', exchange_type='topic', durable=True)
  117.  
  118.         properties = pika.BasicProperties(headers={'msg-type': msg_type},
  119.                                           delivery_mode=2)
  120.  
  121.         # 拼接routing_key
  122.         channel.basic_publish(exchange='exchange_03',
  123.                               routing_key='routing_key.{0}'.format(msg_type),
  124.                               body=json.dumps(data),
  125.                               properties=properties)
  126.  
  127.         connection.close()
  128.  
  129.  
  130. if __name__ == '__main__':
  131.     test_publisher = TestPublisher()
  132.  
  133.     # 简单模式/工作队列模式
  134.     # msg_type_00 = 'msg_type_00'
  135.     # for i in range(20):
  136.     #     time.sleep(1)
  137.     #     data_00 = {'id': i, 'name': 'jay', 'send_time': datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')}
  138.     #     test_publisher.publisher_00(msg_type_00, data_00)
  139.  
  140.     # 发布/订阅模式(fanout)
  141.     # msg_type_01 = 'msg_type_01'
  142.     # for i in range(20):
  143.     #     time.sleep(1)
  144.     #     data_01 = {'id': i, 'name': 'jay', 'send_time': datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')}
  145.     #     test_publisher.publisher_01(msg_type_01, data_01)
  146.  
  147.     # 路由模式(direct)
  148.     # msg_type_02 = 'msg_type_02'
  149.     # for i in range(20):
  150.     #     time.sleep(1)
  151.     #     data_02 = {'id': i, 'name': 'jay', 'send_time': datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')}
  152.     #     test_publisher.publisher_02(msg_type_02, data_02)
  153.  
  154.     # 主题模式(topic),实现分发
  155.     msg_type_list = ['msg_type_03.0', 'msg_type_03.1', 'msg_type_03.2']
  156.     for i in range(20):
  157.         msg_type_03 = random.choice(msg_type_list)
  158.         time.sleep(1)
  159.         data_03 = {'id': i, 'name': 'jay', 'send_time': datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')}
  160.         test_publisher.publisher_03(msg_type_03, data_03)

消费者

  1. import pika
  2. import json
  3. import time
  4. import random
  5. import datetime
  6. import sys
  7.  
  8.  
  9. class TestConsumer(object):
  10.  
  11.     def __init__(self):
  12.         self.username = 'sanford'
  13.         self.password = '123456'
  14.         self.host = 'localhost'
  15.         self.port = 5672
  16.         self.virtual_host = 'sanford_host'
  17.  
  18.     @staticmethod
  19.     def callback_00(channel, method, properties, body):
  20.         """
  21.         回调函数
  22.         """
  23.         time.sleep(random.randint(1, 10))
  24.         headers = properties.headers
  25.         data = json.loads(body)
  26.         data['end_time'] = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
  27.         print(headers, data)
  28.         # 手动确认已经消费成功 当auto_ack=False时
  29.         channel.basic_ack(delivery_tag=method.delivery_tag)
  30.  
  31.     def consumer_00(self):
  32.         """
  33.         简单模式/工作队列模式
  34.         """
  35.         # 创建连接时的登录凭证
  36.         credentials = pika.PlainCredentials(username=self.username, password=self.password)
  37.  
  38.         # 参数设置
  39.         params = pika.ConnectionParameters(host=self.host,
  40.                                            port=self.port,
  41.                                            virtual_host=self.virtual_host,
  42.                                            credentials=credentials)
  43.  
  44.         # 创建阻塞式连接
  45.         connection = pika.BlockingConnection(params)
  46.  
  47.         # 创建信道
  48.         channel = connection.channel()
  49.  
  50.         # 声明队列 队列持久化: durable=True, 服务重启后队列依然存在
  51.         channel.queue_declare(queue='queue_00', durable=True)
  52.  
  53.         # 公平分发(没有这行时为轮询分发) prefetch_count=1如果消费者中有一条消息没处理完就不会继续给这个消费者继续发消息
  54.         channel.basic_qos(prefetch_count=1)
  55.  
  56.         # auto_ack=True 自动确认已经消费成功
  57.         channel.basic_consume(queue='queue_00',
  58.                               on_message_callback=self.callback_00)
  59.  
  60.         channel.start_consuming()
  61.  
  62.     def consumer_01(self):
  63.         """
  64.         发布/订阅模式(fanout)
  65.         """
  66.         credentials = pika.PlainCredentials(username=self.username, password=self.password)
  67.         params = pika.ConnectionParameters(host=self.host,
  68.                                            port=self.port,
  69.                                            virtual_host=self.virtual_host,
  70.                                            credentials=credentials)
  71.         connection = pika.BlockingConnection(params)
  72.         channel = connection.channel()
  73.  
  74.         # 声明交换机指定类型 交换机持久化: durable=True, 服务重启后交换机依然存在
  75.         channel.exchange_declare(exchange='exchange_01', exchange_type='fanout', durable=True)
  76.  
  77.         # 声明队列, queue为空字符串时会创建唯一的队列名. exclusive=True, 仅允许当前的连接访问
  78.         result = channel.queue_declare(queue='', exclusive=True)
  79.         queue_name = result.method.queue
  80.  
  81.         # 通过路由键将队列和交换器绑定, 此模式不需要routing_key进行消费 可以默认为None
  82.         channel.queue_bind(exchange='exchange_01', queue=queue_name)
  83.  
  84.         channel.basic_consume(queue=queue_name,
  85.                               on_message_callback=self.callback_00)
  86.  
  87.         channel.start_consuming()
  88.  
  89.     def consumer_02(self):
  90.         """
  91.         路由模式(direct)
  92.         """
  93.         credentials = pika.PlainCredentials(username=self.username, password=self.password)
  94.         params = pika.ConnectionParameters(host=self.host,
  95.                                            port=self.port,
  96.                                            virtual_host=self.virtual_host,
  97.                                            credentials=credentials)
  98.         connection = pika.BlockingConnection(params)
  99.         channel = connection.channel()
  100.  
  101.         # 声明交换机指定类型 交换机持久化: durable=True, 服务重启后交换机依然存在
  102.         channel.exchange_declare(exchange='exchange_02', exchange_type='direct', durable=True)
  103.  
  104.         # 声明队列, queue为空字符串时会创建唯一的队列名. exclusive=True, 仅允许当前的连接访问
  105.         result = channel.queue_declare(queue='', exclusive=True)
  106.         queue_name = result.method.queue
  107.  
  108.         # 通过路由键将队列和交换器绑定, 此模式需要routing_key进行消费
  109.         channel.queue_bind(exchange='exchange_02', queue=queue_name, routing_key='routing_key_02')
  110.  
  111.         channel.basic_consume(queue=queue_name,
  112.                               on_message_callback=self.callback_00)
  113.  
  114.         channel.start_consuming()
  115.  
  116.     def consumer_03_0(self):
  117.         """
  118.         主题模式(topic),实现分发 routing_key.msg_type_03.0
  119.         """
  120.         credentials = pika.PlainCredentials(username=self.username, password=self.password)
  121.         params = pika.ConnectionParameters(host=self.host,
  122.                                            port=self.port,
  123.                                            virtual_host=self.virtual_host,
  124.                                            credentials=credentials)
  125.         connection = pika.BlockingConnection(params)
  126.         channel = connection.channel()
  127.  
  128.         # 声明交换机指定类型 交换机持久化: durable=True, 服务重启后交换机依然存在
  129.         channel.exchange_declare(exchange='exchange_03', exchange_type='topic', durable=True)
  130.  
  131.         # 声明队列, queue为空字符串时会创建唯一的队列名. exclusive=True, 仅允许当前的连接访问
  132.         result = channel.queue_declare(queue='', exclusive=True)
  133.         queue_name = result.method.queue
  134.  
  135.         # 通过路由键将队列和交换器绑定, 此模式需要routing_key进行消费
  136.         channel.queue_bind(exchange='exchange_03', queue=queue_name, routing_key='routing_key.msg_type_03.0')
  137.  
  138.         channel.basic_consume(queue=queue_name,
  139.                               on_message_callback=self.callback_00)
  140.  
  141.         channel.start_consuming()
  142.  
  143.     def consumer_03_1(self):
  144.         """
  145.         主题模式(topic),实现分发 routing_key.msg_type_03.1
  146.         """
  147.         credentials = pika.PlainCredentials(username=self.username, password=self.password)
  148.         params = pika.ConnectionParameters(host=self.host,
  149.                                            port=self.port,
  150.                                            virtual_host=self.virtual_host,
  151.                                            credentials=credentials)
  152.         connection = pika.BlockingConnection(params)
  153.         channel = connection.channel()
  154.  
  155.         # 声明交换机指定类型 交换机持久化: durable=True, 服务重启后交换机依然存在
  156.         channel.exchange_declare(exchange='exchange_03', exchange_type='topic', durable=True)
  157.  
  158.         # 声明队列, queue为空字符串时会创建唯一的队列名. exclusive=True, 仅允许当前的连接访问
  159.         result = channel.queue_declare(queue='', exclusive=True)
  160.         queue_name = result.method.queue
  161.  
  162.         # 通过路由键将队列和交换器绑定, 此模式需要routing_key进行消费
  163.         channel.queue_bind(exchange='exchange_03', queue=queue_name, routing_key='routing_key.msg_type_03.1')
  164.  
  165.         channel.basic_consume(queue=queue_name,
  166.                               on_message_callback=self.callback_00)
  167.  
  168.         channel.start_consuming()
  169.  
  170.     def consumer_03_2(self):
  171.         """
  172.         主题模式(topic),实现分发 routing_key.msg_type_03.#
  173.         * (星号) 代表任意 一个单词
  174.         # (hash) 0个或者多个单词
  175.         """
  176.         credentials = pika.PlainCredentials(username=self.username, password=self.password)
  177.         params = pika.ConnectionParameters(host=self.host,
  178.                                            port=self.port,
  179.                                            virtual_host=self.virtual_host,
  180.                                            credentials=credentials)
  181.         connection = pika.BlockingConnection(params)
  182.         channel = connection.channel()
  183.  
  184.         # 声明交换机指定类型 交换机持久化: durable=True, 服务重启后交换机依然存在
  185.         channel.exchange_declare(exchange='exchange_03', exchange_type='topic', durable=True)
  186.  
  187.         # 声明队列, queue为空字符串时会创建唯一的队列名. exclusive=True, 仅允许当前的连接访问
  188.         result = channel.queue_declare(queue='', exclusive=True)
  189.         queue_name = result.method.queue
  190.  
  191.         # 通过路由键将队列和交换器绑定, 此模式需要routing_key进行消费
  192.         channel.queue_bind(exchange='exchange_03', queue=queue_name, routing_key='routing_key.msg_type_03.#')
  193.  
  194.         channel.basic_consume(queue=queue_name,
  195.                               on_message_callback=self.callback_00)
  196.  
  197.         channel.start_consuming()
  198.  
  199.  
  200. if __name__ == '__main__':
  201.     test_consumer = TestConsumer()
  202.  
  203.     # 简单模式/工作队列模式
  204.     # test_consumer.consumer_00()
  205.  
  206.     # 发布/订阅模式(fanout)
  207.     # test_consumer.consumer_01()
  208.  
  209.     # 路由模式(direct)
  210.     # test_consumer.consumer_02()
  211.  
  212.     # 主题模式(topic),实现分发
  213.     if sys.argv[1] == '0':
  214.         test_consumer.consumer_03_0()
  215.     elif sys.argv[1] == '1':
  216.         test_consumer.consumer_03_1()
  217.     elif sys.argv[1] == '2':
  218.         test_consumer.consumer_03_2()

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/小小林熬夜学编程/article/detail/480968
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号