Remote Procedure Call(RPC)

柔光的暖阳◎ 2022-08-24 05:27 110阅读 0赞

转自：[https://www.rabbitmq.com/tutorials/tutorial-six-java.html][https_www.rabbitmq.com_tutorials_tutorial-six-java.html]

In the [ second tutorial][second tutorial] we learned how to use *Work Queues* to distribute time-consuming tasks among multiple workers.

But what if we need to run a function on a remote computer and wait for the result? Well, that's a different story. This pattern is commonly known as *Remote Procedure Call* or *RPC*.

In this tutorial we're going to use RabbitMQ to build an RPC system: a client and a scalable RPC server. As we don't have any time-consuming tasks that are worth distributing, we're going to create a dummy RPC service that returns Fibonacci numbers.

### Client interface ###

To illustrate how an RPC service could be used we're going to create a simple client class. It's going to expose a method named call which sends an RPC request and blocks until the answer is received:

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

> #### A note on RPC ####
> 
> Although RPC is a pretty common pattern in computing, it's often criticised. The problems arise when a programmer is not aware whether a function call is local or if it's a slow RPC. Confusions like that result in an unpredictable system and adds unnecessary complexity to debugging. Instead of simplifying software, misused RPC can result in unmaintainable spaghetti code.
> 
> Bearing that in mind, consider the following advice:
> 
>  *  Make sure it's obvious which function call is local and which is remote.
>  *  Document your system. Make the dependencies between components clear.
>  *  Handle error cases. How should the client react when the RPC server is down for a long time?
> 
> When in doubt avoid RPC. If you can, you should use an asynchronous pipeline - instead of RPC-like blocking, results are asynchronously pushed to a next computation stage.

### Callback queue ###

In general doing RPC over RabbitMQ is easy. A client sends a request message and a server replies with a response message. In order to receive a response we need to send a 'callback' queue address with the request. We can use the default queue (which is exclusive in the Java client). Let's try it:

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 ...

> #### Message properties ####
> 
> The AMQP protocol predefines a set of 14 properties that go with a message. Most of the properties are rarely used, with the exception of the following:
> 
>  *  deliveryMode: Marks a message as persistent (with a value of 2) or transient (any other value). You may remember this property from [ the second tutorial][second tutorial].
>  *  contentType: Used to describe the mime-type of the encoding. For example for the often used JSON encoding it is a good practice to set this property to: application/json.
>  *  replyTo: Commonly used to name a callback queue.
>  *  correlationId: Useful to correlate RPC responses with requests.

We need this new import:

import com.rabbitmq.client.AMQP.BasicProperties;

### Correlation Id ###

In the method presented above we suggest creating a callback queue for every RPC request. That's pretty inefficient, but fortunately there is a better way - let's create a single callback queue per client.

That raises a new issue, having received a response in that queue it's not clear to which request the response belongs. That's when the correlationId property is used. We're going to set it to a unique value for every request. Later, when we receive a message in the callback queue we'll look at this property, and based on that we'll be able to match a response with a request. If we see an unknown correlationId value, we may safely discard the message - it doesn't belong to our requests.

You may ask, why should we ignore unknown messages in the callback queue, rather than failing with an error? It's due to a possibility of a race condition on the server side. Although unlikely, it is possible that the RPC server will die just after sending us the answer, but before sending an acknowledgment message for the request. If that happens, the restarted RPC server will process the request again. That's why on the client we must handle the duplicate responses gracefully, and the RPC should ideally be idempotent.

### Summary ###

![python-six.png][]

digraph \{ bgcolor=transparent; truecolor=true; rankdir=LR; node \[style="filled"\]; // subgraph cluster\_C \{ label="Client"; color=transparent; C \[label="C", fillcolor="\#00ffff"\]; \}; subgraph cluster\_XXXa \{ color=transparent; subgraph cluster\_Note \{ color=transparent; N \[label="Request\\nreplyTo=amqp.gen-Xa2...\\ncorrelationId=abc", fontsize=12, shape=note\]; \}; subgraph cluster\_Reply \{ color=transparent; R \[label="Reply\\ncorrelationId=abc", fontsize=12, shape=note\]; \}; \}; subgraph cluster\_XXXb \{ color=transparent; subgraph cluster\_RPC \{ label="rpc\_queue"; color=transparent; RPC \[label="\{<s>||||<e>\}", fillcolor="red", shape="record"\]; \}; subgraph cluster\_REPLY \{ label="replyTo=amq.gen-Xa2..."; color=transparent; REPLY \[label="\{<s>||||<e>\}", fillcolor="red", shape="record"\]; \}; \}; subgraph cluster\_W \{ label="Server"; color=transparent; W \[label="S", fillcolor="\#00ffff"\]; \}; // C -> N; N -> RPC:s; RPC:e -> W; W -> REPLY:e; REPLY:s -> R; R -> C; \}

Our RPC will work like this:

*  When the Client starts up, it creates an anonymous exclusive callback queue.
 *  For an RPC request, the Client sends a message with two properties:  replyTo, which is set to the callback queue and correlationId, which is set to a unique value for every request.
 *  The request is sent to an rpc\_queue queue.
 *  The RPC worker (aka: server) is waiting for requests on that queue. When a request appears, it does the job and sends a message with the result back to the Client, using the queue from the replyTo field.
 *  The client waits for data on the callback queue. When a message appears, it checks the correlationId property. If it matches the value from the request it returns the response to the application.

## Putting it all together ##

The Fibonacci task:

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);
    }

