解密Dubbo:自己动手编写一个较为完善的RPC框架（两万字干货）

现在很多企业都在使用Dubbo或者Spring Cloud做企业的微服务架构,其实对于Dubbo最核心的技术就是RPC调用,现在我们就来动手自己编写一个RPC框架,通过这篇文章的学习,你将学习到

• 分布式系统的概念
• RPC远程方法调用的应用
• Dubbo的原理深入理解

当然,如果要完全自己编写一个RPC框架,我们需要掌握以下知识点

• 网络编程(网络通信) 本文将使用netty4网络通信框架
• 多线程相关知识
• 反射相关知识
• jdk的动态代理
• Spring框架的相关知识

如果对于上述的知识点有一部分不是很理解,也不会影响你阅读本文和对Dubbo的RPC调用原理的理解

好了,我们先来简单的描述一下整个RPC调用的业务流程图

rpc通信模型.png

为了可以实现上面的RPC调用,我们创建的RPC框架的模块之间的关系图如下:

RPC框架流程图.png

对于上面的每个模块的具体作用,使用一个表格简单的进行描述

模块名称主要功能rpc-register主要完成可注册中心Zookeeper的交互
RPC服务端使用该模块往注册中心注册地址和端口
RPC客户端通过该模块获取实时已近注册的服务地址和端口rpc-common定义RPC通信的请求消息和响应消息的规则,以及消息的序列化和反序列化的帮助类rpc-serverRPC服务端,启动RPC服务,扫描app-server中的所有可以提供的服务列表并保存
接受RPC客户端的消息并且通过反射调用具体的方法

响应RPC客户端,把方法执行结果返回到RPC客户端rpc-clientRPC客户端,通过网络通信往RPC服务端发送请求调用消息

接受服务端的响应消息

配置动态代理类,所有的方法调用都通过网络调用发送到RPC服务端app-common具体的应用中的接口和JavaBean对象,类似于service模块和bean模块app-server通过Spring的配置启动SpringContext,并且配置RpcServer和RpcRegistry Bean对象的创建
实现app-common中的接口,并且在接口上添加注解@RpcService(IProductService.class)可以让RPCServer识别到该服务
启动服务app-client通过Spring的配置创建RpcDiscover对象和RpcProxy对象,其中RpcDiscover用于从注册中心获取到服务的地址信息,RpcProxy用于创建类的动态代理对象

接下来我们来看一下具体的实现代码

1. rpc-register
2. 这个模块用户和注册中心进行交互,主要包括三个类
3. 具体的实现代码

