zoukankan      html  css  js  c++  java

  • RabbitMQ

    RabbitMQ原理图示：

    一：RabbitMQ消息类型-HelloWorld

     1 #__author__:Kelvin
 2 #date:2020/4/14 15:10
 3 import pika
 4 
 5 credentials = pika.PlainCredentials('kelvin', '123456')
 6 connection = pika.BlockingConnection(pika.ConnectionParameters('localhost', 5672, "vhost01",credentials))
 7 #创建通道，通过通道和队列进行信息发送与获取
 8 channel = connection.channel()
 9 # 声明queue
10 channel.queue_declare(queue='q1')
11 channel.basic_publish(exchange='',routing_key='q1',body='Hello World!')
12 print("消息已经成功发送...")
13 connection.close()
    send
     1 # __author__:Kelvin
 2 # date:2020/4/14 15:12
 3 import pika
 4 
 5 credentials = pika.PlainCredentials('kelvin', '123456')
 6 connection = pika.BlockingConnection(pika.ConnectionParameters('localhost', 5672, "vhost01", credentials))
 7 channel = connection.channel()
 8 
 9 channel.queue_declare(queue='q1')
10 def callback(ch, method, properties, body):
11     print("接收的消息：%r" % body)
12 channel.basic_consume('q1', callback, True)
13 channel.start_consuming()
    receive

    二：RabbitMQ消息类型-Work

    如果Rabbit只管按顺序把消息发到各个消费者身上，不考虑消费者负载的话，很可能出现，一个机器配置不高的消费者那里堆积了很多消息处理不完，同时配置高的消费者却一直很轻松。为解决此问题，可以在各个消费者端，配置channel.basic_qos(prefetch_count=1)（现在最新版这样使用会报错，应该为channel.basic_qos(0,1)）,意思就是告诉RabbitMQ在我这个消费者当前消息还没处理完的时候就不要再给我发新消息了。

    1：普通均分消息

    原理图示：

     1 # __author__:Kelvin
 2 # date:2020/4/14 21:00
 3 import pika
 4 import time
 5 import sys
 6 
 7 credentials = pika.PlainCredentials('kelvin', '123456')
 8 connection = pika.BlockingConnection(pika.ConnectionParameters('localhost', 5672, "vhost01", credentials))
 9 channel = connection.channel()
10 # 声明queue
11 channel.queue_declare(queue='q2')
12 for i in range(20):
13     message = "Hello World! %s" % i
14     channel.basic_publish(exchange='',routing_key='q2',
15                           body=message,
16                           )
17     print(" [x] Sent %r" % message)
18 connection.close()
    send
     1 # __author__:Kelvin
 2 # date:2020/4/14 21:03
 3 import pika, time
 4 
 5 credentials = pika.PlainCredentials('kelvin', '123456')
 6 connection = pika.BlockingConnection(pika.ConnectionParameters('localhost', 5672, "vhost01", credentials))
 7 channel = connection.channel()
 8 
 9 # 声明queue
10 channel.queue_declare(queue='q2')
11 
12 def callback(ch, method, properties, body):
13     print(" [x] Received %r" % body)
14     time.sleep(0.2)
15     print("method.delivery_tag", method.delivery_tag)
16     ch.basic_ack(delivery_tag=method.delivery_tag)
17 
18 
19 channel.basic_consume("q2",callback,False)
20 channel.start_consuming()
    receive

    2：队列、消息持久化均分消息

    原理图示：

     1 # __author__:Kelvin
 2 # date:2020/4/14 21:00
 3 import pika
 4 import time
 5 import sys
 6 
 7 credentials = pika.PlainCredentials('kelvin', '123456')
 8 connection = pika.BlockingConnection(pika.ConnectionParameters('localhost', 5672, "vhost01", credentials))
 9 channel = connection.channel()
10 # 声明queue
11 channel.queue_declare(queue='q2')
12 message = "Hello World!"
13 channel.basic_publish(exchange='', routing_key='q2',
14                       body=message,
15                       properties=pika.BasicProperties(
16                           delivery_mode=2,
17                       ))  #消息持久化 *****
18 print(" [x] Sent %r" % message)
19 connection.close()
    send
     1 # __author__:Kelvin
 2 # date:2020/4/14 21:03
 3 import pika, time
 4 
 5 credentials = pika.PlainCredentials('kelvin', '123456')
 6 connection = pika.BlockingConnection(pika.ConnectionParameters('localhost', 5672, "vhost01", credentials))
 7 channel = connection.channel()
 8 
 9 # 声明queue
