RabbitMQ学习小结(六)----远程调用

一、引出问题

1、前面的例子都有个共同点，就是发送端发送消息出去后没有结果返回。如果只是单纯发送消息，当然没有问题了，但是在实际中，

常常会需要接收端将收到的消息进行处理之后，返回给发送端。

2、处理方法描述：发送端在发送信息前，产生一个接收消息的临时队列，该队列用来接收返回的结果。其实在这里接收端、发送端

的概念已经比较模糊了，因为发送端也同样要接收消息，接收端同样也要发送消息。

3、我们会使用RabbitMQ来构建一个RPC系统：包含一个客户端和一个RPC服务器。现在的情况是，我们没有一个值得被分发的足够耗

时的任务，所以接下来，我们会创建一个模拟RPC服务来返回斐波那契数列。

4、基本流程如下图：

RabbitMQ中实现RPC的机制是：

(1) 客户端发送消息请求时，在消息的属性设置两个值reply_to和correlation_id

 reply_to和correlation_id，这两个属性是AMQP中消息的属性，reply_to是我们上面提到的服务端处理完成之后将结果发送给

 客户端指定的队列；而correlation_id是将RPC的请求和响应关联起来，此次RPC请求的标识号，服务器处理消息完成后将此属性

 返回，客户端根据这个id理解哪条请求被成功执行或执行失败。

AMQP协议给消息预定义了一系列的14个属性。大多数属性很少会用到，除了以下几个：

delivery_mode（投递模式）：将消息标记为持久的（值为2）或暂存的（除了2之外的其他任何值）

content_type（内容类型）:用来描述编码的mime-type。例如在实际使用中常常使用application/json来描述JOSN编码类型。

reply_to（回复目标）：通常用来命名回调队列。

correlation_id（关联标识）：用来将RPC的响应和请求关联起来。

看看AMQP协议的一些简介及属性等内容。

(2) 服务器端接收到消息并处理

(3) 服务器端处理完消息后，将生成的应答消息到reply_to指定的队列中，同时带上correlation_id属性

(4) 客户端之前已经订阅replyto指定的queue，从中接收到服务器的应答消息后，根据其中的属性correlation_id分析哪条请求被

执行了，根据执行结果进行后续业务处理。

二、代码实现：

rpc_client.py: 客户端

#!/usr/bin/python                                                               

import uuid
import pika

class FibRpcClient(object):
    def __init__(self):
        self.connection = pika.BlockingConnection(pika.ConnectionParameters(host='localhost'))
        self.channel = self.connection.channel()    #建立连接RabbitMQ服务器和通道
        
        result = self.channel.queue_declare(exclusive=True) #声明自己的临时回调队列
        self.callback_queue = result.method.queue

        self.channel.basic_consume(self.on_response, no_ack = True, queue=self.callback_queue) #作为消费者处理响应的消息

    def on_response(self, ch, method, props, body): #回调函数处理响应的消息
        if self.corr_id == props.correlation_id:    #请求和响应关联
            self.response = body

    def call(self, n):
        self.response = None
        self.corr_id = str(uuid.uuid4())
        self.channel.basic_publish(exchange='',routing_key = 'rpc_queue', properties=    #消息属性
                    pika.BasicProperties(reply_to = self.callback_queue, correlation_id = 
                        self.corr_id),body=str(n))
        
        print '1st call hello world...'
        while self.response is None:
            self.connection.process_data_events()

        return int(self.response)

fib = FibRpcClient()

print ' [x] requesting fib(30)'
response = fib.call(30)

print ' [.] Got %d' % response

rpc_server.py:服务器

#!/usr/bin/python
import pika

connection = pika.BlockingConnection(pika.ConnectionParameters(host = 'localhost'))
channel = connection.channel()

channel.queue_declare(queue = 'rpc_queue') #服务器队列

def fib(n):
    if n == 0:                                                                  
        return 0
    if n == 1:
        return 1
    return fib(n-1) + fib(n-2)

def on_request(ch, method, props, body):
    n = int(body)
    print ' [.] fib(%s)' % body
    response = fib(n)
    #将响应消息发送到指定的消息响应队列中，消息属性携带自身的标识
    ch.basic_publish(exchange = '', routing_key = props.reply_to, 
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) 
channel.basic_consume(on_request, queue = 'rpc_queue') #从队列中取出消息进行处理

print ' [x] waiting RPC requests...'
channel.start_consuming()

我们的RPC服务已经准备就绪了，现在启动服务器端：应该一直运行

运行客户端，请求一个fibonacci队列。

我们的代码依旧非常简单，而且没有试图去解决一些复杂（但是重要）的问题。但是大致上了解了利用RabbitMQ实现RPC的流程，可

以继续下去分析openstack的代码了！！！

RPC远程程序调用和RabbitMQ就介绍到这里，谢谢各位博友的帮助。