Python exploite le serveur RabbitMQ pour implémenter le routage de la file d'attente de messages

RabbitMQ est un serveur de file d'attente de messages. Nous examinons ici l'environnement côté serveur de Python Pika RabbitMQ pour voir comment utiliser Python pour faire fonctionner le serveur RabbitMQ afin d'implémenter la fonction de routage de la file d'attente de messages

Python. utilise la bibliothèque Pika (installation : sudo pip install pika) peut faire fonctionner le serveur de file d'attente de messages RabbitMQ (installation : sudo apt-get install Rabbitmq-server). Nous examinons ici les fonctions de routage liées à MQ.

Mise en œuvre de clés de routage

Par exemple, il existe un scénario dans lequel les messages doivent être envoyés à tous les destinataires, mais si vous devez les personnaliser librement, certains messages sont envoyés à certains récepteurs, certains messages sont envoyés à d’autres récepteurs, que devons-nous 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 contain.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

#!/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 routing in routings:
  message = '%s message.' % routing
  channel.basic_publish(exchange='messages',
             routing_key=routing,
             body=message)
  print message
 
connection.close()

analyse du codereceive.py

#!/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 routing in 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 l'état de la liaison.

Correspondance floue des clés de routage
La correspondance floue des clés de routage signifie que vous pouvez utiliser des expressions régulières, ce qui est différent des expressions régulières couramment utilisées. Le mot "#" ici signifie tout, tout. . "*" ne correspond qu'à un seul mot. Vous comprendrez après avoir lu l’exemple.

Suivant l'exemple ci-dessus, send.py et contain.py sont toujours utilisés pour implémenter la fonction de correspondance floue 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'exemple est à peu près la suivante : par exemple, si vous avez une amie proche, vous pouvez lui parler de bonheur, de tristesse, de travail ou de vie ; il y a aussi des amis avec qui vous pouvez partager des choses heureuses et il y en a ; des amis avec qui vous pouvez partager des choses heureuses. Vous pouvez lui parler de choses malheureuses.

Analyse du code send.py

Étant donné que la correspondance floue des clés de routage est requise, le type de commutateur doit être défini sur topic. S'il est défini sur topic, vous pouvez utiliser les symboles correspondants #, *.

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

Dans l'exemple ci-dessus, quatre types de messages sont définis. Ils sont faciles à comprendre et ne seront pas ensuite envoyés. séquence.

Analyse du codereceive.py

De même, le type de commutateur doit être défini sur topic. La fonction de réception des paramètres depuis la ligne de commande a été légèrement ajustée, c'est-à-dire qu'elle se terminera avec une erreur s'il n'y a pas de paramètres.

#!/usr/bin/env python
#coding=utf8
import pika, sys
 
connection = pika.BlockingConnection(pika.ConnectionParameters(
        'localhost'))
channel = connection.channel()
 
#定义交换机，设置类型为topic
channel.exchange_declare(exchange='messages', type='topic')
 
#从命令行获取路由参数，如果没有，则报错退出
routings = sys.argv[1:]
if not routings:
  print >> sys.stderr, "Usage: %s [routing_key]..." % (sys.argv[0],)
  exit()
 
#生成临时队列，并绑定到交换机上，设置路由键
result = channel.queue_declare(exclusive=True)
queue_name = result.method.queue
for routing in 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 quatre terminaux, dont l'un fonctionne comme suit, indiquant que vous pouvez lui parler de tout :

python receive.py "#"

Un autre terminal fonctionne comme suit, indiquant que vous pouvez partager des choses heureuses avec elle :

python receive.py "happy.*"

La troisième exécution Comme suit, cela signifie que les questions de travail peuvent être partagées avec elle :

python receive.py "*.work"

La dernière exécute python send.py. Le résultat est facile à imaginer, je ne le posterai donc pas ici.

Pour plus d'articles sur Python exploitant le serveur RabbitMQ pour implémenter le routage de la file d'attente de messages, veuillez faire attention au site Web PHP chinois !