基于Netty使用1200行/4000行代码实现分布式RPC框架

基于Netty使用1200行/4000行代码实现分布式RPC框架

先放出Github 链接
目前可用的有两个版本，对应releases中的v2.0和v3.2，代码量分别为1200行和4000行。这两个版本都是可以运行的。稍后介绍它们的区别以及功能等。

前置知识

• 对RPC有一定了解，使用过Dubbo或类似RPC框架的会理解地更容易一些。推荐一本书《大型网站系统与JAVA中间件实践》，其中服务框架这一章就是在讲RPC的概念与实现的大概介绍。
• 对Netty有一定了解，如果之前不了解，现在学起来更好，Dubbo、RocketMQ等知名互联网中间件都在使用该网络编程框架。推荐一本书《Netty实战》。
• 熟悉Java多线程、NIO、反射等基础。推荐一本书《Java并发编程的艺术》。
• 熟悉Spring和SpringBoot，主要是依赖注入和AutoConfig部分。

1200LOC Version（V2.0）

1200行的版本还是实现的比较简陋，比如某个应用只能作为consumer或provider，如果作为provider就必须提供全部的接口服务。另外负载均衡其实有点可笑，因为某个客户端只能连接到一个服务器，也就是说只能保证连接数的负载均衡，无法实现调用的负载均衡。另外功能点也比较有限，可以说只是实现了RPC的基本功能。另一个主要问题，也是在下一个版本中大幅改进的，就是没有分层，各个组件之间直接依赖实现，代码强耦合。

功能列表

• 基于Netty实现长连接式的RPC，包括心跳保持、断线重连、解决粘包半包等
• 基于Protostuff实现消息的序列化
• 基于Zookeeper实现分布式服务注册与发现，并实现了几种负载均衡算法
• 基于动态代理实现透明RPC，并为其编写了Spring Boot Starter

运行环境

1. 安装Zookeeper，具体安装过程请自行搜索
2. 安装ZooInspector或类似软件，用于作为可视化Zookeeper客户端，使用ZK的命令行客户端也可以
3. IDE安装lombok相关的插件，idea和eclipse都有相关的插件。没有接触过这个项目的可以搜一下，是用来简化POJO开发的非常好用的工具，目前项目是强依赖这个工具。
4. 如果发现sample-spring模块无法被Maven识别，可以在根pom.xml中的modules里把这个模块加进来。
5. 修改sample-spring-server和sample-spring-client中的application.properties中的rpc.registryAddress=127.0.0.1:2181（这部分改成你的ZK的监听地址，默认就是这个）
6. 对sample-spring-server中的ServerApplication配置启动参数，启动参数为监听的地址，比如127.0.0.1:8000。在idea中可以这样配置：
7. 启动server，如果抛了java.lang.NoClassDefFoundError: org/apache/commons/logging/LogFactory，那么在根pom.xml中加一个依赖
commons-logging
commons-logging
1.2

8. 启动client，不需要配置任何参数。可以启动多个服务器（前提是监听在不同端口上，如果是在本地的话），也可以启动多个客户端。

实现细节

本来是3月份打算写的，正在准备春招一时抽不出时间，最近的话在重新维护这个项目，就不太想写老旧的实现了。
但还是有一定参考价值的，代码量比较小，并且具备基本的功能，虽然有一些功能字面上和主流RPC框架一样，但在实现还是打了一些折扣的。

这个版本实现如果读者有兴趣的烦请自行阅读源码。

4000LOC Version（V3.2）

目前版本与V2.0的区别当时不仅仅是名字改成了toy-rpc，主要是在分层抽象上下了很大功夫。

功能列表

• 基于Netty实现长连接式的RPC，包括心跳保持、断线重连、解决粘包半包等
• 基于Zookeeper实现分布式服务注册与发现，并实现了轮询、随机、加权随机、一致性哈希等负载均衡
  算法，以及FailOver、FailFast、FailSafe等多种集群容错方式
• 参考Dubbo实现了分层结构，如
  config,proxy,cluster,protocol,filter,invocation,registry,transport,executor,serialize等层
• 实现了同步、异步、回调、Oneway等多种调用方式
• 实现了TCP、HTTP、InJvm等多种协议
• 实现了客户端侧的Filter，并基于此实现了LeastActive负载均衡算法
• 实现了简易扩展点，泛化调用等功能
• 基于动态代理实现透明RPC，并为其编写了Spring Boot Starter