10 channel.queue_declare(queue='q2',durable=True) #*****队列持久化
11 
12 def callback(ch, method, properties, body):
13     print(" [x] Received %r" % body)
14     time.sleep(0.2)
15     print("method.delivery_tag", method.delivery_tag)
16     ch.basic_ack(delivery_tag=method.delivery_tag)
17 
18 
19 channel.basic_consume("q2",callback,False)
20 channel.start_consuming()
    receive

    3：根据接收者能力大小接收消息（不均分消息）

    原理图示：

    同时设置channel.basic_qos(0,1)，目的是为了让RabbitMQ服务器发送数据时，如果当前消费者当前消息还没有处理完就不要再发送消息了，channel.basic_consume("q2",callback,False)中的no_ack=False,目的是为了不让RabbitMQ主动确认接收消息，同时在callback回调函数最后主动向RabbitMQ服务器确认接收消息（也就是在接收消息完毕后接收端主动提交确认），

     1 # __author__:Kelvin
 2 # date:2020/4/14 21:00
 3 import pika
 4 import time
 5 import sys
 6 
 7 credentials = pika.PlainCredentials('kelvin', '123456')
 8 connection = pika.BlockingConnection(pika.ConnectionParameters('localhost', 5672, "vhost01", credentials))
 9 channel = connection.channel()
10 # 声明queue
11 channel.queue_declare(queue='q2')
12 for i in range(20):
13     message = "Hello World! %s" % i
14     channel.basic_publish(exchange='',routing_key='q2',
15                           body=message,
16                           )
17     print(" [x] Sent %r" % message)
18 connection.close()
    send
     1 # __author__:Kelvin
 2 # date:2020/4/14 21:03
 3 import pika, time
 4 
 5 credentials = pika.PlainCredentials('kelvin', '123456')
 6 connection = pika.BlockingConnection(pika.ConnectionParameters('localhost', 5672, "vhost01", credentials))
 7 channel = connection.channel()
 8 channel.basic_qos(0,1)
 9 # 声明queue
10 channel.queue_declare(queue='q2')
11 
12 def callback(ch, method, properties, body):
13     print(" [x] Received %r" % body)
14     time.sleep(0.2)
15     print("method.delivery_tag", method.delivery_tag)
16     ch.basic_ack(delivery_tag=method.delivery_tag)
17 
18 
19 channel.basic_consume("q2",callback,False)
20 channel.start_consuming()
    receive1
     1 # __author__:Kelvin
 2 # date:2020/4/14 21:03
 3 import pika, time
 4 
 5 credentials = pika.PlainCredentials('kelvin', '123456')
 6 connection = pika.BlockingConnection(pika.ConnectionParameters('localhost', 5672, "vhost01", credentials))
 7 channel = connection.channel()
 8 channel.basic_qos(0,1)
 9 # 声明queue
10 channel.queue_declare(queue='q2')
11 
12 
13 def callback(ch, method, properties, body):
14     print(" [x] Received %r" % body)
15     time.sleep(1)
16     print("method.delivery_tag", method.delivery_tag)
17     ch.basic_ack(delivery_tag=method.delivery_tag) #*****
18 
19 
20 channel.basic_consume("q2",callback,False) #*****False
21 channel.start_consuming()
    receive2

    三：RabbitMQ消息类型-fanout（广播）

    原理图示：

     1 # __author__:Kelvin
 2 # date:2020/4/14 21:00
 3 import pika
 4 import time
 5 import sys
 6 
 7 credentials = pika.PlainCredentials('kelvin', '123456')
 8 connection = pika.BlockingConnection(pika.ConnectionParameters('localhost', 5672, "vhost01", credentials))
 9 channel = connection.channel()
10 #使用交换机
11 channel.exchange_declare(exchange='logs',exchange_type='fanout') #*****
12 message =" Hello World!"
13 #定义交换机名称
14 channel.basic_publish(exchange='logs',routing_key='',body=message) #*****
15 print("成功发送消息： %r" % message)
16 connection.close()
    send
     1 # __author__:Kelvin
 2 # date:2020/4/14 21:03
 3 import pika, time
 4 
 5 credentials = pika.PlainCredentials('kelvin', '123456')
 6 connection = pika.BlockingConnection(pika.ConnectionParameters('localhost', 5672, "vhost01", credentials))
 7 channel = connection.channel()
 8 channel.exchange_declare(exchange='logs',exchange_type='fanout')#使用交换机 类型为广播*****
 9 result = channel.queue_declare("",exclusive=True)  # 不指定queue名字,rabbit会随机分配一个名字,exclusive=True会在使用此queue的消费者断开后,自动将queue删除
