RabbitMQ 学习笔记（六）：RPC

远程过程调用(RPC)

在第二个笔记，我们学习了如何使用工作队列（work queue）在多个 worker 之间分配耗时的任务。

但是，如果我们需要在远程计算机上运行一个函数并等待结果呢?那就是另一回事了。这种模式通常称为远程过程调用（Remote Procedure Call）或简称“RPC”。

在本教程中，我们将使用RabbitMQ构建一个RPC系统：一个客户机和一个可伸缩的RPC服务器。由于我们没有任何值得分发的费时任务，我们将创建一个虚拟RPC服务来返回斐波那契数列。

客户端接口

为了说明如何使用RPC服务，我们将创建一个简单的客户端类。它将公开一个名为call的方法，该方法会一直发送RPC请求和blocks，直到收到应答为止：

FibonacciRpcClient fibonacciRpc = new FibonacciRpcClient();
String result = fibonacciRpc.call("4");
System.out.println( "fib(4) is " + result);

关于RPC，请注意:

尽管RPC在计算中是一个很常见的模式，但它却经常受到批评。当程序员不知道函数调用是本地的还是一个 slow RPC 时，问题就出现了。这样的混淆可能导致不可预知的系统，并增加了调试的不必要的复杂性。与简化软件不同，错误的RPC可能导致无法维护的意大利面代码。

考虑到这一点，考虑以下建议:
1. 确保函数调用是本地的，而且是远程的。
2. 文件化系统。使组件之间的依赖关系变得清晰。
3. 处理错误（error）情况。当RPC服务器宕了很长时间时，客户机应该如何反应?

当有疑问时避免使用RPC。如果可以的话，您应该使用异步管道，而不是像 RPC 。像blocking（阻塞）一样，结果会被异步地推到下一个计算阶段。

回调队列（Callback queue）

一般来说，在RabbitMQ上执行RPC是很容易的。一个客户端发送一个请求消息，一个服务器回复一个响应消息。为了收到响应，我们需要发送一个callback queue地址。我们可以使用默认队列(在Java客户机中是独占的)。让我们试一试：

callbackQueueName = channel.queueDeclare().getQueue();

BasicProperties props = new BasicProperties
                            .Builder()
                            .replyTo(callbackQueueName)
                            .build();

channel.basicPublish("", "rpc_queue", props, message.getBytes());

// ... 然后代码从callback_queue读取响应消息 ...

消息属性

1.deliveryMode（交付模式）：将消息标记为持久(具有值为2)或暂态(任何其他值)。您可能还记得第二个笔记中的这个属性。
2. contentType：用于描述编码的mime类型。例如，对于经常使用的JSON编码，将该属性设置为: application/json 是一种很好的做法。
3.replyTo：通常用于callback_queue。
4.correlationship:用于将RPC响应与请求关联起来。

我们需要一个新的 import：

import com.rabbitmq.client.AMQP.BasicProperties;

Correlation Id（关联ID）

在上述方法中，我们假定为每个RPC请求创建回调队列。这是非常低效的，但是幸运的是，我们有有更好的方法——为每个客户机创建一个回调队列。

这引发了一个新问题，在该队列中收到了响应，但不清楚响应属于哪个请求。这就是使用 correlation id 属性的时候。我们将把它设置为每个请求的唯一值。稍后，当我们在callback queue中接收消息时，我们将查看此属性，基于此，我们将能够匹配响应和请求。如果我们看到一个未知的关联值，我们可以安全地丢弃这个消息——它不属于我们的请求。

您可能会问，为什么我们应该忽略回调队列中的未知消息，而不是返回一个 error 然后结束？这是由于服务器端可能出现竞态条件（race condition）。尽管不太可能，但RPC服务器可能在发送答案后才会死亡，但这将在发送确认消息（ack）之前。如果发生这种情况，重新启动的RPC服务器将再次处理请求。这就是为什么在客户端我们必须优雅地处理重复的响应，并且RPC应该是具有幂等性的。