package cn.wolfcode.rpc.register;public interface Constant {    //定义客户端连接session会话超时时间,单位为毫秒,该值的设置和zkServer设置的心跳时间有关系
   int SESSION_TIMEOUT=4000;    // 定义用于保存rpc通信服务端的地址信息的目录
   String REGISTRY_PATH="/rpc";    // 定义数据存放的具体目录
   String DATA_PATH=REGISTRY_PATH+"/data";
}
package cn.wolfcode.rpc.register;import lombok.AllArgsConstructor;import lombok.Getter;import lombok.NoArgsConstructor;import lombok.Setter;import org.apache.zookeeper.*;import org.apache.zookeeper.data.Stat;import org.slf4j.Logger;import org.slf4j.LoggerFactory;@Setter@Getter@AllArgsConstructor()@NoArgsConstructorpublic class RpcRegistry {    public static final Logger LOGGER=LoggerFactory.getLogger(RpcRegistry.class);    //zkServer的地址信息
   private String registryAddress;    //zk客户端程序
   private  ZooKeeper zooKeeper;    public void createNode(String data) throws Exception{        //创建一个客户端程序, 对于注册可以不用监听事件
       zooKeeper= new ZooKeeper(registryAddress, Constant.SESSION_TIMEOUT, new Watcher() {            @Override
           public void process(WatchedEvent event) {
           }
       });        if(zooKeeper!=null){            try{                //判断注册的目录是否存在
               Stat stat = zooKeeper.exists(Constant.REGISTRY_PATH, false);                if(stat==null){                    //如果不存在, 创建一个持久的节点目录
                   zooKeeper.create(Constant.REGISTRY_PATH,null,ZooDefs.Ids.OPEN_ACL_UNSAFE,CreateMode.PERSISTENT);
               }                //创建一个临时的序列节点,并且保存数据信息
               zooKeeper.create(Constant.DATA_PATH,data.getBytes(),ZooDefs.Ids.OPEN_ACL_UNSAFE,CreateMode.EPHEMERAL_SEQUENTIAL);
           }catch (Exception e){
               LOGGER.error("",e);
               e.printStackTrace();
           }
       }else{
           LOGGER.debug("zooKeeper connect is null");
       }
   }    //测试程序
   public static void main(String[] args) throws Exception {
       RpcRegistry rpcRegistry = new RpcRegistry();
       rpcRegistry.setRegistryAddress("192.168.158.151:2181");
       rpcRegistry.createNode("testdata");        //让程序等待输入,程序一直处于运行状态
       System.in.read();
   }
}
package cn.wolfcode.rpc.register;import lombok.Getter;import lombok.Setter;import org.apache.zookeeper.WatchedEvent;import org.apache.zookeeper.Watcher;import org.apache.zookeeper.ZooKeeper;import org.slf4j.Logger;import org.slf4j.LoggerFactory;import java.util.ArrayList;import java.util.List;import java.util.Random;@Setter@Getter//地址发现,用于实时的获取最新的RPC服务信息public class RpcDiscover {    public static final Logger LOGGER=LoggerFactory.getLogger(RpcRegistry.class);    //服务端地址 zkServer的地址
   private String registryAddress;    //获取到的所有提供服务的服务器列表
   private volatile List dataList=new ArrayList<>();    private ZooKeeper  zooKeeper=null;    //初始化zkClient客户端
   public RpcDiscover(String registryAddress) throws Exception {        this.registryAddress = registryAddress;
       zooKeeper=new ZooKeeper(registryAddress, Constant.SESSION_TIMEOUT, new Watcher() {            @Override
           public void process(WatchedEvent watchedEvent) {                if(watchedEvent.getType()==Event.EventType.NodeChildrenChanged){                    //监听zkServer的服务器列表变化
                   watchNode();
               }
           }
       });        //获取节点相关数据
       watchNode();
   }    // 从dataList列表随机获取一个可用的服务端的地址信息给rpc-client
   public String discover(){        int size=dataList.size();        if(size>0){            int index= new Random().nextInt(size);            return dataList.get(index);
       }        throw new RuntimeException("没有找到对应的服务器");
   }    //监听服务端的列表信息
   private void watchNode(){        try{            //获取子节点信息
           List nodeList = zooKeeper.getChildren(Constant.REGISTRY_PATH, true);
           List dataList=new ArrayList<>();            for (String node : nodeList) {                byte[] bytes = zooKeeper.getData(Constant.REGISTRY_PATH + "/" + node, false, null);
               dataList.add(new String(bytes));
           }            this.dataList=dataList;
       }catch (Exception e){
           LOGGER.error("",e);
           e.printStackTrace();
       }
   }    //测试程序
   public static void main(String[] args) throws Exception {        //打印获取到的连接地址信息
       System.out.println(new RpcDiscover("192.168.158.151:2181").discover());
       System.in.read();
   }
}
复制代码

• Constant常量定义,设置连接ZKServer的相关参数
• RpcRegistry:往注册中心ZKServer设置地址信息,RPC-Server需要使用
• RpcDiscover: 从注册中心ZKServer获取服务端的网络地址信息 RPC-client需要使用

1. rpc-common
2. 定义RPC通信的请求消息和响应消息的规则,以及消息的序列化和反序列化的帮助类,主要包括
3. 具体代码如下