V2.0的很多问题也被纠正的了，比如一个应用即可以提供远程服务，也可以调用远程服务；负载均衡也实现了每次远程服务调用的时候进行负载均衡；每个应用也不必一定要提供全部的接口服务了。
应该主流RPC框架提供的大部分功能都有了，未来可能会再完善的点有下面这些：
- 优雅停机
- 服务限流、熔断
- 结果缓存
- 多版本，分组
- Router
- 网络层分层、
- Monitor，持久化配置

运行环境

与V2.0基本一致，区别就是server的启动参数配置方式不同：

这个-D是用来覆盖SpringBoot中application.properties配置项的，其实这个地址也可以直接写死在配置文件里，但是如果要启动多个服务器的时候需要改文件，用启动参数就可以提前配置几个idea中的Run Configuration，这样就直接运行即可。

使用方法（独立项目）

在自己的项目中首先引入spring-boot，然后加入toy-rpc-spring-boot-starter的Jar包（本地引入），最后使用@RPCService和@RPCReference来引入，application.properties的配置可以参考几个示例项目，下面也会有介绍。

1.、创建一个SpringBoot项目
2.、对toy-rpc进行打包（maven-install），得到一个toy-spring-boot-starter的jar包（比如路径为D:/idea/toy-rpc/toy-rpc-spring-boot-starter/target/toy-rpc-spring-boot-starter-1.0-SNAPSHOT-jar-with-dependencies.jar），注意要选择这个with-dependencies的jar包。
3.、在你的项目中引入该jar包，使用本地依赖的方式。

 <dependency>
            <groupId>com.sinjinsonggroupId>
            <artifactId>toy-rpc-spring-boot-starterartifactId>
            <version>1.0-SNAPSHOTversion>
            <scope>systemscope>
            <systemPath>D:/idea/toy-rpc/toy-rpc-spring-boot-starter/target/toy-rpc-spring-boot-starter-1.0-SNAPSHOT-jar-with-dependencies.jarsystemPath>
        dependency>

4.、配置application.properties

rpc.application.name=app-1
rpc.application.serialize=protostuff
rpc.application.proxy=jdk
rpc.protocol.type=injvm
rpc.protocol.executor.server.threads=100
rpc.protocol.executor.server.type=threadpool
#rpc.protocol.executor.client.threads=2
rpc.protocol.executor.client.type=threadpool
rpc.registry.address=127.0.0.1:2181
rpc.cluster.loadbalance=LEAST_ACTIVE

5.、使用@RPCServicce来暴露一个服务，使用@RPCReference来引用一个服务。

@RPCService
public class HelloServiceImpl implements HelloService {

    public String hello(User user) {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return "Hello, " + user.getUsername();
    }
}

@Slf4j
@Service
public class SyncCallService {
    @RPCReference    
    private HelloService helloService;

    public void test() throws Exception {
        log.info("sync:{}",helloService.hello(new User("1")));
        log.info("sync:{}",helloService.hello(new User("2")));
        Thread.sleep(3000);
        log.info("sync:{}",helloService.hello(new User("3")));
        Thread.sleep(8000);
        log.info("sync:{}",helloService.hello(new User("4")));

    }
}

给一个示例的pom.xml

<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0modelVersion>

    <parent>
        <groupId>org.springframework.bootgroupId>
        <artifactId>spring-boot-starter-parentartifactId>
        <version>1.5.9.RELEASEversion>
    parent>

    <groupId>com.sinjinsonggroupId>
    <artifactId>hello-toyartifactId>
    <version>1.0-SNAPSHOTversion>

    <properties>
        <project.build.sourceEncoding>UTF-8project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8project.reporting.outputEncoding>
        <java.version>1.8java.version>
        <slf4j.version>1.7.25slf4j.version>
        <log4j.version>1.2.17log4j.version>
    properties>

    <dependencies>
        <dependency>
            <groupId>junitgroupId>
            <artifactId>junitartifactId>
            <version>4.12version>
            <scope>testscope>
        dependency>
        
        <dependency>
            <groupId>org.projectlombokgroupId>
            <artifactId>lombokartifactId>
            <version>1.16.18version>
            <scope>providedscope>
        dependency>
        <dependency>
            <groupId>org.slf4jgroupId>
            <artifactId>slf4j-log4j12artifactId>
            <version>${slf4j.version}version>
        dependency>
        
        <dependency>
            <groupId>log4jgroupId>
            <artifactId>log4jartifactId>
            <version>${log4j.version}version>
        dependency>
        <dependency>
            <groupId>com.sinjinsonggroupId>
            <artifactId>toy-rpc-spring-boot-starterartifactId>
            <version>1.0-SNAPSHOTversion>
            <scope>systemscope>
            <systemPath>D:/idea/toy-rpc/toy-rpc-spring-boot-starter/target/toy-rpc-spring-boot-starter-1.0-SNAPSHOT-jar-with-dependencies.jarsystemPath>
        dependency>
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-bootartifactId>
            <version>1.5.9.RELEASEversion>
        dependency>
    dependencies>
