Message Queue消息队列是一种应用程序对应用程序的通信方法, 可以是线程(Queue), 也可以是进程之间
, 而rabbitmq
是进程之间的消息队列
生产者消费者模型
: 通过一个容器来解决生产者和消费者之间的强耦合, 两者彼此不通信, 生产者生产完数据直接交给阻塞队列, 消费者直接从阻塞队列中取数据, 阻塞队列就相当于一个缓冲区, 平衡两者处理能力
消息队列是分布式系统中重要组件, 主要解决: 解耦, 异步消息
, 流量削峰
高内聚, 低耦合:
重用
相互依赖程度
较低, 代码更加灵活, 可拓展, 并且易于进行单元测试和重构rabbitmq是一款基于AMQP协议的消息中间件, 它能够在应用中提供可靠的消息传输, 易用性, 拓展性, 高可用性, 使用消息中间件用于应用之间的解耦
, 生产者无需知道消费者的存在, 且两端可以用不同的语言编写
, 大大提高了灵活性
生产者.py
import pika # 链接rabbitmq connection = pika.BlockingConnection(pika.ConnectionParameters('localhost')) channel = connection.channel() # 声明队列 channel.queue_declare(queue='hello') # 项队列插入数据 channel.basic_publish(exchange='', routing_key='hello', body='Hello World!') print(" [x] Sent 'Hello World!'")
消费者.py
import pika # 链接rabbitmq 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) # 确认应答参数 channel.basic_consume(queue='hello', auto_ack=True, on_message_callback=callback) print(' [*] Waiting for messages. To exit press CTRL+C') # 真正开始监听 channel.start_consuming()
将原来的默认应答
改成手动应答
当消费者从队列中获取消息并成功处理后,它可以通过发送应答来告知 RabbitMQ 消息已被处理。这有助于确保消息被正确处理,避免消息丢失或重复处理。
生产者
import pika # 链接rabbitmq connection = pika.BlockingConnection(pika.ConnectionParameters('localhost')) channel = connection.channel() # 声明队列 channel.queue_declare(queue='hello') # 项队列插入数据 channel.basic_publish(exchange='', routing_key='hello', body='Hello World!') print(" [x] Sent 'Hello World!'")
消费者
import pika # 链接rabbitmq 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()
rabbitmq的消息队列默认是储存在内存中, 一旦rabbitmq关闭或者出现异常, 就会导致数据丢失, 所以rabbitmq为我们提供了一个参数将数据写入硬盘中持久化存储
生产者
import pika # 链接rabbitmq connection = pika.BlockingConnection(pika.ConnectionParameters('localhost')) channel = connection.channel() # 声明队列 channel.queue_declare(queue='hello', durable=True) # 如果声明过的名字, 就换一个, 否则会报错 # 项队列插入数据 channel.basic_publish(exchange='', routing_key='hello', body='Hello World!', properties=pika.BasicProperties( delivery_mode=2, # make message persistent ) ) print(" [x] Sent 'Hello World!'")
消费者
import pika # 链接rabbitmq connection = pika.BlockingConnection(pika.ConnectionParameters('localhost')) channel = connection.channel() channel.queue_declare(queue='hello', 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='hello', auto_ack=False, # 改成手动应答 on_message_callback=callback) print(' [*] Waiting for messages. To exit press CTRL+C') channel.start_consuming()
有两个消费者同时监听一个的队列。其中一个线程sleep2秒,另一个消费者线程sleep1秒,但是处理的消息是一样多。这种方式叫轮询分发(round-robin)不管谁忙,都不会多给消息,总是你一个我一个。想要做到公平分发(fair dispatch),必须关闭自动应答ack,改成手动应答。使用basicQos(perfetch=1)限制每次只发送不超过1条消息到同一个消费者,消费者必须手动反馈告知队列,才会发送下一个。
生产者
import pika # 链接rabbitmq connection = pika.BlockingConnection(pika.ConnectionParameters('localhost')) channel = connection.channel() # 声明队列 channel.queue_declare(queue='hello', durable=True) # 如果声明过的名字, 就换一个, 否则会报错 # 项队列插入数据 channel.basic_publish(exchange='', routing_key='hello', body='Hello World!', properties=pika.BasicProperties( delivery_mode=2, # make message persistent ) ) print(" [x] Sent 'Hello World!'")
消费者
import pika # 链接rabbitmq connection = pika.BlockingConnection(pika.ConnectionParameters('localhost')) channel = connection.channel() channel.queue_declare(queue='hello', durable=True) def callback(ch, method, properties, body): print(" [x] Received %r" % body) ch.basic_ack(delivery_tag=method.delivery_tag) # 消费者发送应答来确认处理完成当前的消息。 channel.basic_qos(prefetch_count=1) # fair dispatch channel.basic_consume(queue='hello', auto_ack=False, # 改成手动应答 on_message_callback=callback) print(' [*] Waiting for messages. To exit press CTRL+C') channel.start_consuming()
发布订阅和简单的消息队列区别在于,发布订阅会将消息发送给所有的订阅者,而消息队列中的数据被消费一次便消失。所以,RabbitMQ实现发布和订阅时,会为每一个订阅者创建一个队列,而发布者发布消息时,会将消息放置在交换机中并为每一个绑定的队列发送一份消息。常用案例: 外卖系统
生产者
import pika connection = pika.BlockingConnection(pika.ConnectionParameters( host='localhost')) channel = connection.channel() # 创建交换机 channel.exchange_declare(exchange='logs', exchange_type='fanout') # fanout即订阅模式 # 向交换机中插入数据 message = "info: Hello World!" channel.basic_publish(exchange='logs', routing_key='', body=message) print(" [x] Sent %r" % message) connection.close()
消费者
import pika connection = pika.BlockingConnection(pika.ConnectionParameters(host='localhost')) channel = connection.channel() # 这里的声明是防止先运行消费者, 导致没有交换机的错误, 如果已经有交换机, 这条就会不运行 channel.exchange_declare(exchange='logs', exchange_type='fanout') # 创建队列 result = channel.queue_declare("",exclusive=True) # exclusive是创建一个随机唯一的queue name queue_name = result.method.queue # 获取queue name # 队列绑定交换机 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()
在订阅模式的基础上加了一个关键字的筛选, 案例: 日志系统
生产者
import pika connection = pika.BlockingConnection(pika.ConnectionParameters( host='localhost')) channel = connection.channel() channel.exchange_declare(exchange='logs2', exchange_type='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') 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()
通配符交换机”与之前的路由模式相比,它将信息的传输类型的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()