RabbitMQ消息队列(五):RPC远程调用

RPC在RabbitMQ比较容易，一个客户端发送一个请求信息和一个响应信息的服务器回复，为了得到一个响应，我们需要发送一个回调队列地址请求。如下图:

Message properties:
AMQP 预定义了14个属性。它们中的绝大多很少会用到。以下几个是平时用的比较多的：

• delivery_mode: 持久化一个Message（通过设定值为2）。其他任意值都是非持久化
• content_type: 描述mime-type 的encoding。比如设置为JSON编码：设置该property为application/json
• reply_to: 一般用来指明用于回调队列的名字
• correlation_id: 在请求中关联处理RPC响应

Correlation Id

在队列上接收到一个响应，但它并不清楚响应属于哪一个，当我们使用CorrelationId属性的时候，我们就可以将它设置为每个请求的唯一值，当我们在回调队列中接收消息的时候，判断这个属性如果是一个未知的CorrelationId，就可以安全地忽略信息-它不属于我们的请求。为什么我们应该忽略未知的消息在回调队列中，而不是失败的错误？这是由于服务器端的一个竞争条件的可能性。比如还未发送了一个确认信息给请求，但是此时RPC服务器挂了。如果这种情况发生，将再次重启RPC服务器处理请求。这就是为什么在客户端必须处理重复的反应。

实现原理

RPC工作方式如下：
1：当客户端启动时，它创建一个匿名的独占回调队列。

2：对于RPC请求，客户端发送2个属性，一个是replyTo设置回调队列，另一是correlationId为每个队列设置唯一值

3：请求被发送到一个rpc_queue队列中

4：rpc服务器是等待队列的请求，当收到一个请求的时候，他就把消息返回的结果返回给客户端，使请求结束。

5：客户端等待回调队列上的数据，当消息出现的时候，他检查correlationId，如果它和从请求返回的值匹配，就进行响应。

代码实现

RPCServer.Java

package com.springboot.rabbitmq.rpc;

import com.rabbitmq.client.AMQP.BasicProperties;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.QueueingConsumer;

/**
 * RPC 服务端
 */
public class RPCServer {
    private static final String RPC_QUEUE_NAME = "rpc_queue";

    public static String sayHello(String name){
        return "hello " + name ;
    }

    public static void main(String[] args) throws Exception {
        //创建连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        //创建一个新的连接
        Connection connection = factory.newConnection();
        //创建一个通道
        Channel channel = connection.createChannel();
        //声明一个队列
        channel.queueDeclare(RPC_QUEUE_NAME,false,false,false,null);
        //每次只取1个消息
        channel.basicQos(1);
        //basicconsume访问队列。然后进入循环，在其中我们等待请求消息并处理消息然后发送响应。
        QueueingConsumer consumer = new QueueingConsumer(channel);
        channel.basicConsume(RPC_QUEUE_NAME,false,consumer);

        System.out.println("RPCServer Awating RPC request");
        while (true){
            System.out.println("服务端等待接收消息..");
            QueueingConsumer.Delivery delivery = consumer.nextDelivery() ;
            System.out.println("服务端成功收到消息..");
            BasicProperties props = delivery.getProperties();
            BasicProperties replyProps = new BasicProperties.Builder().correlationId(props.getCorrelationId()).build();

            String message = new String(delivery.getBody(),"utf-8");

            System.out.println("RPCServer say(" + message + ")");
            String response = sayHello(message);
            channel.basicPublish( "", props.getReplyTo(), replyProps, response.getBytes());
            channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);
        }

    }

}

RPCClient.java

package com.springboot.rabbitmq.rpc;


import com.rabbitmq.client.AMQP.BasicProperties;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.QueueingConsumer;

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


/**
 * RPC 客户端
 */
public class RPCClient {
    private Connection connection;
    private Channel channel;
    private String requestQueueName = "rpc_queue";
    private String replyQueueName;
    private QueueingConsumer consumer;

    public RPCClient()throws IOException, TimeoutException {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        connection = factory.newConnection();
        channel = connection.createChannel();
        //订阅回调队列，这样就可以得到RPC的响应
        replyQueueName = channel.queueDeclare().getQueue();
        consumer = new QueueingConsumer(channel);
        channel.basicConsume(replyQueueName,true,consumer);
    }

    public String call(String message) throws  Exception{
        String response;
        //生成一个唯一的correlationid，然后通过while循环来捕获合适的回应
        String corrID = UUID.randomUUID().toString();
        //请求信息，发送2个属性，replyTo 和correlationId
        BasicProperties props = new BasicProperties.Builder()
                .correlationId(corrID)
                .replyTo(replyQueueName)
                .build();

        channel.basicPublish("",requestQueueName,props,message.getBytes("utf-8"));
        while(true){
            QueueingConsumer.Delivery delivery = consumer.nextDelivery();
            if(delivery.getProperties().getCorrelationId().equals(corrID)){
                response = new String(delivery.getBody(),"utf-8");
                break;
            }
        }
        return response;
    }

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

    public static void main(String[] args) throws Exception  {
        RPCClient rpcClient = null;
        String response;
        try {
            rpcClient = new RPCClient();
            System.out.println("RPCClient  Requesting sayHello(2)");
            response = rpcClient.call("haha");
            System.out.println("RPCClient  Got '" + response + "'");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (rpcClient != null) {
                rpcClient.close();
            }
        }
    }
}

运行结果

RPCServer:

RPCClient: