rabbitMQ学习笔记(七) RPC 远程过程调用

关于RPC的介绍请参考百度百科里的关于RPC的介绍：http://baike.baidu.com/view/32726.htm#sub32726

   现在来看看Rabbitmq中RPC吧！RPC的工作示意图如下：

   上图中的C代表客户端，S表示服务器端；Rabbitmq中的RPC流程如下：

1、首先客户端发送一个reply_to和corrention_id的请求,发布到RPC队列中；

2、服务器端处理这个请求，并把处理结果发布到一个回调Queue,此Queue的名称应当与reply_to的名称一致

3、客户端从回调Queue中得到先前correlation_id设定的值的处理结果。如果碰到和先前不一样的corrention_id的值，将会忽略而不是抛出异常。

 

  对于上面所提到的回调Queue中的消费处理使用的是BasicProperties类；而消息 属性在AMQP的协议中规定有14个；而很多大部分我们没有用到。常用的几个属性有：

English代码  

Message properties
The AMQP protocol predefine a set of 14 properties that go with a message. Most of the properties are rarely used, with the exception of the following:

delivery_mode: Marks a message as persistent (with a value of 2) or transient (any other value). You may remember this property from the second tutorial. 
content_type: 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. 
reply_to: Commonly used to name a callback queue. 
correlation_id: Useful to correlate RPC responses with requests. 

 delivery_mode : 标记消息是持久性消息还是瞬态信息。在前面的“Work Queue”中我们已经提到过；   

  content_type : 用来描述MIME的类型。如把其类型设定为JSON；

  reply_to : 用于命名一个回调Queue；

  correlation_id : 用于与相关联的请求的RPC响应.

当客户端想要调用服务器的某个方法来完成某项功能时，就可以使用rabbitMQ支持的PRC服务。

其实RPC服务与普通的收发消息的区别不大， RPC的过程其实就是  

客户端向服务端定义好的Queue发送消息，其中携带的消息就应该是服务端将要调用的方法的参数 ，并使用Propertis告诉服务端将结果返回到指定的Queue。

示例：

package com.zf.rabbitmq07;

import java.io.IOException;

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.ConsumerCancelledException;
import com.rabbitmq.client.QueueingConsumer;
import com.rabbitmq.client.QueueingConsumer.Delivery;
import com.rabbitmq.client.ShutdownSignalException;

public class RPCServer {
    
    public static final String RPC_QUEUE_NAME = "rpc_queue";
    
    public static String sayHello(String name){
        return "hello " + name ;
    }
    
    public static void main(String[] args) throws IOException, ShutdownSignalException, ConsumerCancelledException, InterruptedException {
        
        ConnectionFactory connFac = new ConnectionFactory() ;
        connFac.setHost("localhost");
        
        Connection conn = connFac.newConnection() ;
        
        Channel channel = conn.createChannel() ;
        
        channel.queueDeclare(RPC_QUEUE_NAME, false, false, false, null) ;
        
        QueueingConsumer consumer = new QueueingConsumer(channel);
        
        channel.basicConsume(RPC_QUEUE_NAME, false , consumer) ;
        
        while(true){
            System.out.println("服务端等待接收消息..");  
            Delivery deliver = consumer.nextDelivery() ;
            System.out.println("服务端成功收到消息..");
            BasicProperties props =  deliver.getProperties() ;
            
            String message = new String(deliver.getBody() , "UTF-8") ;
            
            String responseMessage = sayHello(message) ;
            
            BasicProperties responseProps = new BasicProperties.Builder()
            .correlationId(props.getCorrelationId())  
            .build() ;
            
            //将结果返回到客户端Queue
            channel.basicPublish("", props.getReplyTo() , responseProps , responseMessage.getBytes("UTF-8") ) ;
             
            //向客户端确认消息
            channel.basicAck(deliver.getEnvelope().getDeliveryTag(), false);
            System.out.println("服务端返回消息完成..");
        }
        
    }

}

package com.zf.rabbitmq07;

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

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

public class RPCClient {

    public static final String RPC_QUEUE_NAME = "rpc_queue";

    public static void main(String[] args) throws IOException, ShutdownSignalException, ConsumerCancelledException, InterruptedException {

        ConnectionFactory connFac = new ConnectionFactory() ;
        connFac.setHost("localhost");
        Connection conn = connFac.newConnection() ;
        Channel channel = conn.createChannel() ;

        //响应QueueName ，服务端将会把要返回的信息发送到该Queue
        String responseQueue = channel.queueDeclare().getQueue() ;

        String correlationId = UUID.randomUUID().toString() ;

        BasicProperties props = new BasicProperties.Builder()
        .replyTo(responseQueue)
        .correlationId(correlationId)
        .build();

        String message = "is_zhoufeng";
        channel.basicPublish( "" , RPC_QUEUE_NAME , props ,  message.getBytes("UTF-8"));

        QueueingConsumer consumer = new QueueingConsumer(channel)    ;

        channel.basicConsume( responseQueue , consumer) ;

        while(true){
            
            Delivery delivery = consumer.nextDelivery() ;
            
            if(delivery.getProperties().getCorrelationId().equals(correlationId)){
                String result = new String(delivery.getBody()) ;  
                System.out.println(result);
            }
            
        }
    }

}