We declare our fibonacci function. It assumes only valid positive integer input. (Don't expect this one to work for big numbers, and it's probably the slowest recursive implementation possible).

The code for our RPC server [ RPCServer.java][RPCServer.java] looks like this:

<table> 
 <tbody> 
 <tr> 
 <td> 
 <div> 
 <pre> 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36</pre> 
 </div> </td> 
 <td> 
 <div> 
 <pre>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");

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);
}
</pre> 
 </div> </td> 
 </tr> 
 </tbody> 
</table>

The server code is rather straightforward:

*  As usual we start by establishing the connection, channel and declaring the queue.
 *  We might want to run more than one server process. In order to spread the load equally over multiple servers we need to set the prefetchCount setting in channel.basicQos.
 *  We use basicConsume to access the queue. Then we enter the while loop in which we wait for request messages, do the work and send the response back.

The code for our RPC client [ RPCClient.java][RPCClient.java]:

<table> 
 <tbody> 
 <tr> 
 <td> 
 <div> 
 <pre> 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43</pre> 
 </div> </td> 
 <td> 
 <div> 
 <pre>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();
}
</pre> 
 </div> </td> 
 </tr> 
 </tbody> 
</table>

The client code is slightly more involved:

*  We establish a connection and channel and declare an exclusive 'callback' queue for replies.
 *  We subscribe to the 'callback' queue, so that we can receive RPC responses.
 *  Our call method makes the actual RPC request.
 *  Here, we first generate a unique correlationId number and save it - the while loop will use this value to catch the appropriate response.
 *  Next, we publish the request message, with two properties:  replyTo and correlationId.
 *  At this point we can sit back and wait until the proper response arrives.
 *  The while loop is doing a very simple job, for every response message it checks if the correlationId is the one we're looking for. If so, it saves the response.  
    
 *  Finally we return the response back to the user.

Making the Client request:

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

Now is a good time to take a look at our full example source code (which includes basic exception handling) for [ RPCClient.java][RPCClient.java] and [ RPCServer.java][RPCServer.java].

Compile and set up the classpath as usual (see [ tutorial one][tutorial one]):

$ javac -cp rabbitmq-client.jar RPCClient.java RPCServer.java

Our RPC service is now ready. We can start the server:

$ java -cp $CP RPCServer
     [x] Awaiting RPC requests

To request a fibonacci number run the client:

$ java -cp $CP RPCClient
     [x] Requesting fib(30)

The design presented here is not the only possible implementation of a RPC service, but it has some important advantages:

*  If the RPC server is too slow, you can scale up by just running another one. Try running a second RPCServer in a new console.
 *  On the client side, the RPC requires sending and receiving only one message. No synchronous calls like queueDeclare are required. As a result the RPC client needs only one network round trip for a single RPC request.

Our code is still pretty simplistic and doesn't try to solve more complex (but important) problems, like:

*  How should the client react if there are no servers running?
 *  Should a client have some kind of timeout for the RPC?
 *  If the server malfunctions and raises an exception, should it be forwarded to the client?
 *  Protecting against invalid incoming messages (eg checking bounds, type) before processing.

> If you want to experiment, you may find the [ rabbitmq-management plugin][rabbitmq-management plugin] useful for viewing the queues.

[https_www.rabbitmq.com_tutorials_tutorial-six-java.html]: https://www.rabbitmq.com/tutorials/tutorial-six-java.html
[second tutorial]: https://www.rabbitmq.com/tutorials/tutorial-two-java.html
[python-six.png]: /images/20220823/5ea8bd5acfb74c1bbcea30b7dc932201.png
[RPCServer.java]: https://github.com/rabbitmq/rabbitmq-tutorials/blob/master/java/RPCServer.java
[RPCClient.java]: https://github.com/rabbitmq/rabbitmq-tutorials/blob/master/java/RPCClient.java
[tutorial one]: https://www.rabbitmq.com/tutorials/tutorial-one-java.html
[rabbitmq-management plugin]: https://www.rabbitmq.com/plugins.html