RabbitMQ（3）

前言：前面我们讲解的都是本地服务器，现在如果需要远程计算机上运行一个函数，等待结果。这就是一个不同的故事了，这种模式通常被称为远程过程调用或者RPC。

本章教程我们使用RabbitMQ搭建一个RPC系统，一个客户端和一个可扩展的RPC服务器，现在我们开始吧。

Callback queue

一般做rpc在RabbitMQ是比较容易的，一个客户端发送一个请求信息和一个响应信息的服务器回复，为了得到一个响应，我们需要在请求消息中发送一个回调队列。如下

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

Message properties属性：

AMQP协议一共预定义了14个属性，但是大多数属性很少使用，下面几个可能用的比较多

deliveryMode：标记消息传递模式，2-消息持久化，其他值-瞬态

contentType：内容类型：用于描述编码的mime-type。例如，经常为该属性设置JSON编码：application/json

replyTo：应答，通用的回调队列名称

correlationid：关联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 common.rabbitMQ;

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

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

public class RPCServer {
	private static final String RPC_QUEUE_NAME = "rpc_queue";

	/**
	 * Fibonacci级数		斐波纳契(一种整数数列)	
	 * 只能接受正整数，而且是效率不怎么高的那种
	 * @param n
	 * @return
	 */
	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[] args) throws IOException, InterruptedException, TimeoutException {
		ConnectionFactory factory = new ConnectionFactory();
		factory.setHost("localhost");

		Connection connection = null;
		try {
			connection = factory.newConnection();
			final 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);
						System.out.println(" response(" + response + ")");
					} catch (RuntimeException e) {
						System.out.println(" [.] " + e.toString());
					} finally {
						channel.basicPublish("", properties.getReplyTo(), replyProps, response.getBytes("UTF-8"));

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

						// RabbitMq consumer worker thread notifies the RPC server owner thread
						synchronized (this) {
							this.notify();
						}
					}
				}
			};

			channel.basicConsume(RPC_QUEUE_NAME, false, consumer);

			// Wait and be prepared to consume the message from RPC client.
			while (true) {
				synchronized (consumer) {
					try {
						consumer.wait();
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
			}
		} catch (IOException | TimeoutException e) {
			e.printStackTrace();
		} finally {
			if (connection != null)
				try {
					connection.close();
				} catch (IOException _ignore) {
				}
		}
	}
}

服务器代码比较简单

1：建立连接，通道，队列

2：我们可能运行多个服务器进程，为了分散负载服务器压力，我们设置channel.basicQos(1);

3：我们用basicconsume访问队列。然后进入循环，在其中我们等待请求消息并处理消息然后发送响应。

RPCClient.java

package common.rabbitMQ;

import java.io.IOException;
import java.util.UUID;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.TimeoutException;
import com.rabbitmq.client.AMQP;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.DefaultConsumer;
import com.rabbitmq.client.Envelope;

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<String> response = new ArrayBlockingQueue<String>(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[] args) {
    	RPCClient fibonacciRpc;
		try {
			fibonacciRpc = new RPCClient();
			System.out.println(" [x] Requesting fib(20)");
			String response = fibonacciRpc.call("20");
			System.out.println(" [.] Got '" + response + "'");
			fibonacciRpc.close();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
    
    
    
}

客户端代码解读

1：建立一个连接和通道，并声明了一个唯一的“回调”队列的答复

2：我们订阅回调队列，这样就可以得到RPC的响应

3：定义一个call方法用于发送当前的回调请求

4：生成一个唯一的correlationid

5：我们请求信息，发送2个属性，replyTo 和correlationId

6：然后就是等待直到有合适的回应到达

7：最后把响应返回到客户端。