10 queue_name = result.method.queue
11 channel.queue_bind(exchange='logs',queue=queue_name) #通道绑定随机分配的队列名*****
12 
13 def callback(ch, method, properties, body):
14     print("接收到消息：%r" % body)
15 channel.basic_consume(queue_name,callback,True)
16 channel.start_consuming()
    receive1
     1 # __author__:Kelvin
 2 # date:2020/4/14 21:03
 3 import pika, time
 4 
 5 credentials = pika.PlainCredentials('kelvin', '123456')
 6 connection = pika.BlockingConnection(pika.ConnectionParameters('localhost', 5672, "vhost01", credentials))
 7 channel = connection.channel()
 8 channel.exchange_declare(exchange='logs',exchange_type='fanout')#使用交换机 类型为广播*****
 9 result = channel.queue_declare("",exclusive=True)  # 不指定queue名字,rabbit会随机分配一个名字,exclusive=True会在使用此queue的消费者断开后,自动将queue删除
10 queue_name = result.method.queue
11 channel.queue_bind(exchange='logs',queue=queue_name) #通道绑定随机分配的队列名*****
12 
13 def callback(ch, method, properties, body):
14     print("接收到消息：%r" % body)
15 channel.basic_consume(queue_name,callback,True)
16 channel.start_consuming()
    receive2
     1 # __author__:Kelvin
 2 # date:2020/4/14 21:03
 3 import pika, time
 4 
 5 credentials = pika.PlainCredentials('kelvin', '123456')
 6 connection = pika.BlockingConnection(pika.ConnectionParameters('localhost', 5672, "vhost01", credentials))
 7 channel = connection.channel()
 8 channel.exchange_declare(exchange='logs',exchange_type='fanout')#使用交换机 类型为广播*****
 9 result = channel.queue_declare("",exclusive=True)  # 不指定queue名字,rabbit会随机分配一个名字,exclusive=True会在使用此queue的消费者断开后,自动将queue删除
10 queue_name = result.method.queue
11 channel.queue_bind(exchange='logs',queue=queue_name) #通道绑定随机分配的队列名*****
12 
13 def callback(ch, method, properties, body):
14     print("接收到消息：%r" % body)
15 channel.basic_consume(queue_name,callback,True)
16 channel.start_consuming()
    receive3

    四：RabbitMQ消息类型-direct（组播）

    原理图示：

    RabbitMQ还支持根据关键字发送，即：队列绑定关键字，发送者将数据根据关键字发送到消息exchange的routing_key属性，exchange根据 关键字 判定应该将数据发送至指定队列。

     1 # __author__:Kelvin
 2 # date:2020/4/14 21:00
 3 import pika
 4 import time
 5 import sys
 6 
 7 credentials = pika.PlainCredentials('kelvin', '123456')
 8 connection = pika.BlockingConnection(pika.ConnectionParameters('localhost', 5672, "vhost01", credentials))
 9 channel = connection.channel()
10 #使用交换机
11 channel.exchange_declare(exchange='direct_logs',exchange_type='direct')
12 message =" Hello World!"
13 severity="info"
14 channel.basic_publish(exchange='direct_logs',
15                       routing_key=severity,
16                       body=message)
17 print("成功发送消息： %r:%r" % (severity, message))
18 connection.close()
    send
     1 # __author__:Kelvin
 2 # date:2020/4/14 21:03
 3 import pika, time
 4 
 5 credentials = pika.PlainCredentials('kelvin', '123456')
 6 connection = pika.BlockingConnection(pika.ConnectionParameters('localhost', 5672, "vhost01", credentials))
 7 channel = connection.channel()
 8 channel.exchange_declare(exchange='direct_logs',exchange_type='direct')
 9 result = channel.queue_declare("",exclusive=True)
