动手写RPC起步

前一篇文章简单介绍了下RPC的基本原理，同时附上了一个小的demo，但是这个小的demo并不能在生产上使用，因为生产上的RPC还需要考虑很多因素，比如接入注册中心、高性能的网络通信、高性能的序列化和反序列化、自动路由、容错处理等等。要实现生产上使用的先不谈，我们先来实现一个稍微复杂的RPC，借助这个RPC例子来更深刻的理解RPC原理，为后续Dubbo源码的分析做准备。

一、简单RPC架构设计

回顾下RPC原理图：

如果要自己设计实现稍微简单的一个rpc框架，应该需要考虑注册中心、网络通信、序列化等内容，因为可以设计出如下键略的RPC架构图：

二、项目起步说明

1、本RCP项目涉及的功能点

动态代理、反射、序列化、反序列化、网络通信、编解码、服务发现和注册、心跳与链路检测等

2、本小节内容说明

设计的技术点：动态代理技术、反射（有关动态代理可以看我的另一篇博文：代理模式）
实现的功能：简易的基于socket的rpc

3、本小节项目总体框架图

三、编码实现

1、api模块

创建用于测试的接口

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

2、common模块

request请求实体类

public class Request implements Serializable {
    private static final long serialVersionUID = 7929047349488932740L;
    /**
     * 请求表示id
     */
    private String requestId;
    /**
     * 请求服务类型
     */
    private String className;
    /**
     * 请求方法名称
     */
    private String methodName;
    /**
     * 请求方法参数类型数组
     */
    private Class[] parameterTypes;
    /**
     * 请求参数列表
     */
    private Object[] args;
  ......省略getter/setter
}

response响应实体类：

public class Response {
    private static final long serialVersionUID = -1023480952777229650L;

    private String requestId;
    /**
     * 响应状态吗
     */
    private int code;
    /**
     * 响应消息说明
     */
    private String msg;
    /**
     * 相应数据
     */
    private Object data;
......省略getter/setter

3、provider模块

服务的暴露（包好服务的注册和服务的发布），服务端基本流程是

服务注册->服务发布->服务启动监听请求（socket）->处理请求

//rpc代理服务，用于暴露服务
public class RpcProxyServer {
    /**
     * 创建一个线程池
     */
    ExecutorService executorService = Executors.newCachedThreadPool();
    /**
     * 端口号
     */
    private int port;

    /**
     * 1、服务注册
     * @param serviceInterface
     * @param impClass
     * @return
     */
    public RpcProxyServer register(Class serviceInterface, Class impClass) {
        //注册服务（接口名:实现类名）
        ProcessorHandler.register(serviceInterface, impClass);
        return this;
    }

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