project>

独立的示例项目代码如果有需要的话可以跟我要一下，如果只是抱着学习源码的态度，项目中的sample-spring下面的示例也足够了。

实现细节

分层抽象

先看一张非常有名的图，相信熟悉Dubbo的同学一定见过：

在V3.2的版本中，分层抽象有相当一部分是借鉴了Dubbo的实现，因为我认为Dubbo的分层是我所见过的软件项目做得非常优秀的。优秀的分层不仅仅使项目的可读性、可维护性更好，其可扩展性（对于RPC框架来说是非常重要的）也会变得非常出色。我在实习期间也略看了一点阿里巴巴内部使用的HSF（High-Speed Service Framework），其功能也和Dubbo大同小异，但是分层、架构设计明显还是Dubbo更优秀一些。

首先要澄清的一点是，toy-rpc不是把Dubbo直接拷贝过来，这明显意义也不大，主要目的还是进一步熟悉RPC，实现更多的功能点（在代码量尽量小的前提下）以及提高工程能力。但功能与Dubbo非常类似，架构设计也有参考的地方，在重构V2.0的时候主要是参考了上面这张图以及部分接口定义，在实现遇到困难的时候也参考了一部分Dubbo源码实现。

在实现的时候遇到的主要问题还是分层的问题，在如何实现组件、层次、模块之间低内聚、高耦合方面花了很多心思，也经历了反复迭代、优化的过程。

现在给大家看几张图，描述了整体架构，有点模仿Dubbo的那张架构图，但是不知道怎么画一起:)

初始化

服务调用之ConsumerSide

服务调用之ProviderSide

同步调用的完整时序图

各层介绍

扩展点：用户可以为某个接口添加自己的实现，在不改变框架源码的前提下，对部分实现进行定制。
最常见的是Filter扩展点。

config

配置层。
设计准则是Instance wrapped by config，一个配置类中持有了它相关的配置的实例。

对应的核心类：
- ReferenceConfig（对应一个服务接口的引用，持有接口代理实例）
- ServiceConfig（对应一个服务接口的暴露，持有接口实现类实例）
- GlobalConfig（全局配置）
- ApplicationConfig（应用配置，持有ProxyFactory实例、Serializer实例）
- RegistryConfig（注册中心配置，持有ServiceRegistry实例）
- ProtocolConfig（协议配置，持有Protocol实例、Executor实例）
- ClusterConfig（集群配置，持有LoadBalancer实例、FaultToleranceHandler实例）

proxy

代理层，主要是为ReferenceConfig生成接口的代理实例（抽象为Invoker，底层是RPC），以及为ServiceConfig生成接口的代理实例（抽象为Invoker，底层直接委托给实现类实例）。
对应的核心类：
- RPCProxyFactory（扩展点，目前有Jdk一种实现）

registry

注册中心层，主要是服务注册与服务发现，比如对于provider而言，在服务暴露的时候将自己的地址写入到注册中心；对于consumer而言，在服务发现的时候获取服务器的地址，并建立连接，并订阅地址列表，当服务器上下线时，consumer可以感知。
对应的核心类：
- ServiceRegistry（扩展点，目前有Zookeeper一种实现）

cluster

集群层，主要是将一个接口的集群实现对外暴露为单个实现，屏蔽集群的细节。在集群内部主要是做负载均衡以及集群容错。
对应的核心类：
- LoadBalancer（扩展点，必须继承自AbstractLoadBalancer，目前有随机、加权随机、轮询、一致性哈希、最小活跃度五种实现）
- FaultToleranceHandler（扩展点，目前有FailOver、FailFast、FailSafe三种实现）

