The Fibonacci task:

privatestaticintfib(int n){
if(n ==0)return0;
if(n ==1)return1;
returnfib(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 can be found here: RPCServer.java.

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, where we provide a callback in the form of an object (DeliverCallback) that will do the work and send the response back.

The code for our RPC client can be found here: RPCClient.java.

The client code is slightly more involved:

• We establish a connection and channel.
• Our call method makes the actual RPC request.
• Here, we first generate a unique correlationId number and save it - our consumer callback will use this value to match the appropriate response.
• Then, we create a dedicated exclusive queue for the reply and subscribe to it.
• 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.
• Since our consumer delivery handling is happening in a separate thread, we're going to need something to suspend the main thread before the response arrives. Usage of CompletableFuture is one possible solution to do so.
• The consumer is doing a very simple job, for every consumed response message it checks if the correlationId is the one we're looking for. If so, it completes the CompletableFuture.
• At the same time main thread is waiting for the CompletableFuture to complete.
• Finally, we return the response back to the user.

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

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

javac -cp$CP 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 management UI useful for viewing the queues.