    /**
     *2、 启动发布（启动）
     */
    public void start() {
        System.out.println("服务启动====");
        ServerSocket serverSocket = null;
        try {
            serverSocket = new ServerSocket(port);

            while (true) {//3、通过循环不断接受请求
                Socket socket = serverSocket.accept();//监听客户端的请求
                //4、每一个socket交给一个processorhandler处理，这里的target就是真正的业务类
                executorService.execute(new ProcessorHandler(socket));//处理客户端的请求
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (serverSocket != null) {
                try {
                    serverSocket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

具体处理请求的handler

//服务端接受请求处理线程
public class ProcessorHandler implements Runnable {

    private static final HashMap> serviceRegistry = new HashMap>();
    /**
     * socket
     */
    private Socket socket;

    public static void register(Class serviceInterface, Class impClass) {
        //注册服务（接口名:实现类名）
        serviceRegistry.put(serviceInterface.getName(), impClass);
    }
    public ProcessorHandler(Socket socket) {
        this.socket = socket;
    }

    public void run() {
        //用于定义输入流和输出流
        ObjectInputStream objectInputStream = null;
        ObjectOutputStream objectOutputStream = null;

        try {
            objectInputStream = new ObjectInputStream(socket.getInputStream());
            //从socket中读取请求流对象
            Request rpcRequest = (Request) objectInputStream.readObject();
            //调用正真的处理方法
            Object result = invoke(rpcRequest);
            Response response = new Response();
            response.setRequestId(rpcRequest.getRequestId());
            response.setData(result);
            response.setMsg(ResponseCodeEnum.SUCCESS.getMsg());
            response.setCode(ResponseCodeEnum.SUCCESS.getCode());
            //将结果通过socket输出
            objectOutputStream = new ObjectOutputStream(socket.getOutputStream());
            objectOutputStream.writeObject(result);
            objectOutputStream.flush();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            closeOpenSource(objectInputStream, objectOutputStream);
        }
    }

    private void closeOpenSource(ObjectInputStream objectInputStream, ObjectOutputStream objectOutputStream) {
        if (objectInputStream != null) {
            try {
                objectInputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        if (objectOutputStream != null) {
            try {
                objectOutputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        if (socket != null) {
            try {
                socket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 利用反射技术执行正真的方法(这里只是简单的实现，没有容错处理）
     *
     * @param rpcRequest
     * @return
     */
    private Object invoke(Request rpcRequest) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InstantiationException, InvocationTargetException {
        //获取目标对象并执行目标方法(也就是获取注册后的接口实现类对象）
        Class targetClass = serviceRegistry.get(rpcRequest.getClassName());
        Class[] parameterTypes = rpcRequest.getParameterTypes();
        Method method = targetClass.getMethod(rpcRequest.getMethodName(), parameterTypes);
        Object[] args = rpcRequest.getArgs();
        return method.invoke(targetClass.newInstance(), args);
    }
}

用到的枚举

public enum ResponseCodeEnum {
    SUCCESS(0, "success"),
    FAIL(1, "fail");
....省略

rpc接口实现类：

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

启动服务main方法：

public class Demo1Main {
    public static void main(String[] args) {
        //创建代理服务
        RpcProxyServer rpcProxyServer = new RpcProxyServer(8888);
        //注册服务
        rpcProxyServer.register(HelloService.class, HelloServiceImpl.class);
        //启动服务
        rpcProxyServer.start();
    }
}

4、consumer模块

消费端模块主要是通过jdk动态代理的方式实现rpc接口代理请求远程，基本流程

client->创建代理对象->通过代理对象请求远程服务->接受返回的信息

public class ClientProxy {
    /**
     * 服务端代理接口
     */
    private Class serverInstance;

    /**
     * 服务端地址
     */
    private InetSocketAddress address;

    public ClientProxy(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}, new RemoteInvocationHandler(address));
    }
}

具体远程调用invoke方法（jdk动态代理InvocationHandler）

public class RemoteInvocationHandler implements InvocationHandler {

    /**
     * 服务端地址
     */
    private InetSocketAddress address;

    public RemoteInvocationHandler(InetSocketAddress address) {
        this.address=address;
    }


    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Request rpcRequest = new Request();
        rpcRequest.setClassName(method.getDeclaringClass().getName());
        rpcRequest.setMethodName(method.getName());
        rpcRequest.setParameterTypes(method.getParameterTypes());
        rpcRequest.setArgs(args);

        //通过网络发送正式请求
        RpcNetTransport netTransport = new RpcNetTransport(address.getPort(), address.getHostName());
        Object result = (Object) netTransport.send(rpcRequest);
        return result;//返回收到的结果
    }
}

具体的rpc网络请求（socket）

//网络传送
public class RpcNetTransport {

    private int port;
    private String host;

    public RpcNetTransport(int port, String host) {
        this.port = port;
        this.host = host;
    }

    /**
     * 发送请求
     *
     * @param request
     */
    public Object send(Request request) throws IOException, ClassNotFoundException {
        Socket socket = null;
        ObjectOutputStream outputStream = null;
        ObjectInputStream inputStream = null;
        try {
            // 1.创建Socket客户端，根据指定地址连接远程服务提供者
            socket = new Socket(host, port);
            //2、将远程服务调用所需的接口类、方法名、参数列表等编码后发送给服务提供者
            outputStream=new ObjectOutputStream(socket.getOutputStream());
            outputStream.writeObject(request);
            //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();
            }
        }
    }

}

消费端消费服务main方法：

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

三、总结与思考

总结：本节实现了一个非常简单的rpc原型项目，包含了服务注册、采用BIO的网络通信模型传送数据、采用jdk原生代理模式进行服务代理、采用jdk原生的序列化方式进行序列化和反序列化等。后续将会针对该原型项目不断的改进，不断的引入新的“武器”，来丰富整个rpc项目。
后期预热：引入注册中心（解决服务治理问题）、引入多种高效的序列化机制、引入NIO的网络通信模型、引入软负载均衡机制、引入spi扩展机制、接入spring等等，敬请期待。