RPC基本原理及demo

一、基本原理

1、RPC模型

流程：当 User 想发起一个远程调用时，它实际是通过本地调用 User-stub。 User-stub 负责将调用的接口、方法和参数通过约定的协议规范进行编码并通过本地的 RPCRuntime 实例传输到远端的实例。 远端 RPCRuntime 实例收到请求后交给 Server-stub 进行解码后发起向本地端 Server 的调用，调用结果再返回给 User 端。

2、RPC组件细化

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

二、RPC简易实现

1、项目结构

2、公共服务接口

public interface HelloService {
    String sayHello(String name);
}

3、服务端实现

（1）实现类

public class HelloServiceImpl implements HelloService {
    public String sayHello(String name) {
        return "hello " + name;
    }
}

（2）服务端Rpc服务类实现
其主要逻辑

1、注册服务类
2、启动服务socket，循环等待客户端连接
3、获取客户端传送的信息
4、根据信息解析并调用本地实现，并回传调用值

public class RpcServer {

    private static final HashMap> serviceRegistry = new HashMap>();
    private int port;

    public RpcServer(int port) {
        this.port = port;
    }

    public RpcServer register(Class serviceInterface, Class impClass) {
        //注册服务（接口名:实现类名）
        serviceRegistry.put(serviceInterface.getName(), impClass);
        return this;
    }

    public void run() throws IOException {
        //1、启动服务
        ServerSocket serverSocket = new ServerSocket();
        serverSocket.bind(new InetSocketAddress(port));
        System.out.println("start server！");
        ObjectInputStream input = null;
        ObjectOutputStream output = null;
        Socket socket = null;
        try {
            //2、循环等待连接
            for (; ; ) {
                //3、获取客户端的请求数据
                socket = serverSocket.accept();
                input = new ObjectInputStream(socket.getInputStream());
                String serviceName = input.readUTF();//客户端传过来的接口名
                String methodName = input.readUTF();//客户端传过来的方法名
                Class[] parameterTypes = (Class[]) input.readObject();//客户端传过来的方法参数类型
                Object[] args = (Object[]) input.readObject();//客户端传过来的参数值

                System.out.println("接受到客户端的请求：serviceName：" + serviceName + ",methodName:" + methodName);
                //4、根据客户端传过信息获取注册的服务端接口,并调用
                Class serviceClass = serviceRegistry.get(serviceName);
                if (serviceClass == null) {
                    throw new ClassNotFoundException(serviceName + " not found!");
                }
                Method method = serviceClass.getMethod(methodName, parameterTypes);
                Object invokeResult = method.invoke(serviceClass.newInstance(), args);
                //5、返回调用的方法
                output = new ObjectOutputStream(socket.getOutputStream());
                output.writeObject(invokeResult);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            close(input, output, socket);
        }

    }

    private void close(ObjectInputStream input, ObjectOutputStream output, Socket socket) {
        if (output != null) {
            try {
                output.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        if (input != null) {
            try {
                input.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        if (socket != null) {
            try {
                socket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

（3）服务端启动类

public class ServerMain {
    public static void main(String[] args) throws IOException {
        RpcServer rpcServer = new RpcServer(8888);
        rpcServer.register(HelloService.class, HelloServiceImpl.class);
        rpcServer.run();
    }
}

3、客户端实现

主要逻辑

1、获取ip和port，通过jdk代理远程调用服务端
2、向服务端传递服务接口相关信息，并获取服务端返回的信息

（1）客户端代理类实现

public class RpcClientProxy implements InvocationHandler {
    /**
     * 服务端代理接口
     */
    private Class serverInstance;
    /**
     * 服务端地址
     */
    private InetSocketAddress address;

    public RpcClientProxy(Class serverInstance, String ip, Integer port) {
        this.address = new InetSocketAddress(ip, port);
        this.serverInstance = serverInstance;
    }

    /**
     * 获取客户端代理对象
     *
     * @return
     */
    public T getClientInstance() {
        return (T) Proxy.newProxyInstance(serverInstance.getClassLoader(), new Class[]{serverInstance}, this);
    }


    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Socket socket = null;
        ObjectOutputStream outputStream = null;
        ObjectInputStream inputStream = null;
        try {
            // 1.创建Socket客户端，根据指定地址连接远程服务提供者
            socket = new Socket();
            socket.connect(address);
            //2、将远程服务调用所需的接口类、方法名、参数列表等编码后发送给服务提供者
            outputStream = new ObjectOutputStream(socket.getOutputStream());
            outputStream.writeUTF(serverInstance.getName());//接口名
            outputStream.writeUTF(method.getName());//方法名
            outputStream.writeObject(method.getParameterTypes());//方法参数类型,数组
            outputStream.writeObject(args);//具体方法参数值
            //3、同步阻塞等待服务器返回应答，获取应答后返回
            inputStream = new ObjectInputStream(socket.getInputStream());
            return inputStream.readObject();
        } finally {
            if (socket != null) {
                socket.close();
            }
            if (outputStream != null) {
                outputStream.close();
            }
            if (inputStream != null) {
                inputStream.close();
            }
        }
    }

}

（2）客户端启动类

public class ClientMain {
    public static void main(String[] args) {
        RpcClientProxy clientProxy = new RpcClientProxy(HelloService.class, "127.0.0.1", 8888);
        HelloService helloService = (HelloService) clientProxy.getClientInstance();
        String result = helloService.sayHello("中国");
        System.out.println(result);
    }
}

4、流程总结