protocol、invocaiton、filter

协议层，也是最核心的一层。
对应的核心类：
- Protocol（扩展点，目前有TCP、HTTP、InJvm三种实现，需要实现响应的Invoker）
- Filter（扩展点，目前有一个为了实现LeastActive算法的ActiveLimitFilter实现）
- Invocation（扩展点，一般不需要扩展，目前有同步、异步、Oneway、Callback四种实现）

transport

通信层，需要配合协议层，自定义协议实现需要相应的自定义通信实现。
对应的核心类：
- Server（在协议export时如果需要，需要启动服务器）
- Client（在协议refer时如果需要，需要启动客户端）
它们不是扩展点，只是Protocol在执行相应操作时依赖的组件。

executor、serialize

其他的较为独立的组件，如任务执行器和序列化器。
对应的核心类：
- TaskExecutor（扩展点，服务器的接口的调用任务线程池，或者客户端的callback线程池，目前有线程池和Disruptor两种实现）
- Serialzer（扩展点，目前有Jdk和Protostuff两种实现）

如何扩展一个扩展点

举两个例子，一个是暂时不需要设置alias别名的，一个是需要设置的。

• Filter
  
  • 在resources目录下创建一个toy目录，然后创建一个名为com.sinjinsong.toy.filter.Filter的文件，文件内容是k=v的格式，k是一个实现类的别名，v是实现类的全类名，比如：bizlog=com.sinjinsong.toy.sample.spring.client.filter.BizLogFilter。这个和Dubbo的实现非常像。
• Serializer
  
  • 同上，文件名为com.sinjinsong.toy.serialize.api.Serializer，文件内容也是k=v的格式。另外，需要修改application.properties中的rpc.application.serialize={你在文件里写的k}。

必备概念

• Invoker：抽象的服务调用者，包括consumer端的代理实例和provider端的真正的服务实现类实例。对于consumer端而言，一个协议Invoker（由某个Protocol调用其refer生成的实例）是对应于一个接口的一个服务器实现(interface,address)；一个ClusterInvoker是对应于一个接口的所有服务器实现的(interface)。现在这一点不太理解的可以往后看，后面有更详细的解释。

• Exporter：Invoker暴露之后的抽象，是抽象的服务暴露后的调用者。

Config层实现细节

GlobalConfig

全局的配置实例，是单例的，持有四个同样是全局单例的配置类。

public class GlobalConfig {
    private ApplicationConfig applicationConfig;
    private ClusterConfig clusterConfig;
    private RegistryConfig registryConfig;
    private ProtocolConfig protocolConfig;
}

应用内的依赖注入

整个应用中的依赖注入都是在toy-rpc-spring-boot-starter的RPCAutoConfiguration中完成的。这里其实涉及一个问题，就是业务系统通常是会依赖Spring来完成bean的加载、依赖注入等，而中间件或者轮子，它们同样也有着依赖注入的需求，那能不能也用Spring呢？答案是能，但是非常不建议这样做，原因是：
1、重。我们这个rpc本身只有4k行代码，但是一个Spring就有几百万行代码，无疑是会增加体积、降低初始化速度等。
2、依赖冲突。假设我们轮子里引入了Spring，那业务系统直接依赖了Spring，用来做依赖注入，又依赖了我们这样轮子，间接依赖了Spring，版本不同的话很容易出现依赖冲突，这会对使用者带来非常大的困扰。

那Dubbo是如何解决这个问题的呢？Dubbo针对JDK提供的SPI机制，自己重写了SPI，可以动态地根据URL来获取同一接口的不同实现类。我们toy-rpc暂时不需要运行时来获取实现类，只需要根据配置文件的配置来决定使用哪个实现类，所以这里是用枚举单例的方式来做依赖注入。
以ApplicationConfig的加载为例：

    @Bean
    public ApplicationConfig applicationConfig() {
        ApplicationConfig application = properties.getApplication();
        if (application == null) {
            throw new RPCException(ErrorEnum.APP_CONFIG_FILE_ERROR, "必须配置applicationConfig");
        }
        // TODO 根据类型创建proxyFactory和serializer
        application.setProxyFactoryInstance(new JdkRPCProxyFactory());

        application.setSerializerInstance(extensionLoader.load(Serializer.class, SerializerType.class, application.getSerialize()));
        log.info("{}", application);
        return application;
    }

