rpc 原理和简单实现

首先你必须了解什么是RPC， （百度知道）

RPC（Remote Procedure Call Protocol）——远程过程调用协议，它是一种通过网络从远程计算机程序上请求服务，而不需要了解底层网络技术的协议。RPC协议假定某些传输协议的存在，如TCP或UDP，为通信程序之间携带信息数据。在OSI网络通信模型中，RPC跨越了传输层和应用层。RPC使得开发包括网络分布式多程序在内的应用程序更加容易。

结构：（图片来源：cnblogs.com/shown）

1. 1. RpcServer  
2.    负责导出（export）远程接口  
3. 2. RpcClient  
4.    负责导入（import）远程接口的代理实现  
5. 3. RpcProxy  
6.    远程接口的代理实现  
7. 4. RpcInvoker  
8.    客户方实现：负责编码调用信息和发送调用请求到服务方并等待调用结果返回  
9.    服务方实现：负责调用服务端接口的具体实现并返回调用结果  
10. 5. RpcProtocol  
11.    负责协议编/解码  
12. 6. RpcConnector  
13.    负责维持客户方和服务方的连接通道和发送数据到服务方  
14. 7. RpcAcceptor  
15.    负责接收客户方请求并返回请求结果  
16. 8. RpcProcessor  
17.    负责在服务方控制调用过程，包括管理调用线程池、超时时间等  
18. 9. RpcChannel  
19.    数据传输通道  

对比本地JAVA 和 RPC代码：
1）本地模式

a）本地的接口：

package example1.day20170625;

/**
 * Created by chenfenggang on 2017/7/17.
 */
public interface Calculator {
     int sum(int a,int b);
}

b）本地的实现

package day20170625;

/**
 * Created by chenfenggang on 2017/7/17.
 */
public class MyCalculator implements  Calculator{
    public int sum(int a, int b) {
        return a+b;
    }
}

c）本地的测试

package day20170625;

/**
 * Created by chenfenggang on 2017/7/17.
 */
public class TestMyCalculator {
    public static void main(String[] args) {
        Calculator calculator = new MyCalculator();
        System.out.println(calculator.sum(1,2));
    }
}

2) 加代理。不实现方法

package day20170625;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

/**
 * Created by chenfenggang on 2017/7/17.
 */
public class MyInvocatationHandler<T> implements InvocationHandler {

    private Class target;
    MyInvocatationHandler(Class target) {
        super();
        this.target = target;
    }
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println(target);
        System.out.println(method.getName());
        System.out.println(args.length);
        for(Object object:args){
            System.out.println(object);
        }
        return 11;
    }

    public <T>T getObject(){
      return  (T)   Proxy.newProxyInstance(target.getClassLoader(),
              new Class<?>[]{target}, new MyInvocatationHandler(target)) ;
    }

    public static void main(String[] args) {
        Calculator   calculator  = (Calculator) new MyInvocatationHandler<Calculator>(Calculator.class).getObject();
        System.out.println(calculator.sum(1,2));
    }
}

这样不管调用什么都会调用invoke方法。如果将这部分变成一个基于io或者nio的东西，就能读取远程的对象。

3）客户端加入Socket

package day20170625;

import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.net.Socket;

/**
 * Created by chenfenggang on 2017/7/17.
 */
public class MyRpcClient<T> implements InvocationHandler {

    private Class target;
    MyRpcClient(Class target) {
        super();
        this.target = target;
    }
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Socket socket = new Socket("localhost",8080);
        ObjectOutputStream objectOutputStream =  new ObjectOutputStream(socket.getOutputStream());
        objectOutputStream.writeObject(target.getName());
        objectOutputStream.writeObject(method.getName());
        objectOutputStream.writeObject(method.getParameterTypes());
        objectOutputStream.writeObject(args);
        return new ObjectInputStream(socket.getInputStream()).readObject();
    }

    public <T>T getObject(){
      return  (T)   Proxy.newProxyInstance(target.getClassLoader(),
              new Class<?>[]{target}, new MyRpcClient(target)) ;
    }

    public static void main(String[] args) {
        Calculator   calculator  = (Calculator) new MyRpcClient<Calculator>(Calculator.class).getObject();
        System.out.println(calculator.sum(123,10));
        System.out.println(calculator.delete(123,10));
    }
}

4）服务端读取客户端请求，反射对象

package day20170625;

import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.HashMap;
import java.util.Map;

/**
 * Created by chenfenggang on 2017/7/17.
 */
public class RpcService  {
    //存储接口与实现类的关系，当然也可以通过客户端传送实现类的类名
    static Map<String ,Class>  classImpMap = new HashMap();
    public static  void put(String name,Class clazz){
        classImpMap.put(name,clazz);
    }
    public static void run() throws IOException, ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InstantiationException, InvocationTargetException {

        ServerSocket serverSocket = new ServerSocket(8080);

        while (true){
            Socket socket = serverSocket.accept();
            ObjectInputStream inputStream =new ObjectInputStream( socket.getInputStream());
            ObjectOutputStream objectOutputStream = new ObjectOutputStream(socket.getOutputStream());
            String calssName = (String)inputStream.readObject();
            String methodName = (String)inputStream.readObject();
            Class<?>[] parameterTypes = (Class<?>[]) inputStream.readObject();
            Object[] arguments = (Object[]) inputStream.readObject();
            Class clazz = null;
            if(calssName!=null) {
                //需要获取接口的实现类
              clazz = classImpMap.get(calssName);
            }
            if(clazz==null){
                continue;
            }
            Method method = clazz.getMethod(methodName,parameterTypes);
            Object result = method.invoke(clazz.newInstance(), arguments);
            objectOutputStream.writeObject(result);
        }
    }

    public static void main(String[] args) {
        try {
            RpcService.put(Calculator.class.getName(),MyCalculator.class);
            RpcService.run();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

5）总结：

RPC优点：

1）客户端只需要接口就像，不用管复杂的实现，

2) 实现代码在服务端运行，可以充分利用服务端代码优势。