从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部分。

秒客网