Python 如何使用pika在rabbitmq中检测已绑定或未绑定队列的exchange？

receiver.py:

#!/usr/bin/env python3
import pika
import sys

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

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

result = channel.queue_declare(queue='', exclusive=True)
queue_name = result.method.queue

channel.queue_bind(
    exchange='device', queue=queue_name, routing_key='abc')

print(' [*] Waiting for logs. To exit press CTRL+C')


def callback(ch, method, properties, body):
    print(" [x] %r:%r" % (method.routing_key, body))
    connection.close()

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

channel.start_consuming()

#!/usr/bin/env python3
import pika
import sys

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

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

message = 'Hello World!'
channel.basic_publish(
    exchange='device', routing_key='abc', body=message)
print(" [x] Sent %r:%r" % ('abc', message))
connection.close()

sender.py:

#!/usr/bin/env python3
import pika
import sys

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

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

result = channel.queue_declare(queue='', exclusive=True)
queue_name = result.method.queue

channel.queue_bind(
    exchange='device', queue=queue_name, routing_key='abc')

print(' [*] Waiting for logs. To exit press CTRL+C')


def callback(ch, method, properties, body):
    print(" [x] %r:%r" % (method.routing_key, body))
    connection.close()

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

channel.start_consuming()

#!/usr/bin/env python3
import pika
import sys

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

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

message = 'Hello World!'
channel.basic_publish(
    exchange='device', routing_key='abc', body=message)
print(" [x] Sent %r:%r" % ('abc', message))
connection.close()

我有上面的

接收者

和

发送者

，效果很好：

// first bash session
# python3 receive1.py
 [*] Waiting for logs. To exit press CTRL+C
 [x] 'abc':b'Hello World!'

// second bash session
# python3 send1.py
 [x] Sent 'abc':'Hello World!'

我的问题是：

#!/usr/bin/env python3
import pika
import sys

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

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

result = channel.queue_declare(queue='', exclusive=True)
queue_name = result.method.queue

channel.queue_bind(
    exchange='device', queue=queue_name, routing_key='abc')

print(' [*] Waiting for logs. To exit press CTRL+C')


def callback(ch, method, properties, body):
    print(" [x] %r:%r" % (method.routing_key, body))
    connection.close()

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

channel.start_consuming()

#!/usr/bin/env python3
import pika
import sys

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

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

message = 'Hello World!'
channel.basic_publish(
    exchange='device', routing_key='abc', body=message)
print(" [x] Sent %r:%r" % ('abc', message))
connection.close()

如果我先调用

sender.py

，然后调用

receiver.py

，则

receiver.py

将不会收到消息。我知道这一点，因为当

sender.py

发送消息时，exchange实际上没有绑定到任何队列，因此根据rabbitmq的设计，它将删除所有消息，而不绑定到exchange队列

一种解决方案是使用命名队列，并在

sender.py

中声明/绑定它。但如果我这样做，如果上次消费者没有从最后一个发送者那里获取消息，那么这次的新消费者可能有机会从最后一个发送者那里接收旧消息

对我来说，

接收者

和

发送者

准备就绪之间的时间间隔非常小。所以我只是想知道

pika

是否可能在

sender.py

中检测到

exchange

已经绑定了

队列

？如果没有绑定，我会睡一会儿再发送

---

有人有什么建议吗？

您可以在发送方和接收方中对绑定进行修改。如果您使用相同的参数，绑定和所有其他配置操作一样都是幂等的。谢谢@LutzHorn，正如问题中提到的，我不喜欢在两侧绑定它。为什么？这将解决您的问题。

一种解决方案是使用命名队列，并在sender.py中声明/绑定它。但是如果我这样做，如果上次消费者没有从最后一个发件人处获取消息，那么这次的新消费者可能有机会从最后一个发件人处接收旧消息。

，您认为可能发生这种情况吗？我可以将消费者丢失消息裸露出来，但无法忍受它接收到一条旧消息。如果消息只能由唯一的消费者使用，则必须为其创建一个唯一的队列。使用临时队列。您可以在发送方和接收方中创建绑定。如果您使用相同的参数，绑定和所有其他配置操作一样都是幂等的。谢谢@LutzHorn，正如问题中提到的，我不喜欢在两侧绑定它。为什么？这将解决您的问题。

一种解决方案是使用命名队列，并在sender.py中声明/绑定它。但是如果我这样做，如果上次消费者没有从最后一个发件人处获取消息，那么这次的新消费者可能有机会从最后一个发件人处接收旧消息。

，您认为可能发生这种情况吗？我可以将消费者丢失消息裸露出来，但无法忍受它接收到一条旧消息。如果消息只能由唯一的消费者使用，则必须为其创建一个唯一的队列。使用临时队列。