Serializer是可以根据配置文件来选择不同实现的，这里有一个相关的枚举类SerializerType：

public enum SerializerType implements ExtensionBaseType {
    PROTOSTUFF(new ProtostuffSerializer()),
    JDK(new JdkSerializer());

    private Serializer serializer;

    SerializerType(Serializer serializer) {
        this.serializer = serializer;
    }

    @Override
    public Serializer getInstance() {
        return serializer;
    }
}

我们看一下extensionLoader是怎么处理的。

    public  T load(Class interfaceClass, Class enumType, String type) {
        ExtensionBaseType extensionBaseType = ExtensionBaseType.valueOf(enumType, type.toUpperCase());
        if (extensionBaseType != null) {
            return extensionBaseType.getInstance();
        }
        if (!extensionMap.containsKey(interfaceClass.getName())) {
            throw new RPCException(ErrorEnum.NO_SUPPORTED_INSTANCE, "{} 没有可用的实现类", interfaceClass);

        }
        Object o = extensionMap.get(interfaceClass.getName()).get(type);
        if (o == null) {
            throw new RPCException(ErrorEnum.NO_SUPPORTED_INSTANCE, "{} 没有可用的实现类", interfaceClass);
        }
        return interfaceClass.cast(o);
    }

其实就是先用valueOf来找枚举，如果能找到，那么getInstance获取实例即可。后面那部分代码是用来实现扩展点的。

应用外的依赖注入

比如说用户自己定义了一个Filter，会在com.sinjinsong.toy.filter.Filter文件里配置一行bizlog=com.sinjinsong.toy.sample.spring.client.filter.BizLogFilter。
在RPCAutoConfiguration的afterPropertiesSet中会使用extensionLoader来加载扩展点。

    public void loadResources() {
        URL parent = this.getClass().getClassLoader().getResource("toy");
        if (parent != null) {
            log.info("/toy配置文件存在，开始读取...");
            File dir = new File(parent.getFile());
            File[] files = dir.listFiles();
            for (File file : files) {
                handleFile(file);
            }
            log.info("配置文件读取完毕!");
        }
    }

    private void handleFile(File file) {
        log.info("开始读取文件:{}", file);
        String interfaceName = file.getName();
        try {
            Class interfaceClass = Class.forName(interfaceName);
            BufferedReader br = new BufferedReader(new FileReader(file));
            String line;
            while ((line = br.readLine()) != null) {
                String[] kv = line.split("=");
                if (kv.length != 2) {
                    log.error("配置行不是x=y的格式的:{}", line);
                    throw new RPCException(ErrorEnum.EXTENSION_CONFIG_FILE_ERROR, "配置行不是x=y的格式的:{}", line);
                }
                // 如果有任何异常，则跳过这一行
                try {
                    Class impl = Class.forName(kv[1]);
                    if (!interfaceClass.isAssignableFrom(impl)) {
                        log.error("实现类{}不是该接口{}的子类", impl, interfaceClass);
                        throw new RPCException(ErrorEnum.EXTENSION_CONFIG_FILE_ERROR, "实现类{}不是该接口{}的子类", impl, interfaceClass);
                    }
                    Object o = impl.newInstance();
                    register(interfaceClass, kv[0], o);
                } catch (Throwable e) {
                    e.printStackTrace();
                    throw new RPCException(ErrorEnum.EXTENSION_CONFIG_FILE_ERROR, "实现类对象{}加载类或实例化失败", kv[1]);
                }
            }
            br.close();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
            throw new RPCException(e, ErrorEnum.EXTENSION_CONFIG_FILE_ERROR, "接口对象{}加载类失败", file.getName());
        } catch (IOException e) {
            e.printStackTrace();
            throw new RPCException(e, ErrorEnum.EXTENSION_CONFIG_FILE_ERROR, "配置文件{}读取失败", file.getName());
        }
    }

简单地说就是把配置文件都读进来，然后对对象进行实例化，缓存起来，在load的时候可以返回用户提供的扩展点对象。

    public  List load(Class interfaceClass) {
        if (!extensionMap.containsKey(interfaceClass.getName())) {
            return Collections.EMPTY_LIST;
        }
        Collection