rabbitmq的简单介绍一

该博客的主要讲解了以下几种rabbitmq的用法
1、实现简单的生产者发送消息给消费者
2、实现序列持久化
3、实现消息持久化
4、实现消息公平分发
5、实现广播
6、实现组播
7、实现细分组播

先来看下rabbitmq的简单介绍，我们后面介绍具体的代码

python操作rabbitmq的模块叫做pika

1个生产者对应1个消费者

如果生产者发送一条消息，那么消费者也只能接受到1条消息
如果生产者发送两条消息，那么消费者就可以接受到2条消息

1个生产者对应2个消费者
如果生产者发送1条消息，那么只有1个消费者能接受到消息
如果生产者发送2条消息，那么每个消费者都接受到1条消息

如果生产者先启动了，生产者的代码已经执行完成，程序退出，这个时候消费者才启动，消费者也能接受到消息

work queue
如果一个生产者对应多个消费者，那么生产者会依次把消息轮训到多个消费者上，实现一个负载均衡的效果

但是如果rabbitmq server重启后，则队列和消息就会丢失
1、队列持久化
durable=True
2、消息持久化
delivery_mode = 2

如果申明一个queue为持久化，那么就需要在服务端和客户端都需要设置

如果申明一个消息的持久化，加一个
delivery_mode = 2

消息公平分发
确保每个消费者同时只能有固定的数量的任务在处理，比如这个固定的任务是1或者2或者3之类的
这个需要在消费者端设置，设置我这个消费者同时只能处理几个任务
设置方法如下，这个1就是同时只能处理一个任务
channel.basic_qos(prefetch_count=1)

发布订阅
前面的一条消息只能被一个客户端消费，那么发布和订阅就是一条消息可以被
多个客户端消息，这里就需要用到“Exchange”，Exchange在定义的时候是有
类型的，以决定到底哪些queue符合条件，可以接受消息，一个exchange可以绑
定多个queue
一个exchange可以绑定多个queue

fanout：所有绑定在这个exchange上的队列都会接受到消息

direct：通过routingKey和exchange决定的哪个唯一的queue可以接收消息
        可以根据关键字发送，即：队列绑定关键字，发送者将根据关键字发送消息
        到指定的队列中

topic：所有符合routingKey（此时可以是一个表达式）的routingKey所绑定
       的queue都可以接收到消息
       表达式符合说明：#号代表一个或多个字符，*代表人和字符
       例如
       #a.a会匹配a.a,aa.a,aaa.a
       *.a会匹配a.a,b.a,c.a
headers:通过headers来决定把消息发给哪些queue

一、先看下rabbitmq的最简单的使用，实现简单的通信

1、先看生产者的代码

# 1、创建一个连接
# 2、创建一个管道
# 3、创建一个队列

import pika

test_connection = pika.BlockingConnection(pika.ConnectionParameters(host="localhost"))
# 1、创建一个连接

test_channel = test_connection.channel()
# 2、创建一个管道

test_channel.queue_declare(queue="test1")
#申明一个队列，名称为“test1”

test_channel.basic_publish(exchange="",
                           routing_key="test1",
                           body="hi,this is 1")

#通过管道发送消息
# 1、exchange主要是队列选择，控制消息往哪个队列中发送，这里还没有用到，后面才会遇到
# 2、routing_key就是指明队列的名称
# 3、body就是发送的消息

print("pub send message success!")
#没有特殊的意义

test_channel.close()
#关闭连接

2、在看消费者的代码

import pika

test_connection = pika.BlockingConnection(pika.ConnectionParameters(host="localhost"))
#创建一个连接

test_channel = test_connection.channel()
#申明一个管道

test_channel.queue_declare(queue="test1")
#在管道中创建一个队列，名称为“test1”，该名称要和生产者的名称一样，

def f(ch,method,properties,body):
    print("pub:",body)

#定义一个函数，这个函数的作用就是只要消费者端收到信息，则会立刻触发执行这个函数

test_channel.basic_consume(f,
                           queue="test1",
                           no_ack=True)

#这里的意思是，写好监控的代码，但是还没有开始监控，这个作用就，兼容队列“test1”，只有一有消息进来，则立刻触发f这个函数，函数中的body参数
# 就是队列中的消息

print("sub waiting for message!")

test_channel.start_consuming()
#这句话的才是真正的开始监控队列中的消息，如果没有收到消息，则会一直阻塞，如果有消息，则不阻塞

二、这里我们介绍下如何实现序列持久化，何为序列持久化，我们在这里需要说明一下

序列持久化：我们在管道中申明了一个序列，如果rabbitmq重启后，则这个序列就会丢失；如果我们实现序列持久化，得到的效果就是如果我们开始申明过一个序列，且把该序列持久化，那么就算rabbitmp服务器重启，我们也不需要在重新申明序列，如果测试我们可以这样做：先执行服务端的代码，执行完成后重启rabbitmq，然后修改生产者的代码，把申明队列的代码注释掉，代码还是可以正常的执行，不会报错，启动消费者的代码，可以正常接受到消息。

核心的代码如下

在消费端的代码和服务端的代码是一样的，只需要在申明队列的加一个参数即可

注：这里需要注意的是，如果在前面定义一个名称为队列的名称为“a”，如果我们在没有重启rabbitma之前，如果想把队列“a”修改为持久化，则会报错

test_channel.queue_declare(queue="test1",durable=True)

　　

三、这里我们介绍下如何实现消息的持久化，何为消息持久化，我们在这里需要说明一下