Summary

我们的RPC将这样工作：

当客户机启动时，它创建一个匿名的独有的 callback_queue。

对于RPC请求，客户端发送带有两个属性的消息:一. replyTo，它被设置为callback_queue；二. correlationship id，它将为每个请求设置一个惟一的值。

请求被发送到一个 rpc_queue 队列。

RPC worker (也就是服务器)在队列上等待请求。当出现请求时，它会执行该任务并将结果发送回客户端，使用来自replyTo字段的队列。

客户机在callback_queue上等待数据。当消息出现时，它会检查correlation id属性。如果它与请求中的值匹配，则返回对应用程序的响应。

编译运行

斐波那契序列的任务:

private static int fib(int n) {
    if (n == 0) return 0;
    if (n == 1) return 1;
    return fib(n-1) + fib(n-2);
}

我们声明 fib 函数。它只假设有效的正整数输入。(不要期望这个对大数字起作用，这是最慢的递归实现，没有之一)。

我们的RPC服务器RPCServer.java如下:

import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Consumer;
import com.rabbitmq.client.DefaultConsumer;
import com.rabbitmq.client.AMQP;
import com.rabbitmq.client.Envelope;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class RPCServer {

  private static final String RPC_QUEUE_NAME = "rpc_queue";

  private static int fib(int n) {
    if (n ==0) return 0;
    if (n == 1) return 1;
    return fib(n-1) + fib(n-2);
  }

  public static void main(String[] argv) {
    ConnectionFactory factory = new ConnectionFactory();
    factory.setHost("localhost");

    Connection connection = null;
    try {
      connection      = factory.newConnection();
      Channel channel = connection.createChannel();

      channel.queueDeclare(RPC_QUEUE_NAME, false, false, false, null);

      channel.basicQos(1);

      System.out.println(" [x] Awaiting RPC requests");

      Consumer consumer = new DefaultConsumer(channel) {
        @Override
        public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
          AMQP.BasicProperties replyProps = new AMQP.BasicProperties
                  .Builder()
                  .correlationId(properties.getCorrelationId())
                  .build();

          String response = "";

          try {
            String message = new String(body,"UTF-8");
            int n = Integer.parseInt(message);

            System.out.println(" [.] fib(" + message + ")");
            response += fib(n);
          }
          catch (RuntimeException e){
            System.out.println(" [.] " + e.toString());
          }
          finally {
            channel.basicPublish( "", properties.getReplyTo(), replyProps, response.getBytes("UTF-8"));

            channel.basicAck(envelope.getDeliveryTag(), false);
          }
        }
      };

      channel.basicConsume(RPC_QUEUE_NAME, false, consumer);

      //loop to prevent reaching finally block
      while(true) {
        try {
          Thread.sleep(100);
        } catch (InterruptedException _ignore) {}
      }
    } catch (IOException | TimeoutException e) {
      e.printStackTrace();
    }
    finally {
      if (connection != null)
        try {
          connection.close();
        } catch (IOException _ignore) {}
    }
  }
}

我们的 RPC 服务器代码相当简单:

像往常一样，我们首先建立连接、通道和声明队列。

我们可能希望运行多个服务器进程。为了将负载均匀地分布在多个服务器上，我们需要在channel.basicQos中设置prefetchCount设置。

我们使用basicConsume 来访问队列，在那里我们以对象(DefaultConsumer)的形式提供一个回调，该对象将执行工作并发回响应。

我们的RPC客户端RPCClient . java的代码：

import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.DefaultConsumer;
import com.rabbitmq.client.AMQP;
import com.rabbitmq.client.Envelope;

import java.io.IOException;
import java.util.UUID;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.TimeoutException;

public class RPCClient {

  private Connection connection;
  private Channel channel;
  private String requestQueueName = "rpc_queue";
  private String replyQueueName;