package cn.wolfcode.rpc.common;import lombok.*;@Setter@Getter@NoArgsConstructor@AllArgsConstructor@ToString//RPC通信的数据请求规则public class RpcRequest {    // 请求消息的消息Id
   private String requestId;    // 请求的具体的类名(接口名称)
   private String className;    // 请求的具体的方法名称
   private String methodName;    // 请求的方法参数类型列表
   private Class[] parameterTypes;    // 请求的方法参数列表
   private Object[] parameters;
}
package cn.wolfcode.rpc.common;import lombok.*;@Setter@Getter@NoArgsConstructor@AllArgsConstructor@ToString//RPC通信消息的响应数据规则public class RpcResponse {    //响应的消息id
   private String responseId;    //请求的消息id
   private String requestId;    // 响应的消息是否成功
   private boolean success;    // 响应的数据结果
   private Object result;    // 如果有异常信息,在该对象中记录异常信息
   private Throwable throwable;
}
package cn.wolfcode.rpc.common;import com.dyuproject.protostuff.LinkedBuffer;import com.dyuproject.protostuff.ProtostuffIOUtil;import com.dyuproject.protostuff.Schema;import com.dyuproject.protostuff.runtime.RuntimeSchema;import org.objenesis.Objenesis;import org.objenesis.ObjenesisStd;import java.util.Map;import java.util.concurrent.ConcurrentHashMap;/**
* 序列化工具类（基于 Protostuff 实现） 用于把对象序列化字节数组, 把字节数组反序列化对象
*/public class SerializationUtil {    private static Map, Schema> cachedSchema = new ConcurrentHashMap, Schema>();    private static Objenesis objenesis = new ObjenesisStd(true);    private SerializationUtil() {
   }    /**
    * 获取类的schema
    * @param cls
    * @return
    */
   @SuppressWarnings("unchecked")    private static  Schema getSchema(Class cls) {
       Schema schema = (Schema) cachedSchema.get(cls);        if (schema == null) {
           schema = RuntimeSchema.createFrom(cls);                if (schema != null) {
               cachedSchema.put(cls, schema);
           }
       }        return schema;
   }    /**
    * 序列化（对象 -> 字节数组）
    */
   @SuppressWarnings("unchecked")    public static  byte[] serialize(T obj) {
       Class cls = (Class) obj.getClass();
       LinkedBuffer buffer = LinkedBuffer.allocate(LinkedBuffer.DEFAULT_BUFFER_SIZE);        try {
           Schema schema = getSchema(cls);            return ProtostuffIOUtil.toByteArray(obj, schema, buffer);//序列化
       } catch (Exception e) {            throw new IllegalStateException(e.getMessage(), e);
       } finally {
           buffer.clear();
       }
   }    /**
    * 反序列化（字节数组 -> 对象）
    */
   public static  T deserialize(byte[] data, Class cls) {        try {         /*
         * 如果一个类没有参数为空的构造方法时候，那么你直接调用newInstance方法试图得到一个实例对象的时候是会抛出异常的
         * 通过ObjenesisStd可以完美的避开这个问题
         * */
           T message = (T) objenesis.newInstance(cls);//实例化
           Schema schema = getSchema(cls);//获取类的schema
           ProtostuffIOUtil.mergeFrom(data, message, schema);            return message;
       } catch (Exception e) {            throw new IllegalStateException(e.getMessage(), e);
       }
   }
}
package cn.wolfcode.rpc.common;import io.netty.buffer.ByteBuf;import io.netty.channel.ChannelHandlerContext;import io.netty.handler.codec.MessageToByteEncoder;//对传递的消息进行编码, 因为是请求/响应对象的传递,先编码为字节数组在发送到服务器解码public class RpcEncoder extends MessageToByteEncoder {    // 传递的数据的对象类型
   private Class genericClass;    public RpcEncoder(Class genericClass) {        this.genericClass = genericClass;
   }    @Override
   protected void encode(ChannelHandlerContext ctx, Object msg, ByteBuf out) throws Exception {        if(genericClass.isInstance(msg)){            //序列化请求消息为字节数组
           byte[] bytes = SerializationUtil.serialize(msg);            // 把数据写入到下一个通道(channel)或者是发往服务端
           out.writeBytes(bytes);
       }
   }
}
package cn.wolfcode.rpc.common;import io.netty.buffer.ByteBuf;import io.netty.channel.ChannelHandlerContext;import io.netty.handler.codec.ByteToMessageDecoder;import java.util.List;//对传递的消息进行解码, 接受到的数据是字节数组,需要把数组转换为对应的请求/响应消息对象public class RpcDecoder extends ByteToMessageDecoder {    private Class genericClass;    public RpcDecoder(Class genericClass) {        this.genericClass = genericClass;
   }    @Override
   //解码方法,把字节数组转换为消息对象
   protected void decode(ChannelHandlerContext ctx, ByteBuf in, List