消息持久化：如果生产者的代码已经执行完成，即消息已经发送出去了，此时消费者还未消费这条消息，此时rabbitmq重启，重启成功后，此时启动消费者的代码，消费者还可以正常的接受到消息

核心代码如下，实现消息持久化，生产者和消费者的代码是不一样

先看生产者的核心代码，在发布消息的时候加这么一行即可：

test_channel.basic_publish(exchange="",
                           routing_key="test1",
                           body="hi,this is 1",
                           properties=pika.BasicProperties(delivery_mode=2))

在看消费者的核心代码，在回调函数中加一行即可

def f(ch,method,properties,body):
    ch.basic_ack(delivery_tag=method.delivery_tag)
    print("pub:",body)

四、我们在看看下如何实现消息的公平分发，主要处理的场景是这样的：正常情况下，如果有多个消费者，消息处理的原则是这样的，第一条消息由A消费者处理，第二天消息由B消费者处理，第三条消息由C处理，那么如果消费者A、B、C的处理消息的能力不一样，那么就会出现配置高的消费者处于空闲状态，配置低的消费者一直在不停处理问题的；消息的公平分发就是要解决这个问题，最终的效果就是同一个时间一个消费者只能处理处理一个消息，如果A消费者没有处理完，则会把消息发送给消费者2处理，而不会一直等待消费者A去处理

消息的公平处理的代码也很简单，消费者端实现，生产者端不需要做任何修改

核心代码如下，只有一行代码，这里的1就是同一时间一个消费者只处理一条消息

channel.basic_qos(prefetch_count=1)

五、实现广播，这个是什么意思呢？我们这里简单介绍一下，前面我们讲的所有的例子都是一条消息只能被一个消费者消费，而广播实现的效果就是一条消息可以发送多个消费者

要实现广播，我们这里需要用到exchange了，只要绑定在一个exchange的队列都可以接受到同一条消息

先看一个简单的实现

生产者端绑定3个queue到exchange上，三个消费者每个绑定了一个queue到exchange上，我们看下效果

生产者的代码

import pika

test_connection = pika.BlockingConnection(pika.ConnectionParameters(host="localhost"))

test_channel = test_connection.channel()

test_channel.exchange_declare(exchange="test",
                              exchange_type="fanout")

queue_list = []
test_channel.queue_declare(queue="hello1",durable=True)
queue_list.append("hello1")
test_channel.queue_declare(queue="hello2",durable=True)
queue_list.append("hello2")
test_channel.queue_declare(queue="hello3",durable=True)
queue_list.append("hello3")

for i in queue_list:
    test_channel.basic_publish(exchange="test",
                               routing_key=i,
                               body="broadcast information!")

test_channel.close()

消费者的代码

import pika

test_connection = pika.BlockingConnection(pika.ConnectionParameters(host="localhost"))

test_channel = test_connection.channel()

test_channel.exchange_declare(exchange="test",
                         exchange_type="fanout")

test_channel.queue_declare(queue="hello1",durable=True)

test_channel.queue_bind(exchange="test",queue="hello1")

def callback(ch,method,properties,body):
    print("server:",body)

test_channel.basic_consume(callback,
                           queue="hello1",
                           no_ack=True)

test_channel.start_consuming()

我们看下结果：每个消费者都接受到了3条消息，但是我们在生产者端明明是往每个队列中发一条消息，为什么消费者1、2、3都收到了3条消息呢，因为我们什么exchange的类型fanout了，exchange类型就会把消息广播到所有绑定到该exchange上的队列

server: b'broadcast information!'
server: b'broadcast information!'
server: b'broadcast information!'

在看下官方的代码例子，其实如果exchange的类似fanout，就不需要申明队列了，只需要申明exchange的类型和名称即可

先看生产者端代码

import pika
import sys

# 前面的例子都基本是1对1的消息发送和接受，即消息之恩能够发送到指定的队列中，但是
# 有的时候我们需要消息被所有的queue接受，类似的广播的效果
# 如果要实现广播的效果，这时候就要用到exchange了

# exchange在定义的时候是有类型的，以决定到底哪些队列符合条件，可以接受消息

# 如果是fanout，则不需要申明queue

client_connection = pika.BlockingConnection(pika.ConnectionParameters(host="localhost"))
#首先也是要连接上rabbitmq，和生产者端是一样的

channel = client_connection.channel()

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

message = "".join(sys.argv[1:]) or "info:hello world!"

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

print("[x] send %r" % message)

client_connection.close()

　　

在看消费者端的代码，消费者端需要申明一个队列，这里我们没有生成一个具体的名称，而是让系统自动替我们申明了一个队列，该队列在代码执行完成后自动销毁

自动生成队列的如下

result = channel.queue_declare(exclusive=True)
#不指定queue的名字，rabbitmq自动随机分配一个名字，并且在这个queue会在消费者
#断开后自动被删除

queue_name = result.method.queue

消费者的核心代码如下

import pika

client_connection = pika.BlockingConnection(pika.ConnectionParameters(host="localhost"))
#首先也是要连接上rabbitmq，和生产者端是一样的
channel = client_connection.channel()

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

result = channel.queue_declare(exclusive=True)
#不指定queue的名字，rabbitmq自动随机分配一个名字，并且在这个queue会在消费者
#断开后自动被删除

queue_name = result.method.queue

channel.queue_bind(exchange="logs",
                   queue=queue_name)
#把queue绑定到exchange上，他才能接受消息

print("waiting for message")
def callback(ch,method,properties,body):
    print("receive message %r" %body)

channel.basic_consume(callback,
                      queue=queue_name,
                      no_ack=True)
channel.start_consuming()