1. RPC的基础概念

　　RPC，即Remote Procdure Call，中文名：远程过程调用；更详细内容可以转到RPC原理及RPC实例分析学习。

　　（1）它允许一台计算机程序远程调用另外一台计算机的子程序，而不用去关心底层的网络通信细节，对我们来说是透明的。因此，它经常用于分布式网络通信中。

RPC协议假定某些传输协议的存在，如TCP或UDP，为通信程序之间携带信息数据。在OSI网络通信模型中，RPC跨越了传输层和应用层。RPC使得开发包括网络分布式多程序在内的应用程序更加容易。

　　（2）Hadoop的进程间交互都是通过RPC来进行的，比如Namenode与Datanode直接，Jobtracker与Tasktracker之间等。

因此，可以说：Hadoop的运行就是建立在RPC基础之上的。Hadoop RPC是Hadoop的一个重要部分，提供分布式环境下的对象调用功能，源码在org.apache.hadoop.ipc中。而HBase也几乎完全copy了这部分的源码，只是在配置项上面有所改动。

2. Hadoop中的RPC机制

　　同其他RPC框架一样，Hadoop RPC分为四个部分：

　　（1）序列化层：Clent与Server端通信传递的信息采用了Hadoop里提供的序列化类或自定义的Writable类型；

　　（2）函数调用层：Hadoop RPC通过动态代理以及java反射实现函数调用；

　　（3）网络传输层：Hadoop RPC采用了基于TCP/IP的socket机制；

　　（4）服务器端框架层：RPC Server利用java NIO以及采用了事件驱动的I/O模型，提高RPC Server的并发处理能力；

　　Hadoop RPC在整个Hadoop中应用非常广泛，Client、DataNode、NameNode之间的通讯全靠它了。例如：我们平时操作HDFS的时候，使用的是FileSystem类，它的内部有个DFSClient对象，这个对象负责与NameNode打交道。在运行时，DFSClient在本地创建一个NameNode的代理，然后就操作这个代理，这个代理就会通过网络，远程调用到NameNode的方法，也能返回值。

3. Hadoop RPC设计技术

（1）动态代理

（2）反射——动态加载类

（3）序列化

（4）非阻塞的异步IO（NIO）

4. Hadoop RPC实例

(1)Protocol

被远程访问的类，也就是Server端，必须实现VersionedProtocol接口，这个接口只有一个方法getProtocolVersion，用来判断Server和Client端调用的是不是一个版本的，一般Server的代码修改一次，版本号就得改一次。

在例子中，我们定义一个接口MyProtocol，继承VersionedProtocol，里面定义Server端需要实现的方法。

这里MyProtocol接口只有一个方法println，输入一个Text，打印出来，并返回一个Text。

MyProtocol.java代码如下：

1import org.apache.hadoop.io.Text;
2 import org.apache.hadoop.ipc.VersionedProtocol;
3 
4 public interface MyProtocol extends VersionedProtocol {
5     public Text println(Text t);
6 }

(2)Server

Server端实现上述的Protocol接口，里面需要启动一个RPC.Server，它是一个Thread。

构造方法是RPC.getServer(Object instance, String bindAddress, int port, Configuration conf)

instance：表示提供远程访问的对象，一般Server都会传入this作为参数；
bindAddress：Server绑定的ip地址；
port：Server绑定的端口；
conf：Configuration对象，不用解释了吧。

MyServer实现了MyProtocol接口中定义的println方法，将参数打印到控制台，并返回finish。

MyServer.java代码如下：

1 import java.io.IOException;
2 import java.net.UnknownHostException;
3 
4 import org.apache.hadoop.conf.Configuration;
5 import org.apache.hadoop.io.Text;
6 import org.apache.hadoop.ipc.RPC;
7 import org.apache.hadoop.ipc.RPC.Server;
8 
9 public class MyServer implements MyProtocol{
10     private Server server;
11     
12     public MyServer(){
13         try {
14             server = RPC.getServer(this, "localhost", 8888, new Configuration());
15             server.start();
16             server.join();
17         } catch (UnknownHostException e) {
18             e.printStackTrace();
19         } catch (IOException e) {
20             e.printStackTrace();
21         } catch (InterruptedException e) {
22             e.printStackTrace();
23         }
24     }
25     
26     @Override
27     public Text println(Text t){
28         System.out.println(t);
29         return new Text("finish");
30     }
31 
32     @Override
33     public long getProtocolVersion(String protocol, long clientVersion) throws IOException {
34         return 1;
35     }
36     
37     public static void main(String[] args) {
38         new MyServer();
39     }
40 
41 }

(3)Client

Client端需要创建一个Server的远程代理，并可以通过操作这个代理，来调用到Server端的方法。

创建代理可以调用RPC.waitForProxy(Class protocol, long clientVersion, InetSocketAddress addr, Configuration conf)

protocol：一个Protocol的class，它必须是继承VersionedProtocol的接口；
clientVersion：客户端的版本号，如果与服务端不一致，则会抛错；
addr：一个InetSocketAddress对象，包含了ip和port；
conf：不解释。

这个方法会返回一个VersionedProtocol类型的代理对象，将它强制转型成自己定义的Protocol，接下来就可以操作创建好的代理了。在例子中，我们通过代理来让Server端打印字符串到控制台，并接受返回的消息。

MyClient.java代码如下：

1 import java.io.IOException;
2 import java.net.InetSocketAddress;
3 
4 import org.apache.hadoop.conf.Configuration;
5 import org.apache.hadoop.io.Text;
6 import org.apache.hadoop.ipc.RPC;
7 
8 public class MyClient {
9     
10     private MyProtocol proxy;
11 
12     public MyClient(){
13         InetSocketAddress addr = new InetSocketAddress("localhost",8888);
14         try {
15             proxy = (MyProtocol) RPC.waitForProxy(MyProtocol.class, 1, addr , new Configuration());
16         } catch (IOException e) {
17             e.printStackTrace();
18         }
19     }
20     
21     public void println(String s){
22         System.out.println(proxy.println(new Text(s)));
23     }
24 
25     public void close(){
26         RPC.stopProxy(proxy);
27     }
28     
29     public static void main(String[] args) {
30         MyClient c = new MyClient();
31         c.println("123");
32         c.close();
33     }
34 }

(4)运行

运行MyServer，控制台显示：

12011-12-30 18:49:56 -[INFO] Initializing RPC Metrics with hostName=MyServer, port=8888
22011-12-30 18:49:56 -[INFO] IPC Server listener on 8888: starting
32011-12-30 18:49:56 -[INFO] IPC Server Responder: starting
42011-12-30 18:49:56 -[INFO] IPC Server handler 0 on 8888: starting

运行MyClient，控制台显示：

finish

MyServer端会追加显示：

Hadoop中的RPC