10 queue_name = result.method.queue
11 severities=["error","warning"]
12 for severity in severities:
13     channel.queue_bind(exchange='direct_logs',queue=queue_name,routing_key=severity)
14 def callback(ch, method, properties, body):
15     print("接收到消息：%r:%r" % (method.routing_key, body))
16 channel.basic_consume(queue_name,callback,True)
17 channel.start_consuming()
    receive1
     1 # __author__:Kelvin
 2 # date:2020/4/14 21:03
 3 import pika, time
 4 
 5 credentials = pika.PlainCredentials('kelvin', '123456')
 6 connection = pika.BlockingConnection(pika.ConnectionParameters('localhost', 5672, "vhost01", credentials))
 7 channel = connection.channel()
 8 channel.exchange_declare(exchange='direct_logs',exchange_type='direct')
 9 result = channel.queue_declare("",exclusive=True)
10 queue_name = result.method.queue
11 severities=["warning"]
12 for severity in severities:
13     channel.queue_bind(exchange='direct_logs',queue=queue_name,routing_key=severity)
14 def callback(ch, method, properties, body):
15     print("接收到消息：%r:%r" % (method.routing_key, body))
16 channel.basic_consume(queue_name,callback,True)
17 channel.start_consuming()
    receive2
     1 # __author__:Kelvin
 2 # date:2020/4/14 21:03
 3 import pika, time
 4 
 5 credentials = pika.PlainCredentials('kelvin', '123456')
 6 connection = pika.BlockingConnection(pika.ConnectionParameters('localhost', 5672, "vhost01", credentials))
 7 channel = connection.channel()
 8 channel.exchange_declare(exchange='direct_logs',exchange_type='direct')
 9 result = channel.queue_declare("",exclusive=True)
10 queue_name = result.method.queue
11 severities=["error","warning","info"]
12 for severity in severities:
13     channel.queue_bind(exchange='direct_logs',queue=queue_name,routing_key=severity)
14 def callback(ch, method, properties, body):
15     print("接收到消息：%r:%r" % (method.routing_key, body))
16 channel.basic_consume(queue_name,callback,True)
17 channel.start_consuming()
    receive3

    五：RabbitMQ消息类型-topic（更细致的过滤-组播）

    原理图示：

     1 # __author__:Kelvin
 2 # date:2020/4/14 21:00
 3 import pika
 4 import time
 5 import sys
 6 
 7 credentials = pika.PlainCredentials('kelvin', '123456')
 8 connection = pika.BlockingConnection(pika.ConnectionParameters('localhost', 5672, "vhost01", credentials))
 9 channel = connection.channel()
10 #使用交换机
11 channel.exchange_declare(exchange='topic_logs',exchange_type='topic')
12 message =" Hello World!"
13 severity="error.first"
14 channel.basic_publish(exchange='topic_logs',
15                       routing_key=severity,
16                       body=message)
17 print("成功发送消息： %r:%r" % (severity, message))
18 connection.close()
    send
     1 # __author__:Kelvin
 2 # date:2020/4/14 21:03
 3 import pika, time
 4 
 5 credentials = pika.PlainCredentials('kelvin', '123456')
 6 connection = pika.BlockingConnection(pika.ConnectionParameters('localhost', 5672, "vhost01", credentials))
 7 channel = connection.channel()
 8 channel.exchange_declare(exchange='topic_logs',exchange_type='topic')
 9 result = channel.queue_declare("",exclusive=True)
10 queue_name = result.method.queue
11 severity="info.*"
12 channel.queue_bind(exchange='topic_logs',queue=queue_name,routing_key=severity)
13 def callback(ch, method, properties, body):
14     print("接收到消息：%r:%r" % (method.routing_key, body))
15 channel.basic_consume(queue_name,callback,True)
16 channel.start_consuming()
    receive1
     1 # __author__:Kelvin
 2 # date:2020/4/14 21:03
 3 import pika, time
 4 
 5 credentials = pika.PlainCredentials('kelvin', '123456')
 6 connection = pika.BlockingConnection(pika.ConnectionParameters('localhost', 5672, "vhost01", credentials))
 7 channel = connection.channel()
 8 channel.exchange_declare(exchange='topic_logs',exchange_type='topic')
 9 result = channel.queue_declare("",exclusive=True)
