rabbitmq消息队列

2023/6/3 1:22:10

编程Tag： 中间价三剑客

本文主要是介绍rabbitmq消息队列，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

消息队列Rabbitmq

1. 什么是消息队列(MQ)

Message Queue消息队列是一种应用程序对应用程序的通信方法, 可以是线程(Queue), 也可以是进程之间, 而rabbitmq是进程之间的消息队列

生产者消费者模型: 通过一个容器来解决生产者和消费者之间的强耦合, 两者彼此不通信, 生产者生产完数据直接交给阻塞队列, 消费者直接从阻塞队列中取数据, 阻塞队列就相当于一个缓冲区, 平衡两者处理能力

2. 为什么要有消息队列

消息队列是分布式系统中重要组件, 主要解决: 解耦, 异步消息, 流量削峰

高内聚, 低耦合:

  • 高内聚: 将相关功能和数据组织在一起, 使代码模块具有清晰的职责和目的, 更利于维护, 理解, 重用
  • 低耦合: 模块之间的相互依赖程度较低, 代码更加灵活, 可拓展, 并且易于进行单元测试和重构

3. 最典型的消息队列

rabbitmq是一款基于AMQP协议的消息中间件, 它能够在应用中提供可靠的消息传输, 易用性, 拓展性, 高可用性, 使用消息中间件用于应用之间的解耦, 生产者无需知道消费者的存在, 且两端可以用不同的语言编写, 大大提高了灵活性

4. 简单模式

生产者.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()

5. 参数

5.1 应答参数

将原来的默认应答改成手动应答

当消费者从队列中获取消息并成功处理后，它可以通过发送应答来告知 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()

5.2 持久化储存参数

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()

5.3 分发参数

有两个消费者同时监听一个的队列。其中一个线程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()

6. 交换机模式

6.1 订阅

发布订阅和简单的消息队列区别在于，发布订阅会将消息发送给所有的订阅者，而消息队列中的数据被消费一次便消失。所以，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()

6.2 关键字

在订阅模式的基础上加了一个关键字的筛选, 案例: 日志系统

生产者

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()

6.3 通配符

通配符交换机”与之前的路由模式相比，它将信息的传输类型的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()


这篇关于rabbitmq消息队列的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！


相关编程文章

更多>
本站官方QQ
官方QQ:
23002807

沪ICP备2023033072号-1

     

扫一扫关注最新编程教程