#######################简单模式#######################
### 生产者

import pika

# 1 链接rabbitmq
connection = pika.BlockingConnection(pika.ConnectionParameters(‘127.0.0.1‘))
channel = connection.channel()

# 2 创建队列
channel.queue_declare(queue=‘hello‘)

# 3 向指定队列插入数据
channel.basic_publish(exchange=‘‘, # 简单模式
                      routing_key=‘hello‘, # 指定队列
                      body=‘Hello Yuan!‘)

print(" [x] Sent ‘Hello Yuan!‘")


### 消费者
import pika

connection = pika.BlockingConnection(pika.ConnectionParameters(‘localhost‘))
channel = connection.channel()

#  创建队列
channel.queue_declare(queue=‘hello‘)

# 确定回调函数
def callback(ch, method, properties, body):
    print(" [x] Received %r" % body)

# 确定监听队列参数
channel.basic_consume(queue=‘hello‘,
                      auto_ack=True, # 默认应答
                      on_message_callback=callback)

print(‘ [*] Waiting for messages. To exit press CTRL+C‘)

# 正式监听
channel.start_consuming()




#######################应答参数#######################
"""
### 消费者
auto_ack=False
ch.basic_ack(delivery_tag=method.delivery_tag)
"""
### 消费者
import pika


connection = pika.BlockingConnection(pika.ConnectionParameters(‘localhost‘))
channel = connection.channel()

#  创建队列
channel.queue_declare(queue=‘hello‘)


# 确定回调函数
def callback(ch, method, properties, body):

    print(" [x] Received %r" % body)
    ch.basic_ack(delivery_tag=method.delivery_tag)  #######2.#######

# 确定监听队列参数
channel.basic_consume(queue=‘hello‘,
                      auto_ack=False, ####### 1.默认应答改为手动应答
                      on_message_callback=callback)


print(‘ [*] Waiting for messages. To exit press CTRL+C‘)
# 正式监听
channel.start_consuming()



#######################持久化参数#######################
"""
#声明queue
channel.queue_declare(queue=‘hello2‘, durable=True)  # 若声明过，则换一个名字
 
channel.basic_publish(exchange=‘‘,
                      routing_key=‘hello2‘,
                      body=‘Hello World!‘,
                      properties=pika.BasicProperties(
                          delivery_mode=2,  # make message persistent
                          )
                      )
"""
### 生产者

import pika

# 1 链接rabbitmq
connection = pika.BlockingConnection(pika.ConnectionParameters(‘127.0.0.1‘))
channel = connection.channel()

# 2 创可持久化队列
channel.queue_declare(queue=‘hello3‘,durable=True)   ####1.若声明过，则换一个名字

# 3 向指定队列插入数据
channel.basic_publish(exchange=‘‘, # 简单模式
                      routing_key=‘hello3‘, # 指定队列
                      body=‘Hello ALEX!‘,
                      properties=pika.BasicProperties(
                          delivery_mode=2,  #2 make message persistent
                      )
                      )

print(" [x] Sent ‘Hello ALEX!‘")

### 消费者
import pika


connection = pika.BlockingConnection(pika.ConnectionParameters(‘localhost‘))
channel = connection.channel()

#  创建队列
channel.queue_declare(queue=‘hello3‘,durable=True)  #### 1.


# 确定回调函数
def callback(ch, method, properties, body):

    print(" [x] Received %r" % body)
    ch.basic_ack(delivery_tag=method.delivery_tag)

# 确定监听队列参数
channel.basic_consume(queue=‘hello3‘,
                      auto_ack=False, # 默认应答改为手动应答
                      on_message_callback=callback)


print(‘ [*] Waiting for messages. To exit press CTRL+C‘)
# 正式监听
channel.start_consuming()


#######################分发参数#######################
"""
channel.basic_qos(prefetch_count=1)

有两个消费者同时监听一个的队列。其中一个线程sleep2秒，另一个消费者线程sleep1秒，
但是处理的消息是一样多。这种方式叫轮询分发（round-robin）不管谁忙，都不会多给消息，
总是你一个我一个。想要做到公平分发（fair dispatch），必须关闭自动应答ack，改成手动应答。
使用basicQos(perfetch=1)限制每次只发送不超过1条消息到同一个消费者，消费者必须手动反馈告知队列，才会发送下一个。
"""

### 消费者

import pika


connection = pika.BlockingConnection(pika.ConnectionParameters(‘localhost‘))
channel = connection.channel()

#  创建队列
channel.queue_declare(queue=‘hello4‘)


# 确定回调函数
def callback(ch, method, properties, body):
    import time
    time.sleep(5)
    print(" [x] Received %r" % body)
    ch.basic_ack(delivery_tag=method.delivery_tag)

#  公平分发
channel.basic_qos(prefetch_count=1)

