Utilisation de Python RabbitMQ (4)

Le troisième article explique l'utilisation des commutateurs. Il peut déjà envoyer des messages à tous les récepteurs. Cependant, si vous devez le personnaliser librement, certains messages sont envoyés à certains récepteurs et certains messages sont envoyés à d'autres récepteurs. Je fais ? Que faire ? Dans ce cas, des clés de routage sont utilisées.

Le principe de fonctionnement de la clé de routage : lorsque la file d'attente de messages de chaque extrémité réceptrice est liée au commutateur, la clé de routage correspondante peut être définie. Lorsque l'expéditeur envoie des informations via le commutateur, il peut spécifier la clé de routage et le commutateur enverra le message à la file d'attente de messages correspondante en fonction de la clé de routage, afin que l'extrémité réceptrice puisse recevoir le message.

Suite à l'article précédent, nous utilisons toujours send.py et réception.py pour simuler la fonction des clés de routage. send.py représente l'extrémité émettrice et recevoir.py représente l'extrémité réceptrice. La fonction de l'instance est d'envoyer trois niveaux d'informations : info, avertissement et erreur aux différentes extrémités de réception.

Analyse du code send.py

Par rapport à l'article précédent, les changements portent principalement sur deux aspects :

Réglez le type de commutateur sur direct. Dans l'article précédent, il était réglé sur fanout, ce qui signifie diffusion, et le message sera envoyé à tous les récepteurs. Ici, il est réglé sur direct, ce qui signifie que le message sera envoyé selon la clé de routage définie.
Définissez la clé de routage lors de l'envoi d'informations.

#!/usr/bin/env python
#coding=utf8
import pika
connection= pika.BlockingConnection(pika.ConnectionParameters(
'localhost'))
channel= connection.channel()
#定义交换机，设置类型为direct
channel.exchange_declare(exchange='messages',type='direct')
#定义三个路由键
routings= ['info','warning','error']
#将消息依次发送到交换机，并设置路由键
for routingin routings:
message= '%s message.' % routing
channel.basic_publish(exchange='messages',
routing_key=routing,
body=message)
print message
connection.close()

Analyse du codereceive.py

Par rapport au troisième article, les changements portent principalement sur trois aspects :

Définir le type de commutateur (type) à diriger.
Ajoutez la fonction de ligne de commande pour obtenir les paramètres, et les paramètres sont des clés de routage.
Définissez la clé de routage lors de la liaison de la file d'attente au commutateur.

#!/usr/bin/env python
#coding=utf8
import pika, sys
connection= pika.BlockingConnection(pika.ConnectionParameters(
'localhost'))
channel= connection.channel()
#定义交换机，设置类型为direct
channel.exchange_declare(exchange='messages',type='direct')
#从命令行获取路由键参数，如果没有，则设置为info
routings= sys.argv[1:]
if not routings:
routings= ['info']
#生成临时队列，并绑定到交换机上，设置路由键
result= channel.queue_declare(exclusive=True)
queue_name= result.method.queue
for routingin routings:
channel.queue_bind(exchange='messages',
queue=queue_name,
routing_key=routing)
def callback(ch, method, properties, body):
print " [x] Received %r" % (body,)
channel.basic_consume(callback, queue=queue_name, no_ack=True)
print ' [*] Waiting for messages. To exit press CTRL+C'
channel.start_consuming()

Ouvrez deux terminaux, l'un exécute le code python contain.py info warn, ce qui signifie que seuls les messages d'information et d'avertissement sont reçus. Exécutez send.py sur un autre terminal et vous pourrez constater que le terminal de réception ne reçoit que des messages d'informations et d'avertissement. Si vous ouvrez plusieurs terminaux, exécutez recevoir.py et transmettez différents paramètres de clé de routage, vous pouvez voir des effets plus évidents.

Lorsque l'extrémité réceptrice est en cours d'exécution, vous pouvez utiliser Rabbitmqctl list_bindings pour afficher les liaisons.

Ce qui précède est le contenu de l'utilisation de Python Rabbitmq (4). Pour plus de contenu connexe, veuillez faire attention au site Web PHP chinois (www.php.cn) !