远程过程调用(RPC)
(使用Java客户端)
在指南的第二部分，我们学习了如何使用工作队列将耗时的任务分布到多个工作者中。
但是假如我们需要调用远端计算机的函数，等待结果呢？好吧，这又是另一个故事了。这模式通常被称为远程过程调用或RPC。
在这部分，我们将会使用RabbitMQ构建一个RPC系统：一个客户端和一个可扩展的RPC服务器。由于我们还没有值得分散的耗时任务，我们将会创建一个虚拟的RPC服务，用来返回Fibonacci(斐波纳契数列)。
用户接口
为了说明RPC服务如何使用，我们将会创建一个简单德客户端类。它会暴露一个叫call的方法，用来发送一个RPC请求，在响应回复之前都会一直阻塞：
FibonacciRpcClient fibonacciRpc = new FibonacciRpcClient();
String result = fibonacciRpc.call("4");
System.out.println( "fib(4) is " + result);
RPC方面的注意
虽然RPC在电脑运算方面是一个十分普通的模式，但是它依旧常常受批判的。
如果一个程序员没有意识到函数call是本地的还是一个迟钝的RPC。这结果是不可预知的很让你困惑的，并且会增加不必要的复杂调试。与简化软件相反，误用RPC会导致不可维护的意大利面条代码（译者注：原文是spaghetti code可能形容代码很长很乱）。
思想中煎熬，考虑下接下来的建议：
确保明显区分哪个是函数call是本地调用的，哪个是远端调用的。
给你的系统加上文档，让组件之间的依赖项清晰可见的。
处理错误事件。当RPC服务器很久没有响应了，客户端应该如何响应？
当关于RPC的所有疑问消除，在你可以的情况下，你应该使用一个异步的管道，代替RPC中阻塞，结果会异步的放入接下来的计算平台。
回收队列
一般来说在RabbitMQ上做RPC是容易的。一个客户端发送一个请求消息，一个服务器返回响应消息。为了接受到响应，我们需要再请求中带上一个callback队列的地址。我们可以使用默认队列(那个在Java客户端上市独占的)。让我们试一下：
callbackQueueName = channel.queueDeclare().getQueue();
BasicProperties props = new BasicProperties
.Builder()
.replyTo(callbackQueueName)
.build();
channel.basicPublish("", "rpc_queue", props, message.getBytes());
// ... then code to read a response message from the callback_queue ...
消息属性
这AMQP协议预先确定了消息中的14个属性。他们大多数属性很少使用，除了下面这些例外：deliveryMode:将一个消息标记为持久化(值为2)或者瞬态的(其他值)。你可能从第二部分中记起这个属性。contentType:用来描述媒体类型的编码。例如常常使用的JSON编码，这是一个好的惯例，设置这个属性为：application/json。replyTo:通常来命名回收队列的名字。correlationId:对RPC加速响应请求是很有用的。
我们需要这个新的引用：
import com.rabbitmq.client.AMQP.BasicProperties;
相关性ID (原：Correlation Id)
在当前方法中我们建议为每一个RPC请求创建一个回收队列。这个效率十分低下的，但幸运的是有一个更好的方式- 让我们为每一个客户端创建一个单一的回收队列。
这样又出现了新的问题，没有清晰的判断队列中的响应是属于哪个请求的。这个时候coorrelationId属性发挥了作用。我们将每个请求的这个属性设置为唯一值。以后当我们在回收队列中接收消息时，我们将会查看这个属性，依据这个属性值，我们是能将每个响应匹配的对应的请求上。如果我们遇见个未知的correlationId值，我们可以安全的丢弃这个消息-因为它不属于任何一个我们的请求。
你可能会问，为什么我们要忽略哪些在回收队列中未知的消息，而不是以一个错误结束？因为在服务器竟态条件下，这种情况是可能的。RPC服务器发送给
我们答应之后，在发送一个确认消息之前，就死掉了，虽然这种可能性不大，但是它依旧存在可能。如果这事情发生了，RPC服务器重启之后，将会再一次处理请
求。这就是为什么我们要温和地处理重复的响应，这RPC理想情况下是幂等的。
摘要
我们的RPC将会像这样工作：
当客户端启动，它会创建一个匿名的独占的回收队列。
对于一个RPC请求，客户端会发送一个消息中有两个属性：replyTo,要发送的的回收队列和correlationId,对于每一个请求都是唯一值。
这请求发送到rpc_queue队列中。
这RPC工作者(亦称：服务器)等候队列中的请求。当请求出现，它处理这工作并发送携带结果的信息到客户端，使用的队列是消息属性replTo中的那个。
客户端等待回收队列中的数据。当一个消息出现，它会检查correlationId属性。如果它符合请求中的值，它会返回这响应给应用程序。
把所有的放在一起
斐波那契任务：
private static int fib(int n) throws Exception {
if (n == 0) return 0;
if (n == 1) return 1;
return fib(n-1) + fib(n-2);
}
我们声明我们的斐波那契函数。它假定一个合法的正整数做为输入参数。（不要期望这个可以处理大量数字，它可能是最慢的递归实现了）。
我们的RPC服务器RPCServer.java的代码：
private static final String RPC_QUEUE_NAME = "rpc_queue";
ConnectionFactory factory = new ConnectionFactory();
factory.setHost("localhost");
Connection connection = factory.newConnection();
Channel channel = connection.createChannel();
channel.queueDeclare(RPC_QUEUE_NAME, false, false, false, null);
channel.basicQos(1);
QueueingConsumer consumer = new QueueingConsumer(channel);
channel.basicConsume(RPC_QUEUE_NAME, false, consumer);
System.out.println(" [x] Awaiting RPC requests");
while (true) {
QueueingConsumer.Delivery delivery = consumer.nextDelivery();
BasicProperties props = delivery.getProperties();
BasicProperties replyProps = new BasicProperties
.Builder()
.correlationId(props.getCorrelationId())
.build();
String message = new String(delivery.getBody());
int n = Integer.parseInt(message);
System.out.println(" [.] fib(" + message + ")");
String response = "" + fib(n);
channel.basicPublish( "", props.getReplyTo(), replyProps, response.getBytes());
channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);
}
这服务器代码是相当简单明了的：
如往常一样，我们开始建立连接，通道和声明队列。
我们可能想运行不止一个服务器进程。为了均衡的负载到多个服务器上，我们需要设置channel.basicQos中的prefetchCount属性。
我们使用basicConsume访问队列。然后进入while循环，我们等待请求消息，处理工作，发送响应。
我们RPC客户端RPCClient.java的代码：
private Connection connection;
private Channel channel;
private String requestQueueName = "rpc_queue";
private String replyQueueName;
private QueueingConsumer consumer;
public RPCClient() throws Exception {
ConnectionFactory factory = new ConnectionFactory();
factory.setHost("localhost");
connection = factory.newConnection();
channel = connection.createChannel();
replyQueueName = channel.queueDeclare().getQueue();
consumer = new QueueingConsumer(channel);
channel.basicConsume(replyQueueName, true, consumer);
}
public String call(String message) throws Exception {
String response = null;
String corrId = java.util.UUID.randomUUID().toString();
BasicProperties props = new BasicProperties
.Builder()
.correlationId(corrId)
.replyTo(replyQueueName)
.build();
channel.basicPublish("", requestQueueName, props, message.getBytes());
while (true) {
QueueingConsumer.Delivery delivery =consumer.nextDelivery();
if (delivery.getProperties().getCorrelationId().equals(corrId)) {
response = new String(delivery.getBody());
break;
}
}
return response;
}
public void close() throws Exception {
connection.close();
}
The client code is slightly more involved:
这客户端代码是更加清晰：
我们建立一个连接和通道并且声明一个独占的callback队列用来等待答复。
我们订阅这个callback队列，以便于我们可以接收到RPC响应。
我们的call方法做这真正的RPC请求。
接着，我们首次生成一个唯一的correlationId数字并且保存它，在循环中使用这个值找到合适的响应。
接下来，我们发布请求消息，带着两个属性：replyTo和correlationId。
这时候，我们可以坐下来，等着合适的响应抵达。
这循环中做了个简单德工作，检查每一个响应消息中correlationId值，是否是它要寻找的。如果是，它会保存这响应。
最终，我们把响应返回给用户。
制造客户端请求：
RPCClient fibonacciRpc = new RPCClient();
System.out.println(" [x] Requesting fib(30)");
String response = fibonacciRpc.call("30");
System.out.println(" [.] Got '" + response + "'");
fibonacciRpc.close();
现在是时候让我们回顾下我们RPCClient.java和RPCServer.java中的全部例子的源码(包含基本的异常处理)。
编译和如往常一样建立类路径（看指南的第一部分）
$ javac -cp rabbitmq-client.jar RPCClient.java RPCServer.java
我们的RPC服务现在准备好了，我们启动着服务器：
$ java -cp $CP RPCServer
[x] Awaiting RPC requests
为了请求一个斐波那契数字，运行客户端：
$ java -cp $CP RPCClient
[x] Requesting fib(30)
现在的设计不仅仅可以实现一个RPC服务，并且它还有几项重要的优势：
如果RPC服务器反应太迟缓，你可以通过运行另一个程序来扩展。试着通过一个新的控制平台来运行第二个RPC服务器。在客户端这边，RPC要求仅发送和接收一个消息。像queueDeclare非同步调用是被要求的。因此，RPC客户端仅仅需要一个网络循环的单一RPC请求。
我们的代码一直是十分简单的，不能试着解决更复杂（但是重要）的问题，比如：
如果没有服务器运行，客户端如何响应？
客户端是否对RPC的超时有处理？
如果服务器发生故障，抛出一个异常，是否应该传递到客户端？
在处理之前把进入来的非法消息隔离掉（检查界限，类型）。