# 确定监听队列参数
channel.basic_consume(queue=‘hello4‘,
                      auto_ack=False, # 默认应答改为手动应答
                      on_message_callback=callback)


print(‘ [*] Waiting for messages. To exit press CTRL+C‘)
# 正式监听
channel.start_consuming()

#######################交换机之发布订阅#######################
###生产者
import pika

# 链接rabbitmq
connection = pika.BlockingConnection(pika.ConnectionParameters(host=‘localhost‘))
channel = connection.channel()


# 声明一个名为logs类型为fanout的交换机
channel.exchange_declare(exchange=‘logs‘,
                         exchange_type=‘fanout‘) # fanout：发布订阅模式参数

# 向logs交换机插入数据"info: Hello World!"
message = "info: Hello World!"
channel.basic_publish(exchange=‘logs‘,
                      routing_key=‘‘,
                      body=message)
print(" [x] Sent %r" % message)
connection.close()


###消费者
import pika

# 链接rabbitmq
connection = pika.BlockingConnection(pika.ConnectionParameters(host=‘localhost‘))
channel = connection.channel()

# 声明一个名为logs类型为fanout的交换机
channel.exchange_declare(exchange=‘logs‘,
                         exchange_type=‘fanout‘)

# 创建队列 (随机生成一个队列)
result = channel.queue_declare("",exclusive=True)
queue_name = result.method.queue
print(queue_name)

# 将指定队列绑定到交换机上
channel.queue_bind(exchange=‘logs‘,
                   queue=queue_name)

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

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


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

channel.start_consuming()


#######################交换机之关键字#######################
###生产者

import pika

# 链接rabbitmq
connection = pika.BlockingConnection(pika.ConnectionParameters(host=‘localhost‘))
channel = connection.channel()


# 声明一个名为logs类型为fanout的交换机
channel.exchange_declare(exchange=‘logs2‘,
                         exchange_type=‘direct‘) # fanout：发布订阅模式参数

# 向logs交换机插入数据"info: Hello World!"
message = "error: Hello World!"
channel.basic_publish(exchange=‘logs2‘,
                      routing_key=‘error‘,
                      body=message)
print(" [x] Sent %r" % message)
connection.close()


###消费者
import pika

# 链接rabbitmq
connection = pika.BlockingConnection(pika.ConnectionParameters(host=‘localhost‘))
channel = connection.channel()


# 声明一个名为logs类型为fanout的交换机
channel.exchange_declare(exchange=‘logs2‘,
                         exchange_type=‘direct‘)

# 创建队列(随机生成一个队列)
result = channel.queue_declare("",exclusive=True)
queue_name = result.method.queue
print(queue_name)

# 将指定队列绑定到交换机上
channel.queue_bind(exchange=‘logs2‘,
                   queue=queue_name,
                   routing_key="info"
                   )

channel.queue_bind(exchange=‘logs2‘,
                   queue=queue_name,
                   routing_key="error"
                   )


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

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


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

channel.start_consuming()



#######################交换机之通配符#######################
###生产者
import pika

# 链接rabbitmq
connection = pika.BlockingConnection(pika.ConnectionParameters(
        host=‘localhost‘))
channel = connection.channel()


# 声明一个名为logs类型为fanout的交换机
channel.exchange_declare(exchange=‘logs3‘,
                         exchange_type=‘topic‘) # fanout：发布订阅模式参数

# 向logs交换机插入数据"info: Hello World!"
message = "usa.weather......."
channel.basic_publish(exchange=‘logs3‘,
                      routing_key=‘usa.weather‘,
                      body=message)
print(" [x] Sent %r" % message)
connection.close()



###消费者
import pika

# 链接rabbitmq
connection = pika.BlockingConnection(pika.ConnectionParameters(host=‘localhost‘))
channel = connection.channel()

# 声明一个名为logs类型为fanout的交换机
channel.exchange_declare(exchange=‘logs3‘,
                         exchange_type=‘topic‘)

# 创建队列(随机生成一个队列)
result = channel.queue_declare("",exclusive=True)
queue_name = result.method.queue
print(queue_name)

# 将指定队列绑定到交换机上
channel.queue_bind(exchange=‘logs3‘,
                   queue=queue_name,
                   routing_key="#.weather"
                   )


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

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


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

channel.start_consuming()

import pika
import uuid
import time

