當今分散式應用盛行，rpc框架也就隨之出現，今天用java寫一個小的demo。

首先看一下什麼事遠端呼叫

遠端呼叫涉及到了網路io，基本過程是客戶端向服務端傳送訊息，表明自己要呼叫的方法的名字以及包含的引數，然後服務端呼叫函式，再向客戶端返回結果。所以涉及了兩次網路io。

這樣的話，客戶端的程式碼寫起來比較費勁，每一個方法底層都是網路io，但是過程都是一樣的，傳遞引數，得到結果，所以這裡肯定可以優化，比如在java中可以使用動態代理機制。只需要使用一個服務端的介面類就，讓Proxy動態生成一個代理類。服務端就是一個socket的常規伺服器，可以使用執行緒池或者多路複用這樣的技術，然後通過反射來呼叫實際類。還有註冊服務的功能，所謂註冊就是讓介面和真正的實現類對接，最後就可以呼叫到實現類的方法。

所以遠端呼叫其實就是網路io，在客戶端和服務端下面都有訊息的封裝和解析，以及網路io。

下面是一個簡單的例子：

介面

public interface HelloService{

	public String hello(String name);
	
}

public class HelloServiceImpl implements HelloService{

	@Override
	public String hello(String name) {
		return "Hello, " + name;
	}

}

public class RPCServer {

	private ExecutorService threadPool;
	private static final int DEFAULT_THREAD_NUM = 10;
	
	public RPCServer(){
		threadPool = Executors.newFixedThreadPool(DEFAULT_THREAD_NUM);
	}
	
	public void register(Object service, int port){
		try {
			System.out.println("server starts...");
			ServerSocket server = new ServerSocket(port);
			Socket socket = null;
			while((socket = server.accept()) != null){
				System.out.println("client connected...");
				threadPool.execute(new Processor(socket, service));
			}
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
	
	class Processor implements Runnable{
		Socket socket;
		Object service;
		
		public Processor(Socket socket, Object service){
			this.socket = socket;
			this.service = service;
		}
		public void process(){
			
		}
		@Override
		public void run() {
			try {
				ObjectInputStream in = new ObjectInputStream(socket.getInputStream());
				String methodName = in.readUTF();
				Class<?>[] parameterTypes = (Class<?>[]) in.readObject();
				Object[] parameters = (Object[]) in.readObject();
				Method method = service.getClass().getMethod(methodName, parameterTypes);
				try {
					Object result = method.invoke(service, parameters);
					ObjectOutputStream out = new ObjectOutputStream(socket.getOutputStream());
					out.writeObject(result);
				} catch (IllegalAccessException e) {
					e.printStackTrace();
				} catch (IllegalArgumentException e) {
					e.printStackTrace();
				} catch (InvocationTargetException e) {
					e.printStackTrace();
				}
			} catch (IOException e) {
				e.printStackTrace();
			} catch (NoSuchMethodException e) {
				e.printStackTrace();
			} catch (SecurityException e) {
				e.printStackTrace();
			} catch (ClassNotFoundException e1) {
				e1.printStackTrace();
			}
		}
	}
}
 

public class Main {

	public static void main(String args[]){
		HelloService helloService = new HelloServiceImpl();
		
		RPCServer server = new RPCServer();
		server.register(helloService, 50001);
	}
}

public class RPCClient {

	public static void main(String args[]){
		HelloService helloService = getClient(HelloService.class, "127.0.0.1", 50001);
		System.out.println(helloService.hello("liyao1"));
	}
	
	@SuppressWarnings("unchecked")
	public static <T> T getClient(Class<T> clazz, String ip, int port){
		return  (T) Proxy.newProxyInstance(RPCClient.class.getClassLoader(), new Class<?>[]{clazz}, new InvocationHandler() {
			
			@Override
			public Object invoke(Object arg0, Method arg1, Object[] arg2) throws Throwable {
				Socket socket = new Socket(ip, port);
				ObjectOutputStream out = new ObjectOutputStream(socket.getOutputStream());
				out.writeUTF(arg1.getName());
				out.writeObject(arg1.getParameterTypes());
				out.writeObject(arg2);
				ObjectInputStream in = new ObjectInputStream(socket.getInputStream());
				return in.readObject();
			}
		});
	}
}
 

那麼什麼是rpc呢？既然是框架，那麼必然是幫我們做了一下上面的事情的。rpc幫助我們生成了客戶端和服務端的訊息和io等公共的程式碼，這樣客戶端可以直接呼叫代理類的方法，感知不到遠端呼叫，服務端也只需要註冊服務即可，也就是上面的io，反射，代理等等複雜的程式碼rpc框架都給我們生成了。

使用了rpc框架，我們只需要定義一個介面，然後讓rpc框架為我們生成客戶端的代理類，同時生成服務端的serversocket類，我們只需要在服務端編寫真正的實現類，然後註冊在伺服器上就可以。其餘的事情都是框架做的。

再說一遍，我們只需要：

（1）定義介面；

（2）用介面生成服務端和客戶端代理的程式碼；

（3）編寫介面實現；

（4）註冊服務；

這下是不是簡單了很多，這就是rpc框架的魅力。

下一節我會給出一個thrift的小例子，就可以感受使用框架的便捷。