  public RPCClient() throws IOException, TimeoutException {
    ConnectionFactory factory = new ConnectionFactory();
    factory.setHost("localhost");

    connection = factory.newConnection();
    channel = connection.createChannel();

    replyQueueName = channel.queueDeclare().getQueue();
  }

  public String call(String message) throws IOException, InterruptedException {
    String corrId = UUID.randomUUID().toString();

    AMQP.BasicProperties props = new AMQP.BasicProperties
            .Builder()
            .correlationId(corrId)
            .replyTo(replyQueueName)
            .build();

    channel.basicPublish("", requestQueueName, props, message.getBytes("UTF-8"));

    final BlockingQueue response = new ArrayBlockingQueue(1);

    channel.basicConsume(replyQueueName, true, new DefaultConsumer(channel) {
      @Override
      public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
        if (properties.getCorrelationId().equals(corrId)) {
          response.offer(new String(body, "UTF-8"));
        }
      }
    });

    return response.take();
  }

  public void close() throws IOException {
    connection.close();
  }

  public static void main(String[] argv) {
    RPCClient fibonacciRpc = null;
    String response = null;
    try {
      fibonacciRpc = new RPCClient();

      System.out.println(" [x] Requesting fib(30)");
      response = fibonacciRpc.call("30");
      System.out.println(" [.] Got '" + response + "'");
    }
    catch  (IOException | TimeoutException | InterruptedException e) {
      e.printStackTrace();
    }
    finally {
      if (fibonacciRpc!= null) {
        try {
          fibonacciRpc.close();
        }
        catch (IOException _ignore) {}
      }
    }
  }
}

客户端代码稍微复杂一点：

我们建立一个连接和通道，并声明一个“回调”队列。

我们订阅“回调”队列，这样我们就可以接收到RPC响应。

我们的调用方法实现了实际的RPC请求。

在这里，我们首先生成一个惟一的correlationId并保存它——在DefaultConsumer中实现handleDelivery将使用这个值来捕获适当的响应。

此时，我们可以坐下来，等到适当的反应到来。

由于我们的客户交付处理是在一个单独的线程中发生的，所以在响应到达之前，我们需要一些东西来暂停主线程。使用BlockingQueue是可能的解决方案之一。在这里我们创建了ArrayBlockingQueue，容量设置为1，因为我们只需要等待一个响应。

handleDelivery方法做的是非常简单的工作，对于每一个消耗的响应消息，它检查是否correlationId是我们正在寻找的。如果是这样，它就会对BlockingQueue进行响应。

与此同时，主线程还在等待响应，以将其从BlockingQueue中取出。

最后，我们将响应返回给用户。

客户端请求:

RPCClient fibonacciRpc = new RPCClient();

System.out.println(" [x] Requesting fib(30)");
String response = fibonacciRpc.call("30");
System.out.println(" [.] Got '" + response + "'");

fibonacciRpc.close();

像往常一样编译和设置类路径(参见笔记一):

javac -cp $CP 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有某种超时吗?

如果服务器出现故障并引发异常，是否应该将其转发给客户端?

在处理之前，保护无效的传入消息(如检查边界)。

相关链接

rabbitmq-c++(SimpleAmqpClient) 笔记代码系列：

rabbitmq-c++(SimpleAmqpClient) 笔记代码一
rabbitmq-c++(SimpleAmqpClient) 笔记代码二
rabbitmq-c++(SimpleAmqpClient) 笔记代码三
rabbitmq-c++(SimpleAmqpClient) 笔记代码四
rabbitmq-c++(SimpleAmqpClient) 笔记代码五
rabbitmq-c++(SimpleAmqpClient) 笔记代码六

RabbitMQ 学习笔记系列：

RabbitMQ 学习笔记（一）：简单介绍及”Hello World”
RabbitMQ 学习笔记（二）：work queues
RabbitMQ 学习笔记（三）：Publish/Subscribe
RabbitMQ 学习笔记（四）：Routing
RabbitMQ 学习笔记（五）：Topics
RabbitMQ 学习笔记（六）：RPC