# 斐波那契数列 前两个数相加依次排列
class FibonacciRpcClient(object):
    def __init__(self):
        # 赋值变量，一个循环值
        self.response = None
        # 客户端启动时，创建回调队列，会开启会话用于发送RPC请求以及接受响应
        # 建立连接，指定服务器的ip地址
        self.connection = pika.BlockingConnection(pika.ConnectionParameters(
                host=‘localhost‘))
        self.channel = self.connection.channel()

        # 声明回调队列，再次声明的原因是，服务器和客户端可能先后开启，该声明是幂等的，多次声明，但只生效一次
        # exclusive=True 参数是指只对首次声明它的连接可见
        # exclusive=True 会在连接断开的时候，自动删除

        # 生成随机queue
        result = self.channel.queue_declare("",exclusive=True)
        # 随机取queue名字，发给消费端
        # 将次队列指定为当前客户端的回调队列
        self.callback_queue = result.method.queue

        # self.on_response 回调函数:只要收到消息就调用这个函数。
        # 声明收到消息后就 收queue=self.callback_queue内的消息

        # 客户端订阅回调队列，当回调队列中有响应时，调用`on_response`方法对响应进行处理;
        self.channel.basic_consume(queue=self.callback_queue,
                                   auto_ack=True,
                              on_message_callback=self.on_response)

    # 对回调队列中的响应进行处理的函数

    # 收到消息就调用
    # ch 管道内存对象地址
    # method 消息发给哪个queue
    # body数据对象
    def on_response(self, ch, method, props, body):
        # 判断本机生成的ID 与 生产端发过来的ID是否相等
        if self.corr_id == props.correlation_id:
            # 将body值 赋值给self.response
            self.response = body

    # 发出RPC请求
    # 例如这里服务端就是一个切菜师傅，菜切好了，需要传递给洗菜师傅，这个过程是发送rpc请求

    def call(self, n):

        # 生成correlation_id 关联标识，通过python的uuid库，生成全局唯一标识ID，保证时间空间唯一性
        #　随机一次唯一的字符串
        self.corr_id = str(uuid.uuid4())

        # 发送RPC请求内容到RPC请求队列`s14rpc`，同时发送的还有`reply_to`和`correlation_id`
        # routing_key=‘rpc_queue‘ 发一个消息到rpc_queue内
        self.channel.basic_publish(exchange=‘‘,
                                   routing_key=‘rpc_queue‘,
                                   properties=pika.BasicProperties(

                                         # 执行命令之后结果返回给self.callaback_queue这个队列中
                                         reply_to = self.callback_queue,
                                         # 生成UUID 发送给消费端
                                         correlation_id = self.corr_id,
                                         ),
                                   # 发的消息，必须传入字符串，不能传数字
                                   body=str(n))
        # 没有数据就循环收
        while self.response is None:
            # 非阻塞版的start_consuming()
            # 没有消息不阻塞
            self.connection.process_data_events()
            print("no msg...")
            time.sleep(0.5)
        return int(self.response)

#　实例化  建立客户端
fibonacci_rpc = FibonacciRpcClient()

# 发送RPC请求，丢进rpc队列，等待客户端处理完毕，给与响应
print("发送了请求sum(50)")
response = fibonacci_rpc.call(50)
print("得到远程结果响应%r" % response)

import pika
import time
# 链接socket
connection = pika.BlockingConnection(pika.ConnectionParameters(
        host=‘localhost‘))
# 建立会话
channel = connection.channel()

# 声明RPC请求队列
channel.queue_declare(queue=‘rpc_queue‘)

#　斐波那契数列
def fib(n):
    if n == 0:
        return 0
    elif n == 1:
        return 1
    else:
        return fib(n-1) + fib(n-2)

# 模拟一个进程，例如切菜师傅，等着洗菜师傅传递数据
def sum(n):
    n+=100
    return n
# 对RPC请求队列中的请求进行处理


# 收到消息就调用
# ch 管道内存对象地址
# method 消息发给哪个queue
# props 返回给消费的返回参数
# body数据对象
def on_request(ch, method, props, body):
    n = int(body)

    print(" [.] fib(%s)" % n)
    # 调用斐波那契函数 传入结果
    response = fib(n)
    
    # 调用数据处理方法
    # response = sum(n)

    ch.basic_publish(exchange=‘‘,
                     # reply_to代表回复目标
                     # 生产端随机生成的queue
                     routing_key=props.reply_to,
                     # 获取UUID唯一 字符串数值
                     # correlation_id（关联标识）：用来将RPC的响应和请求关联起来。

                     properties=pika.BasicProperties(correlation_id =                                                    props.correlation_id),
                     # 消息返回给生产端
                     body=str(response))
    # 确保任务完成
    ch.basic_ack(delivery_tag = method.delivery_tag)

# 负载均衡，同一时刻发送给该服务器的请求不超过一个
# channel.basic_qos(prefetch_count=1)

# rpc_queue收到消息:调用on_request回调函数
# queue=‘rpc_queue‘从rpc内收
channel.basic_consume(queue="rpc_queue",
                      auto_ack=True,
                      on_message_callback=on_request)
print(" [x] Awaiting RPC requests")

#开始消费
channel.start_consuming()