10 queue_name = result.method.queue
11 severity="info.student.*"
12 channel.queue_bind(exchange='topic_logs',queue=queue_name,routing_key=severity)
13 def callback(ch, method, properties, body):
14     print("接收到消息：%r:%r" % (method.routing_key, body))
15 channel.basic_consume(queue_name,callback,True)
16 channel.start_consuming()
    receive2
     1 # __author__:Kelvin
 2 # date:2020/4/14 21:03
 3 import pika, time
 4 
 5 credentials = pika.PlainCredentials('kelvin', '123456')
 6 connection = pika.BlockingConnection(pika.ConnectionParameters('localhost', 5672, "vhost01", credentials))
 7 channel = connection.channel()
 8 channel.exchange_declare(exchange='topic_logs',exchange_type='topic')
 9 result = channel.queue_declare("",exclusive=True)
10 queue_name = result.method.queue
11 severity="#"
12 channel.queue_bind(exchange='topic_logs',queue=queue_name,routing_key=severity)
13 def callback(ch, method, properties, body):
14     print("接收到消息：%r:%r" % (method.routing_key, body))
15 channel.basic_consume(queue_name,callback,True)
16 channel.start_consuming()
    receive3

    六：RabbitMQ消息类型-RPC

    原理图示：

     1 #__author__:Kelvin
 2 #date:2020/4/15 0:20
 3 import pika
 4 import uuid
 5 
 6 
 7 class FibonacciRpcClient(object):
 8     def __init__(self):
 9         self.credentials = pika.PlainCredentials('kelvin', '123456')
10         self.connection = pika.BlockingConnection(pika.ConnectionParameters('localhost', 5672, "vhost01", self.credentials))
11         self.channel = self.connection.channel()
12         result = self.channel.queue_declare("",exclusive=True)
13         self.callback_queue = result.method.queue
14         self.channel.basic_consume(self.callback_queue,self.on_response,True)
15 
16     def on_response(self, ch, method, props, body):
17         if self.corr_id == props.correlation_id:
18             self.response = body
19 
20     def call(self, n):
21         self.response = None
22         self.corr_id = str(uuid.uuid4())
23         self.channel.basic_publish(exchange='',
24                                    routing_key='rpc_queue',
25                                    properties=pika.BasicProperties(
26                                        reply_to=self.callback_queue,
27                                        correlation_id=self.corr_id,
28                                    ),
29                                    body=str(n))
30         while self.response is None:
31             self.connection.process_data_events()
32         return int(self.response)
33 
34 fibonacci_rpc = FibonacciRpcClient()
35 print("请求计算 fib(10)")
36 response = fibonacci_rpc.call(10)
37 print("获取返回结果 %r" % response)
    RPCclient
     1 # __author__:Kelvin
 2 # date:2020/4/15 0:21
 3 import pika
 4 import time
 5 
 6 credentials = pika.PlainCredentials('kelvin', '123456')
 7 connection = pika.BlockingConnection(pika.ConnectionParameters('localhost', 5672, "vhost01", credentials))
 8 channel = connection.channel()
 9 channel.queue_declare(queue='rpc_queue')
10 
11 def fib(n):
12     if n == 0:
13         return 0
14     elif n == 1:
15         return 1
16     else:
17         return fib(n - 1) + fib(n - 2)
18 
19 
20 def on_request(ch, method, props, body):
21     n = int(body)
22     print("客户端请求计算的参数为：%s"%n)
23     response = fib(n)
24     ch.basic_publish(exchange='',
25                      routing_key=props.reply_to,
26                      properties=pika.BasicProperties(correlation_id=props.correlation_id),
27                      body=str(response))
28     ch.basic_ack(delivery_tag=method.delivery_tag)
29 
30 channel.basic_qos(prefetch_count=1)
31 channel.basic_consume('rpc_queue',on_request)
32 channel.start_consuming()
    RPCserver

    RabbitMQ运行环境erlang和rabbitmq服务器软件下载地址：

    链接：https://pan.baidu.com/s/12WEKqztnHDZE0_xfkSn7fg
    提取码：zasx

  • 相关阅读:
    矩阵构造方法（转载）
    欧拉函数
    POJ3233:Matrix Power Series(矩阵快速幂+二分）
    矩阵快速幂（转载）
    素数筛法模板
    快速幂取模算法
    hdu1286(找新朋友）&&POJ2407Relatives（欧拉函数模版题）
    判断两线段相交
    POJ3070:Fibonacci(矩阵快速幂模板题）
    HDU1575:Tr A(矩阵快速幂模板题）
  • 原文地址：https://www.cnblogs.com/sun-10387834/p/12703331.html
Copyright © 2011-2022 走看看