从0开始写一个基于注解的轻量级分布式RPC框架(1)RPC原理和准备工作

1.原理

RPC(Remote Procedure Call Protocol)远程过程调用,是分布式的基础。

具体源码已经上传GIT 基于注解的RPC源码
RPC就是调用远程服务就像调用本地接口一样。
我们先看一下一个简单又经典的RPC示例

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.ServerSocket;
import java.net.Socket;
public class RpcFramework {
    /**
     * 暴露服务
     * 
     * @param service 服务实现
     * @param port 服务端口
     * @throws Exception 2017年2月22日13:33:02 TODO: 线程池
     */
    public static void export(final Object service, int port) throws Exception {
        if (service == null)
            throw new IllegalArgumentException("service instance == null");
        if (port <= 0 || port > 65535)
            throw new IllegalArgumentException("Invalid port " + port);
        LogCore.RPC.info("Export service={}, port={}", service.getClass().getName(), port);
        @SuppressWarnings("resource")
        ServerSocket server = new ServerSocket(port);
        while (true) {// for (;;)
            /*
             * 阻塞,直到有个链接连过来,这里连上后又阻塞等待链接,所以是个1对n的服务。 调用这方法的函数会被阻塞,这个方法里的线程是为了实现同时1对多,也因此server.accept()不能放在try-resource块里,那样会提前关闭socket
             */
            Socket socket = server.accept();
            try {
                ThreadPoolTool.execute(() -> {
                    try (ObjectInputStream input = new ObjectInputStream(socket.getInputStream())) {
                        String methodName = input.readUTF();
                        Class<?>[] parameterTypes = (Class<?>[]) input.readObject();
                        Object[] arguments = (Object[]) input.readObject();
                        try (ObjectOutputStream output = new ObjectOutputStream(
                                    socket.getOutputStream());) {
                            Method method = service.getClass().getMethod(methodName, parameterTypes);
                            Object result = method.invoke(service, arguments);
                            output.writeObject(result);
                        } catch (Throwable t) {
                            LogCore.RPC.error("rpc framework output err", t);
                        }
                    } catch (Throwable t) {
                        LogCore.RPC.error("rpc framework err", t);
                    }
                });
                // thread.setName("RpcFramework export service:" + service.getClass().getSimpleName());
                // thread.start();
            } catch (Exception e) {
                LogCore.RPC.error("rpc framework socket err", e);
            }
        }
    }

    /**
     * 引用服务
     * 
     * @param <T> 接口泛型
     * @param interfaceClass 接口类型
     * @param host 服务器主机名
     * @param port 服务器端口
     * @return 远程服务
     * @throws Exception
     */
    @SuppressWarnings("unchecked")
    public static <T> T refer(final Class<T> interfaceClass, final String host, final int port) {
        if (interfaceClass == null)
            throw new IllegalArgumentException("Interface class == null");
        if (!interfaceClass.isInterface())
            throw new IllegalArgumentException("The " + interfaceClass.getName() + " must be interface class!");
        if (host == null || host.length() == 0)
            throw new IllegalArgumentException("Host == null!");
        if (port <= 0 || port > 65535)
            throw new IllegalArgumentException("Invalid port " + port);
        LogCore.RPC.info("Get remote service {} from server {}:{}", interfaceClass.getName(), host, port);
        return (T) Proxy.newProxyInstance(interfaceClass.getClassLoader(), new Class<?>[] { interfaceClass },
                    new InvocationHandler() {
                        public Object invoke(Object proxy, Method method, Object[] arguments) throws Throwable {
                            try (Socket socket = new Socket(host, port)) {
                                try (ObjectOutputStream output = new ObjectOutputStream(
                                            socket.getOutputStream())) {
                                    output.writeUTF(method.getName());
                                    output.writeObject(method.getParameterTypes());
                                    output.writeObject(arguments);
                                    try (ObjectInputStream input = new ObjectInputStream(
                                                socket.getInputStream())) {
                                        Object result = input.readObject();
                                        if (result instanceof Throwable) {
                                            throw (Throwable) result;
                                        }
                                        return result;
                                    }
                                }
                            }
                        }
                    });
    }

}

上面的例子中,使用的是传统的IO并用多线程实现并发调用,使用的是JDK序列化。其过程为

1. 通信使用的是Socket IO通信。

2. 服务消费者将要调用的类的接口和要调用的方法和参数

①交给代理

②代理把接口方法名和参数类型和参数值序列化

③代理把序列化后的信息发送到远程网络,并接受结果

④代理将结果反序列化后返回

3. 服务提供者开启Socket Server通过反射来完成方法调用

①服务端开启Socket server，阻塞socket.accept()直到有客户端连接。

②收到请求后,开辟线程处理这个链接传来的信息。并继续阻塞新的socket.accept();

③将连接传来的信息反序列化为方法名，方法参数类型，方法参数值。通过反射调用实例的方法，将结果序列化后返回。调用结束。

当然上面的例子一个实例占用了一个端口。不过对我们了解RPC的原理和思路已经够了:消费者使用代理技术将本地调用代理。服务提供者使用反射调用本地实例的方法。
之后我们将我们可以从0开始写一个比较完整的RPC框架

2.准备工作

(java+maven+zookeeper+netty+springboot(IOC))

需求	方案	说明
工程的构建	maven
通信 netty	netty	使用了netty处理http,这个可以自由选择TCP还是HTTP
序列化	fastjson	使用简单,简化开发
服务的注册和发现	zookeeper	zookeeper维护了连接的session可以主动发现客户端断开而删除节点,zk保证了CAP中的CP,只用了zkclient客户端并将其中的JDK序列化替换为String序列化
IOC容器	Spring boot	只使用其最基本的IOC部分。