Mqtt三种交换机类型和路由键+消息优先级处理

在 RabbitMQ 中，queue 和 routing_key 不必总是一致。它们的使用方式取决于交换机类型和消息路由的需求。让我们详细讨论一下不同交换机类型以及 queue 和 routing_key 的关系。

1. Direct Exchange

概念
Direct Exchange 是最简单的交换机类型。它将消息路由到与消息的路由键完全匹配的绑定键的队列。

代码示例
声明交换机：

channel.exchange_declare(exchange='direct_logs', exchange_type='direct')

这里，我们声明了一个名为 direct_logs 的 Direct Exchange。

声明队列：

channel.queue_declare(queue='error_logs')

我们声明了一个名为 error_logs 的队列。

绑定队列到交换机：

channel.queue_bind(exchange='direct_logs', queue='error_logs', routing_key='error')

将 error_logs 队列绑定到 direct_logs 交换机，绑定键为 error。

发送消息：

channel.basic_publish(exchange='direct_logs', routing_key='error', body='Error log message')

发送消息时指定 routing_key 为 error，因此消息会被路由到 error_logs 队列。

总结
在 Direct Exchange 中，queue 和 routing_key 必须匹配绑定键。

2. Fanout Exchange

概念
Fanout Exchange 会将接收到的所有消息广播到所有与它绑定的队列。它不使用路由键进行路由。

代码示例
声明交换机：

channel.exchange_declare(exchange='logs', exchange_type='fanout')

这里，我们声明了一个名为 logs 的 Fanout Exchange。

声明队列：

channel.queue_declare(queue='log_queue')

我们声明了一个名为 log_queue 的队列。

绑定队列到交换机：

channel.queue_bind(exchange='logs', queue='log_queue')

将 log_queue 队列绑定到 logs 交换机。注意这里没有 routing_key 参数，因为 Fanout Exchange 不使用路由键。

发送消息：

channel.basic_publish(exchange='logs', routing_key='', body='Log message')

发送消息时 routing_key 可以为空，因为 Fanout Exchange 会忽略它。所有绑定到 logs 交换机的队列都会接收到消息。

总结
在 Fanout Exchange 中，routing_key 被忽略，消息会被广播到所有绑定的队列。

3. Topic Exchange

概念
Topic Exchange 是一种强大的路由机制。它允许消息的路由键与绑定键使用通配符进行匹配。* 可以匹配一个单词，# 可以匹配零个或多个单词。

代码示例
声明交换机：

channel.exchange_declare(exchange='topic_logs', exchange_type='topic')

这里，我们声明了一个名为 topic_logs 的 Topic Exchange。

声明队列：

channel.queue_declare(queue='warning_logs')

我们声明了一个名为 warning_logs 的队列。

绑定队列到交换机：

channel.queue_bind(exchange='topic_logs', queue='warning_logs', routing_key='log.warning')

将 warning_logs 队列绑定到 topic_logs 交换机，绑定键为 log.warning。

发送消息：

channel.basic_publish(exchange='topic_logs', routing_key='log.warning', body='Warning log message')

发送消息时指定 routing_key 为 log.warning，因此消息会被路由到 warning_logs 队列。

总结

在 Topic Exchange 中，routing_key 与绑定键之间的匹配可以使用通配符 * 和 #。

注意：

在 RabbitMQ 中，当有多个消费者同时连接到同一个队列时，消息会以轮询（Round-Robin）的方式分配给消费者。RabbitMQ 并不直接支持指定消息消费的顺序，因为这是由 RabbitMQ 的内部机制管理的。

然而，有一些方法可以在一定程度上控制消息的处理顺序：

1. 使用优先级队列

通过使用消息优先级队列，可以在某种程度上控制消息处理的顺序。高优先级的消息会被优先处理。

设置消息优先级队列示例：
声明队列时指定优先级：

import pika

connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()

//声明队列，并指定最大优先级
args = {'x-max-priority': 10}
channel.queue_declare(queue='priority_queue', arguments=args)

//发送消息，并指定优先级
channel.basic_publish(exchange='',
                      routing_key='priority_queue',
                      body='Low priority message',
                      properties=pika.BasicProperties(priority=1))

channel.basic_publish(exchange='',
                      routing_key='priority_queue',
                      body='High priority message',
                      properties=pika.BasicProperties(priority=10))

connection.close()

消费消息：

import pika

def callback(ch, method, properties, body):
    print(f"Received {body}")

connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()

channel.queue_declare(queue='priority_queue')

channel.basic_consume(queue='priority_queue', on_message_callback=callback, auto_ack=True)

print('Waiting for messages. To exit press CTRL+C')
channel.start_consuming()

在这个例子中，具有高优先级的消息会被优先消费。

2. 手动确认与预取数量

通过设置预取数量（Prefetch Count），可以控制每个消费者在处理消息之前最多接收多少条未确认的消息。这可以防止某些消费者在处理较慢时被过多的消息压垮。

设置预取数量示例：
声明队列并设置预取数量：

import pika

connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()

//声明队列
channel.queue_declare(queue='task_queue', durable=True)

//设置预取数量
channel.basic_qos(prefetch_count=1)

def callback(ch, method, properties, body):
    print(f"Received {body}")
    # 模拟处理时间
    import time
    time.sleep(1)
    ch.basic_ack(delivery_tag=method.delivery_tag)

channel.basic_consume(queue='task_queue', on_message_callback=callback)

print('Waiting for messages. To exit press CTRL+C')
channel.start_consuming()

在这个例子中，每个消费者一次只接收一条未确认的消息，这可以使得消费者之间的工作负载更均匀分布。

3. 使用消息属性中的 timestamp

通过在消息属性中添加 timestamp 属性，消费者可以根据消息的时间戳进行排序和处理。

使用 timestamp 属性示例：
发送消息时添加 timestamp 属性：

import pika
import datetime

connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()

channel.queue_declare(queue='timestamp_queue')

//发送消息，并指定时间戳
timestamp = int(datetime.datetime.now().timestamp())
channel.basic_publish(exchange='',
                      routing_key='timestamp_queue',
                      body='Message with timestamp',
                      properties=pika.BasicProperties(timestamp=timestamp))

connection.close()

消费消息并按时间戳排序：

import pika

connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()

channel.queue_declare(queue='timestamp_queue')

messages = []

def callback(ch, method, properties, body):
    messages.append((properties.timestamp, body))
    messages.sort(key=lambda x: x[0])
    for message in messages:
        print(f"Received {message[1]} with timestamp {message[0]}")
    ch.basic_ack(delivery_tag=method.delivery_tag)

channel.basic_consume(queue='timestamp_queue', on_message_callback=callback)

print('Waiting for messages. To exit press CTRL+C')
channel.start_consuming()

在这个例子中，消费者在接收到消息后，会根据时间戳对消息进行排序并处理。

总结

虽然 RabbitMQ 本身不支持严格的消费顺序控制，但通过使用优先级队列、预取数量和消息属性（如 timestamp），可以在一定程度上实现对消息处理顺序的控制。这些方法结合使用，可以优化消息处理流程，达到预期的顺序控制效果。