1、源码下载和编译

源码下载、编译和导入步骤如下：
（1）dubbo的项目在github中的地址为: https://github.com/apache/dubbo
（2）进入需要进行下载的地址，执行 git clone https://github.com/apache/dubbo.git
（3）为了防止master中代码不稳定，进入dubbo项目 cd dubbo 可以切入到最近的release分支 git checkout 2.7.6-release
（4）进行本地编译，进入dubbo项目 cd dubbo , 进行编译操作 mvn clean install -DskipTests
（5）使用IDE引入项目。

2、架构整体设计

2.1 Dubbo调用关系说明

在这里主要由四部分组成:

• Provider: 暴露服务的服务提供方

Protocol 负责提供者和消费者之间协议交互数据
Service 真实的业务服务信息 可以理解成接口 和 实现
Container Dubbo的运行环境

• Consumer: 调用远程服务的服务消费方

Protocol 负责提供者和消费者之间协议交互数据
Cluster 感知提供者端的列表信息
Proxy 可以理解成 提供者的服务调用代理类 由它接管 Consumer中的接口调用逻辑

• Registry: 注册中心，用于作为服务发现和路由配置等工作，提供者和消费者都会在这里进行注册
• Monitor: 用于提供者和消费者中的数据统计，比如调用频次，成功失败次数等信息。

启动和执行流程说明:
提供者端启动 容器负责把Service信息加载 并通过Protocol 注册到注册中心
消费者端启动 通过监听提供者列表来感知提供者信息 并在提供者发生改变时 通过注册中心及时
通知消费端
消费方发起 请求 通过Proxy模块
利用Cluster模块 来选择真实的要发送给的提供者信息
交由Consumer中的Protocol 把信息发送给提供者
提供者同样需要通过 Protocol 模块来处理消费者的信息
最后由真正的服务提供者 Service 来进行处理

2.2 整体的调用链路

**

说明 淡绿色代表了 服务生产者的范围 淡蓝色 代表了服务消费者的范围 红色箭头代表了调用的方向

从外到内分为三层： 业务逻辑层 RPC层(远程过程调用) Remoting (远程数据传输层)

整体链路调用的流程:（面试中经常会问到）
1. 消费者通过Interface进行方法调用 统一交由消费者端的 Proxy 通过ProxyFactory 来进行代理对象的创建 使用到了jdk javassist技术
2.交给Filter 这个模块 做一个统一的过滤请求 在SPI案例中涉及过
3.接下来会进入最主要的Invoker调用逻辑
通过Directory 去配置中新读取信息 最终通过list方法获取所有的Invoker
通过Cluster模块 根据选择的具体路由规则 来选取Invoker列表
通过LoadBalance模块 根据负载均衡策略 选择一个具体的Invoker 来处理我们的请求
如果执行中出现错误 并且Consumer阶段配置了重试机制 则会重新尝试执行
4. 继续经过Filter 进行执行功能的前后封装 Invoker 选择具体的执行协议（此处Filter与第二步针对的对象不同，此处做一样计数，统计、上下文数据处理等）
5. 客户端 进行编码和序列化 然后发送数据
6. 到达Consumer中的 Server 在这里进行 反编码 和 反序列化的接收数据
7. 使用Exporter选择执行器
8. 交给Filter 进行一个提供者端的过滤 到达 Invoker 执行器
9. 通过Invoker 调用接口的具体实现 然后返回

2.3 Dubbo源码整体设计

图例说明：

• 图中左边淡蓝背景的为服务消费方使用的接口，右边淡绿色背景的为服务提供方使用的接口，位于中轴线上的为双方都用到的接口。
• 图中从下至上分为十层，各层均为单向依赖，右边的黑色箭头代表层之间的依赖关系，每一层都可以剥离上层被复用，其中，Service 和 Confifig 层为 API，其它各层均为 SPI。
• 图中绿色小块的为扩展接口，蓝色小块为实现类，图中只显示用于关联各层的实现类。
• 图中蓝色虚线为初始化过程，即启动时组装链，红色实线为方法调用过程，即运行时调时链，紫色三角箭头为继承，可以把子类看作父类的同一个节点，线上的文字为调用的方法。

调用链路结合上图需要记住
Dubbo源码整体设计与调用链路十分相似。只不过这里可以看到接口的一些具体实现以及左侧也有更为详细的层次划分，我们在后面的源码解析时也会着重介绍其中比较重要的模块实现。

分层介绍:（需记住）

• Business 业务逻辑层

• service 业务层 包括我们的业务代码 比如 接口 实现类 直接面向开发者RPC层 远程过程调用层

• config 配置层 对外提供配置 以ServiceConfifig ReferenceConfifig 为核心 可以直接初始化配置类 也可以解析配置文件生成

• proxy 服务代理层 无论是生产者 还是消费者 框架都会产生一个代理类 整个过程对上层透明 就是业务层对远程调用无感
• registry 注册中心层 封装服务地址的注册与发现 以服务的URL为中心
• cluster 路由层 (集群容错层) 提供了多个提供者的路由和负载均衡 并且它桥接注册中心 以Invoker为核心
• monitor 监控层 RPC调用相关的信息 如 调用次数 成功失败的情况 调用时间等 在这一层完成
• protocol 远程调用层 封装RPC调用 无论是服务的暴露 还是 服务的引用 都是在Protocol中作为主功能入口 负责Invoker的整个生命周期 Dubbo中所有的模型都向Invoker靠拢

• Remoting层 远程数据传输层

• exchange 信息交换层 封装请求和响应的模式 如把请求由同步 转换成异步

• transport 网络传输层 统一网络传输的接口 比如 netty 和 mina 统一为一个网络传输接口

• serialize 数据序列化层 负责管理整个框架中的数据传输的序列化 和反序列化

  3、服务注册与消费源码剖析

  3.1 注册中心Zookeeper剖析

  注册中心是Dubbo的重要组成部分，主要用于服务的注册与发现，我们可以选择Redis、Nacos、
  Zookeeper作为Dubbo的注册中心，Dubbo推荐用户使用Zookeeper作为注册中心。
  注册中心Zookeeper目录结构
  我们使用一个最基本的服务的注册与消费的Demo来进行说明。
  例如：只有一个提供者和消费者。 com.lagou.service.HelloService 为我们所提供的服务。

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

  则Zookeeper的目录结构如下：
  

• 可以在这里看到所有的都是在dubbo层级下的

• dubbo跟节点下面是当前所拥有的接口名称，如果有多个接口，则会以多个子节点的形式展开
• 每个服务下面又分别有四个配置项
  • consumers: 当前服务下面所有的消费者列表(URL)
  • providers: 当前服务下面所有的提供者列表(URL)
  • configuration: 当前服务下面的配置信息信息，provider或者consumer会通过读取这里的配置信息来获取配置
  • routers: 当消费者在进行获取提供者的时，会通过这里配置好的路由来进行适配匹配规则。
• 可以看到，dubbo基本上很多时候都是通过URL的形式来进行交互获取数据的，在URL中也会保存很多的信息。后面也会对URL的规则做详细介绍。

通过这张图我们可以了解到如下信息:

• 提供者会在 providers 目录下进行自身的进行注册。
• 消费者会在 consumers 目录下进行自身注册，并且监听 provider 目录，以此通过监听提供者增加或者减少，实现服务发现。
• Monitor模块会对整个服务级别做监听，用来得知整体的服务情况。以此就能更多的对整体情况做监控。

3.2 服务的注册过程分析

服务注册(暴露)过程(面试重点) 下图流程必须能说清楚
（注册中心挂了之后，如果远程服务没有调用过，没有本地缓存， 可以通过直连方式进行远程调用）
**
查看ServiceConfifig类，重点查看 ProxyFactory 和 Protocol 类型的属性 以及 ref
ServiceConfig类中定义了静态属性Protocol和ProxyFactory 都是通过SPI方式获取到实例

ref的定义位于其父类ServiceConfigBase

ServiceConfig 类拿到对外提供服务的实际类 ref(如：HelloServiceImpl),然后通过ProxyFactory 接口实现类中的 getInvoker 方法使用 ref 生成一个 AbstractProxyInvoker 实例，到这一步就完成具体服务到 Invoker 的转化。

接下来就是 Invoker 转换到 Exporter 的过程。
其中会涉及到 RegistryService接口 RegistryFactory 接口 和 注册provider到注册中心流程的过程
（1）RegistryService代码解读,这块儿的代码比较简单，主要是对指定的路径进行注册，解绑，监听和
取消监听，查询操作。也是注册中心中最为基础的类。

package org.apache.dubbo.registry;
import org.apache.dubbo.common.URL;
import java.util.List;
/**
 * RegistryService. (SPI, Prototype, ThreadSafe)
 *
 * @see org.apache.dubbo.registry.Registry
 * @see org.apache.dubbo.registry.RegistryFactory#getRegistry(URL)
 */
public interface RegistryService {
   /*** 进行对URL的注册操作，比如provider，consumer，routers等 */
    void register(URL url);
    /*** 解除对指定URL的注册，比如provider，consumer，routers等 */
    void unregister(URL url);
    /*** 增加对指定URL的路径监听，当有变化的时候进行通知操作 */
    void subscribe(URL url, NotifyListener listener);
    /*** 解除对指定URL的路径监听，取消指定的listener */
    void unsubscribe(URL url, NotifyListener listener);
    /*** 查询指定URL下面的URL列表，比如查询指定服务下面的consumer列表 */
    List<URL> lookup(URL url);
}

（2）我们再来看 RegistryFactory ，是通过他来生成真实的注册中心。通过这种方式，也可以保证一
个应用中可以使用多个注册中心。可以看到这里也是通过不同的protocol参数，来选择不同的协议。

package org.apache.dubbo.registry;
import org.apache.dubbo.common.URL;
import org.apache.dubbo.common.extension.Adaptive;
import org.apache.dubbo.common.extension.SPI;
/**
 * RegistryFactory. (SPI, Singleton, ThreadSafe)
 *
 * @see org.apache.dubbo.registry.support.AbstractRegistryFactory
 */
@SPI("dubbo")
public interface RegistryFactory {
    /**
     * Connect to the registry
     * <p>
     * Connecting the registry needs to support the contract: <br>
     * 1. When the check=false is set, the connection is not checked, otherwise the exception is thrown when disconnection <br>
     * 2. Support username:password authority authentication on URL.<br>
     * 3. Support the backup=10.20.153.10 candidate registry cluster address.<br>
     * 4. Support file=registry.cache local disk file cache.<br>
     * 5. Support the timeout=1000 request timeout setting.<br>
     * 6. Support session=60000 session timeout or expiration settings.<br>
     *
     * @param url Registry address, is not allowed to be empty
     * @return Registry reference, never return empty value
     */
    /*** 获取注册中心地址 */
    @Adaptive({"protocol"})
    Registry getRegistry(URL url);
}

（3）下面我们就来跟踪一下，一个服务是如何注册到注册中心上去的。其中比较关键的一个类是RegistryProtocol ，他负责管理整个注册中心相关协议。并且统一对外提供服务。这里我们主要以RegistryProtocol.export 方法作为入口，这个方法主要的作用就是将我们需要执行的信息注册并且导出。
根据上面调试可以看出，将具体服务ref封装成Invoker后是调用 RegistryProtocol.export方法来将Invoker转换成exporter的

进入RegistryProtocol.export方法

在这里获取一些相关参数 源码如下

 @Override
    public <T> Exporter<T> export(final Invoker<T> originInvoker) throws RpcException {
        // 获取注册中心的地址
        URL registryUrl = getRegistryUrl(originInvoker);
        // url to export locally // 获取当前提供者需要注册的地址
        URL providerUrl = getProviderUrl(originInvoker);
        // 获取进行注册override协议的访问地址
        final URL overrideSubscribeUrl = getSubscribedOverrideUrl(providerUrl);
        // 增加override的监听器
        final OverrideListener overrideSubscribeListener = new OverrideListener(overrideSubscribeUrl, originInvoker);
        overrideListeners.put(overrideSubscribeUrl, overrideSubscribeListener);
        // 根据现有的override协议，对注册地址进行改写操作
        providerUrl = overrideUrlWithConfig(providerUrl, overrideSubscribeListener);
        //export invoker
        // 对当前的服务进行本地导出 
        // 完成后即可在看到本地的20880端口号已经启动，并且暴露服务
        final ExporterChangeableWrapper<T> exporter = doLocalExport(originInvoker, providerUrl);
        // url to registry // 获取真实的注册中心, 比如我们常用的ZookeeperRegistry
        final Registry registry = getRegistry(originInvoker);
        // 获取当前服务需要注册到注册中心的providerURL，主要用于去除一些没有必要的参数(比如在本地导出时所使用的qos参数等值)
        final URL registeredProviderUrl = getUrlToRegistry(providerUrl, registryUrl);
        // decide if we need to delay publish
        // 获取当前url是否需要进行注册参数
        boolean register = providerUrl.getParameter(REGISTER_KEY, true);
        if (register) {
            // 将当前的提供者注册到注册中心上去（重点）
            register(registryUrl, registeredProviderUrl);
        }
        // Deprecated! Subscribe to override rules in 2.6.x or before.
        // 对override协议进行注册，用于在接收到override请求时做适配,这种方式用于适配2.6.x及之 前的版本(混用)
        registry.subscribe(overrideSubscribeUrl, overrideSubscribeListener);
        // 设置当前导出中的相关信息
        exporter.setRegisterUrl(registeredProviderUrl);
        exporter.setSubscribeUrl(overrideSubscribeUrl);
        //Ensure that a new exporter instance is returned every time export
        // 返回导出对象(对数据进行封装)
        return new DestroyableExporter<>(exporter);
    }

（4）下面我们再来看看 register 方法, 这里面做的比较简单，主要是从 RegistoryFactory 中获取注册中心，并且进行地址注册。

public void register(URL registryUrl, URL registeredProviderUrl) {
    // 获取注册中心
    Registry registry = registryFactory.getRegistry(registryUrl); 
    // 对当前的服务进行注册 
    registry.register(registeredProviderUrl); 
    // ProviderModel 表示服务提供者模型，此对象中存储了与服务提供者相关的信息。
    // 比如服务的配置信息，服务实例等。每个被导出的服务对应一个 ProviderModel。
    ProviderModel model = ApplicationModel.getProviderModel(registeredProviderUrl.getServiceKey()); 
    model.addStatedUrl(new ProviderModel.RegisterStatedURL( registeredProviderUrl, registryUrl, true ));
}

（5）这里我们再跟里面的register方法之前，先来介绍一下Registry中的类目录结构


目录结构描述如下：

• 在这里每个层级代表继承自父级
• 这里面 RegistryService 就是我们之前所讲对外提供注册机制的接口。
• 其下面 Registry 也同样是一个接口，是对 RegistryService 的集成，并且继承了 Node 接口，说明注册中心也是基于URL去做的。
• AbstractRegistry 是对注册中心的封装，其主要会对本地注册地址的封装，主要功能在于远程注册中心不可用的时候，可以采用本地的注册中心来使用。
• FailbackRegistry 从名字中可以看出来，失败自动恢复，后台记录失败请求，定时重发功能。
• 最深的一层则更多是真实的第三方渠道实现。

继续跟踪register 发现进入了FailbackRegistry类
（6）下面我们来看一下在 FailbackRegistry 中的实现, 可以在这里看到他的主要作用是调用第三方的实现方式，并且在出现错误时增加重试机制。

@Override
    public void register(URL url) {
        if (!acceptable(url)) {
            logger.info("URL " + url + " will not be registered to Registry. Registry " + url + " does not accept service of this protocol type.");
            return;
        }
        // 上层调用 // 主要用于保存已经注册的地址列表
        super.register(url);
        // 将一些错误的信息移除(确保当前地址可以在出现一些错误的地址时可以被删除)
        removeFailedRegistered(url);
        removeFailedUnregistered(url);
        try {
            // Sending a registration request to the server side
            // 发送给第三方渠道进行注册操作
            doRegister(url);
        } catch (Exception e) {
            Throwable t = e;
            // 记录日志
            // If the startup detection is opened, the Exception is thrown directly.
            boolean check = getUrl().getParameter(Constants.CHECK_KEY, true)
                    && url.getParameter(Constants.CHECK_KEY, true)
                    && !CONSUMER_PROTOCOL.equals(url.getProtocol());
            boolean skipFailback = t instanceof SkipFailbackWrapperException;
            if (check || skipFailback) {
                if (skipFailback) {
                    t = t.getCause();
                }
                throw new IllegalStateException("Failed to register " + url + " to registry " + getUrl().getAddress() + ", cause: " + t.getMessage(), t);
            } else {
                logger.error("Failed to register " + url + ", waiting for retry, cause: " + t.getMessage(), t);
            }
            // Record a failed registration request to a failed list, retry regularly
            // 后台异步进行重试，也是Failback比较关键的代码
            addFailedRegistered(url);
        }
    }
//重试代码
 private void addFailedRegistered(URL url) {
        FailedRegisteredTask oldOne = failedRegistered.get(url);
        if (oldOne != null) {
            return;
        }
        FailedRegisteredTask newTask = new FailedRegisteredTask(url, this);
        oldOne = failedRegistered.putIfAbsent(url, newTask);
        if (oldOne == null) {
            // never has a retry task. then start a new task for retry.
            retryTimer.newTimeout(newTask, retryPeriod, TimeUnit.MILLISECONDS);
        }
    }

然后跟踪doRegistry方法 进入ZookeeperRegistry类
（7）下面我们再来看看Zookeeper中 doRegister 方法的实现, 可以看到这里的实现也比较简单，关键在于 toUrlPath 方法的实现。关于 dynamic 的值，我们也在上面有看到，他的URL也是true的。

（8）解读 toUrlPath 方法。可以看到这里的实现也是比较简单，也验证了我们之前的路径规则。

private String toUrlPath(URL url) {
    // 分类地址 + url字符串
    return toCategoryPath(url) + PATH_SEPARATOR + URL.encode(url.toFullString());
}
private String toCategoryPath(URL url) {
    // 服务名称 + category(在当前的例子中是providers)
    return toServicePath(url) + PATH_SEPARATOR + url.getParameter(CATEGORY_KEY, DEFAULT_CATEGORY);
}
    private String toServicePath(URL url) {
        // 接口地址
        String name = url.getServiceInterface();
        if (ANY_VALUE.equals(name)) {
            return toRootPath();
        }
        //根节点+ 接口地址
        return toRootDir() + URL.encode(name);
    }

至此注册过程完成

3.3 URL规则详解 和 服务本地缓存

1、URL规则详解
URL地址如下：

protocol://host:port/path?key=value&key=value 
provider://192.168.20.1:20883/com.lagou.service.HelloService?anyhost=true&application=service-provider2
&bind.ip=192.168.20.1&bind.port=20883&category=configurators
&check=fals e&deprecated=false&dubbo=2.0.2&dynamic=true
&generic=false&interface=com.lagou.service

URL主要有以下几部分组成：

• protocol: 协议，一般像我们的 provider 或者 consumer 在这里都是人为具体的协议
• host: 当前 provider 或者其他协议所具体针对的地址，比较特殊的像 override 协议所指定的
• host就是 0.0.0.0 代表所有的机器都生效
• port: 和上面相同，代表所处理的端口号
• path: 服务路径，在 provider 或者 consumer 等其他中代表着我们真实的业务接口
• key=value: 这些则代表具体的参数，这里我们可以理解为对这个地址的配置。比如我们 provider中需要具体机器的服务应用名，就可以是一个配置的方式设置上去。

注意：Dubbo中的URL与java中的URL是有一些区别的，如下：

• 这里提供了针对于参数的 parameter 的增加和减少(支持动态更改)
• 提供缓存功能，对一些基础的数据做缓存.

2、服务本地缓存
在上面我们有讲到dubbo有对路径进行本地缓存操作。这里我们就对本地缓存进行讲解。
dubbo调用者需要通过注册中心（例如：ZK）注册信息，获取提供者，但是如果频繁往从ZK获取信息，肯定会存在单点故障问题，所以dubbo提供了将提供者信息缓存在本地的方法。
Dubbo在订阅注册中心的回调处理逻辑当中会保存服务提供者信息到本地缓存文件当中（同步/异步两种方式），以URL纬度进行全量保存。
Dubbo在服务引用过程中会创建registry对象并加载本地缓存文件，会优先订阅注册中心，订阅注册中心失败后会访问本地缓存文件内容获取服务提供信息。

（1）首先从构造方法讲起, 这里方法比较简单，主要用于确定需要保存的文件信息。并且从系统中读取已有的配置信息。

  public AbstractRegistry(URL url) {
        setUrl(url);
        // Start file save timer
        syncSaveFile = url.getParameter(REGISTRY_FILESAVE_SYNC_KEY, false);
         //默认保存路径(home/.dubbo/dubbo-registry-appName-address-port.cache)
        String defaultFilename = System.getProperty("user.home") + "/.dubbo/dubbo-registry-" + url.getParameter(APPLICATION_KEY) + "-" + url.getAddress().replaceAll(":", "-") + ".cache";
        String filename = url.getParameter(FILE_KEY, defaultFilename);
          // 创建文件
        File file = null;
        if (ConfigUtils.isNotEmpty(filename)) {
            file = new File(filename);
            if (!file.exists() && file.getParentFile() != null && !file.getParentFile().exists()) {
                if (!file.getParentFile().mkdirs()) {
                    throw new IllegalArgumentException("Invalid registry cache file " + file + ", cause: Failed to create directory " + file.getParentFile() + "!");
                }
            }
        }
        this.file = file;
        // When starting the subscription center,
        // we need to read the local cache file for future Registry fault tolerance processing.
         //加载已有的配置文件
        loadProperties();
        notify(url.getBackupUrls());
    }

通过跟踪代码notify(url.getBackupUrls())=>notify(url, listener, filterEmpty(url, urls))=>saveProperties(url);
（2）我们可以看到这个类中最为关键的一个属性为 properties ，我们可以通过寻找，得知这个属性的设置值只有在一个地方: saveProperties ，我们来看一下这个方法。这里也有一个我们值得关注的点，就是基于版本号的的更改。下面看saveProperties(url)方法

private void saveProperties(URL url) {
        if (file == null) {
            return;
        }
        try {
            StringBuilder buf = new StringBuilder();
            // 获取所有通知到的地址
            Map<String, List<URL>> categoryNotified = notified.get(url);
            if (categoryNotified != null) {
                for (List<URL> us : categoryNotified.values()) {
                    for (URL u : us) {
                        //多个地址拼接
                        if (buf.length() > 0) {
                            buf.append(URL_SEPARATOR);
                        }
                        buf.append(u.toFullString());
                    }
                }
            }
            // 保存数据
            properties.setProperty(url.getServiceKey(), buf.toString());
            // 保存为一个新的版本号 
            // 通过这种机制可以保证后面保存的记录，在重试的时候，不会重试之前的版本
            long version = lastCacheChanged.incrementAndGet();
            // 需要同步保存则进行保存
            if (syncSaveFile) {
                doSaveProperties(version);
            } else {
                // 否则则异步去进行处理
                registryCacheExecutor.execute(new SaveProperties(version));
            }
        } catch (Throwable t) {
            logger.warn(t.getMessage(), t);
        }
    }

（3）下面我们再来看看是如何进行保存文件的。这里的实现也比较简单，主要比较关键的代码在于利用文件级锁来保证同一时间只会有一个线程执行(跨VM的锁)。

 public void doSaveProperties(long version) {
        if (version < lastCacheChanged.get()) {
            return;
        }
        if (file == null) {
            return;
        }
        // Save
        try {
            // 使用文件级别所，来保证同一段时间只会有一个线程进行读取操作
            File lockfile = new File(file.getAbsolutePath() + ".lock");
            if (!lockfile.exists()) {
                lockfile.createNewFile();
            }
            try (RandomAccessFile raf = new RandomAccessFile(lockfile, "rw");
                 FileChannel channel = raf.getChannel()) {
                // 利用文件锁来保证并发的执行的情况下，只会有一个线程执行成功(原因在于可能是跨 VM的)
                FileLock lock = channel.tryLock();
                if (lock == null) {
                    throw new IOException("Can not lock the registry cache file " + file.getAbsolutePath() + ", ignore and retry later, maybe multi java process use the file, please config: dubbo.registry.file=xxx.properties");
                }
                // Save
                try {
                    if (!file.exists()) {
                        file.createNewFile();
                    }
                    // 将配置的文件信息保存到文件中
                    try (FileOutputStream outputFile = new FileOutputStream(file)) {
                        properties.store(outputFile, "Dubbo Registry Cache");
                    }
                } finally {
                    // 解开文件锁
                    lock.release();
                }
            }
        } catch (Throwable e) {
            // 执行出现错误时，则交给专门的线程去进行重试
            savePropertiesRetryTimes.incrementAndGet();
            if (savePropertiesRetryTimes.get() >= MAX_RETRY_TIMES_SAVE_PROPERTIES) {
                logger.warn("Failed to save registry cache file after retrying " + MAX_RETRY_TIMES_SAVE_PROPERTIES + " times, cause: " + e.getMessage(), e);
                savePropertiesRetryTimes.set(0);
                return;
            }
            if (version < lastCacheChanged.get()) {
                savePropertiesRetryTimes.set(0);
                return;
            } else {
                registryCacheExecutor.execute(new SaveProperties(lastCacheChanged.incrementAndGet()));
            }
            logger.warn("Failed to save registry cache file, will retry, cause: " + e.getMessage(), e);
        }
    }

3.4 Dubbo 消费过程分析

服务消费流程（面试下图流程需说清楚）

首先 ReferenceConfig 类的 init 方法调用 createProxy() ,期间 使用 Protocol 调用 refer 方法生成 Invoker 实例(如上图中的红色部分)，这是服务消费的关键。接下来使用ProxyFactory把 Invoker转换为客户端需要的接口(如：HelloService)。
三个对象和ServiceConfig类中一样

跟踪init方法，内部调用createProxy创建接口代理对象

跟踪进入createProxy 在方法内调用refer()生成invoker对象，此处Protocol具体逻辑有子类实现 继续跟踪

=> org.apache.dubbo.registry.integration.RegistryProtocol#refer

跟踪进入doRefer方法 在此生成Invoker对象

看一下invoker对象里内容内部的directory包含了消费者请求的所有信息

在此生成invoker对象结束

继续往下跟踪createProxy方法 在末尾处调用了getProxy方法

根据invoker里包含的接口 生成对应的代理对象。此代理对象就是进行远程服务调用的对象，默认使用的javassist进行对象代理生成

4、Dubbo扩展SPI源码剖析

SPI在之前都有使用过，其中最重要的类就是 ExtensionLoader ，它是所有Dubbo中SPI的入口。
我们通过分析源码来学习 ExtensionLoader 是怎么加载的。这里会具体介绍
org.apache.dubbo.common.extension.ExtensionLoader.getExtensionLoader 和
org.apache.dubbo.common.extension.ExtensionLoader.getExtension 方法。
getExtensionLoader 获取扩展点加载器 并加载所对应的所有的扩展点实现
getExtension 根据name 获取扩展的指定实现

4.1 getExtensionLoader 加载过程

先回顾一下dubbo中spi调用示例：
先根据类型获取ExtensionLoader,然后在获取支持的扩展点实现

public class App 
{
    public static void main( String[] args )
    {
        //获取扩展加载器
        ExtensionLoader<HelloService> extensionLoader = ExtensionLoader.getExtensionLoader(HelloService.class);
        //遍历所有支持的扩展点
        final Set<String> supportedExtensions = extensionLoader.getSupportedExtensions();
        for(String extension : supportedExtensions){
            final String s = extensionLoader.getExtension(extension).sayHello();
            System.out.println(s);
        }
    }
}

（1）是如何进行实例化 ExtensionLoader 的 加载扩展点的路径

  private static final ConcurrentMap<Class<?>, ExtensionLoader<?>> EXTENSION_LOADERS = new ConcurrentHashMap<>(64);
private static <T> boolean withExtensionAnnotation(Class<T> type) {
    // 包含`@SPI`注解在接口上 
    return type.isAnnotationPresent(SPI.class); 
} 
@SuppressWarnings("unchecked")
    public static <T> ExtensionLoader<T> getExtensionLoader(Class<T> type) {
        // 必须传入类型
        if (type == null) {
            throw new IllegalArgumentException("Extension type == null");
        }
        // 必须是接口类型
        if (!type.isInterface()) {
            throw new IllegalArgumentException("Extension type (" + type + ") is not an interface!");
        }
        // 必须包含SPI的注解
        if (!withExtensionAnnotation(type)) {
            throw new IllegalArgumentException("Extension type (" + type +
                    ") is not an extension, because it is NOT annotated with @" + SPI.class.getSimpleName() + "!");
        }
        // 尝试从已经加载过的数据中去读取(缓存功能) 此处缓存容器是ConcurrentHashMap
        ExtensionLoader<T> loader = (ExtensionLoader<T>) EXTENSION_LOADERS.get(type);
        if (loader == null) {
            // 如果没有的话，才会进行初始化，并且放入到缓存汇总  每一个接口类型都对应一个ExtensionLoader对象
            EXTENSION_LOADERS.putIfAbsent(type, new ExtensionLoader<T>(type));
            loader = (ExtensionLoader<T>) EXTENSION_LOADERS.get(type);
        }
        return loader;
    }

（2）具体看一下 ExtensionLoader 的构造器函数, 这里他的实现比较简单，并没有做太多的操作。主要是对type进行赋值操作，然后获取 ExtensionFactory 对象。

   private ExtensionLoader(Class<?> type) {
        this.type = type;
        // 这里需要对对象的工厂做额外的创建，可以看到扩展的工厂也是一个扩展点
        objectFactory = (type == ExtensionFactory.class ? null : 
                ExtensionLoader.getExtensionLoader(ExtensionFactory.class).getAdaptiveExtension());
    }

（3）具体再来关注一下 ExtensionFactory 是做什么用的, 从这里我们可以大概的看出来，他是通过传入扩展点类型和真正的名称来获取扩展的。这里就和我们SPI中的具体名称实现相挂钩。

package org.apache.dubbo.common.extension;
/**
 * ExtensionFactory
 */
@SPI
public interface ExtensionFactory {
    /**
     * Get extension.
     *根据传入的扩展点类型 和名字 来获取扩展 这里和我们SPI中的具体实现挂钩了
     * @param type object type.
     * @param name object name.
     * @return object instance.
     */
    <T> T getExtension(Class<T> type, String name);
}

（4）可以在 dubbo-common/src/main/resources/META-
INF/dubbo/internal/org.apache.dubbo.common.extension.ExtensionFactory 中看到，他默认
有两个实现的提供

adaptive=org.apache.dubbo.common.extension.factory.AdaptiveExtensionFactory
spi=org.apache.dubbo.common.extension.factory.SpiExtensionFactory

（5）可以看到在 AdaptiveExtensionFactory 中是使用 @Adaptive 标记的。这里可以通过类名基本
看出来，他其实最主要的作用是进行代理其他的ExtensionFactory。其中比较重要的方法在于getSupportedExtensions 方法，获取所有支持的扩展信息实现。

@Adaptive
public class AdaptiveExtensionFactory implements ExtensionFactory {
    private final List<ExtensionFactory> factories;
    public AdaptiveExtensionFactory() {
        // 获取针对ExtensionFactory扩展加载器
        ExtensionLoader<ExtensionFactory> loader = ExtensionLoader.getExtensionLoader(ExtensionFactory.class);
        List<ExtensionFactory> list = new ArrayList<ExtensionFactory>();
        //获取支持的扩展
        for (String name : loader.getSupportedExtensions()) {
            //对扩展进行缓存
            list.add(loader.getExtension(name));
        }
        factories = Collections.unmodifiableList(list);
    }
    @Override
    public <T> T getExtension(Class<T> type, String name) {
        for (ExtensionFactory factory : factories) {
            // 交给每个真实的ExtensionFactory来处理
            T extension = factory.getExtension(type, name);
            if (extension != null) {
                return extension;
            }
        }
        return null;
    }
}

（6）获取所有支持的扩展信息实现: ExtensionLoader.getSupportedExtensions ，这里可以看到，其实比较关键的方法在于 getExtensionClasses 方法

    public Set<String> getSupportedExtensions() {
        // 获取所有的扩展类信息
        Map<String, Class<?>> clazzes = getExtensionClasses();
        // 返回所有的扩展点名称
        return Collections.unmodifiableSet(new TreeSet<>(clazzes.keySet()));
    }

（7）观察 getExtensionClasses 的实现,可以看到这里其实主要做的就是一件事情，防止重复被加
载，所以真正的的实现还需要专门去查看 loadExtensionClasses 方法
在我们通过名称获取扩展类之前,首先需要根据配置文件解析出扩展类名称到扩展类的映射关系表
classes之后再根据扩展项名称 从映射关系表中获取取对应的扩展类即可。相关过程代码分析如下

    private Map<String, Class<?>> getExtensionClasses() {
        // 从缓存中获取已加载的扩展类
        Map<String, Class<?>> classes = cachedClasses.get();
        // 双重检查
        if (classes == null) {
            // 为空的话，则锁住，标识只会被执行一次
            synchronized (cachedClasses) {
                classes = cachedClasses.get();
                if (classes == null) {
                    // 进行加载信息 加载扩展类
                    classes = loadExtensionClasses();
                    cachedClasses.set(classes);
                }
            }
        }
        return classes;
    }

（8）观察 loadExtensionClasses 方法实现。这里主要做了两件事情。
1: 加载当前SPI的默认实现。
2:加载这个类的所有扩展点实现，并且按照name和Class对象的形式存储，下面会专门针对于cacheDefaultExtensionName 和 loadDirectory 方法做说明

观察 cacheDefaultExtensionName 方法实现。这里面的是实现比较简单，主要用于读取注解中value
值来获取到默认的名称。

    private void cacheDefaultExtensionName() {
        // 获取当前类是否包含SPI注解，一般走到这里都是拥有这个注解的
        final SPI defaultAnnotation = type.getAnnotation(SPI.class);
        if (defaultAnnotation == null) {
            return;
        }
        // 来获取其的value值，这个值主要的作用是设置这个SPI中的默认扩展名 
        // 比如LoadBalance的默认实现就是random。就是通过这里进行的设置
        String value = defaultAnnotation.value();
        if ((value = value.trim()).length() > 0) {
            String[] names = NAME_SEPARATOR.split(value);
            if (names.length > 1) {
                throw new IllegalStateException("More than 1 default extension name on extension " + type.getName()
                        + ": " + Arrays.toString(names));
            }
            if (names.length == 1) {
                cachedDefaultName = names[0];
            }
        }
    }

观察 loadDirectory 方法实现。这里的主要功能是从这个文件夹中寻找真正的文件列表，并且对其中
的文件内容解析并且放入到 extensionClasses Map中，具体解析文件的内容实现，还要参考
loadResource 实现。

  private void loadDirectory(Map<String, Class<?>> extensionClasses, String dir, String type,
                               boolean extensionLoaderClassLoaderFirst, String... excludedPackages) {
        // 文件名称规则: 路径/包名.接口名
        String fileName = dir + type;
        try {
            // 寻找classloader和url列表
            Enumeration<java.net.URL> urls = null;
            // try to load from ExtensionLoader's ClassLoader first
            // 如果需要的话, 需要先从当前类的ClassLoader中寻找
            ClassLoader classLoader = findClassLoader();
            // try to load from ExtensionLoader's ClassLoader first
            if (extensionLoaderClassLoaderFirst) {
                ClassLoader extensionLoaderClassLoader = ExtensionLoader.class.getClassLoader();
                if (ClassLoader.getSystemClassLoader() != extensionLoaderClassLoader) {
                    urls = extensionLoaderClassLoader.getResources(fileName);
                }
            }
            // 如果找不到任何的URL列表，则继续尝试去其当前线程的ClassLoader中寻找
            if(urls == null || !urls.hasMoreElements()) {
                if (classLoader != null) {
                    urls = classLoader.getResources(fileName);
                } else {
                    urls = ClassLoader.getSystemResources(fileName);
                }
            }
            // 如果存在文件的话
            if (urls != null) {
                while (urls.hasMoreElements()) {
                    // 遍历每一个资源文件，并且进行加载资源信息到extensionClasses, 主要功能 是读取文件内容
                    java.net.URL resourceURL = urls.nextElement();
                    loadResource(extensionClasses, classLoader, resourceURL, excludedPackages);
                }
            }
        } catch (Throwable t) {
            logger.error("Exception occurred when loading extension class (interface: " +
                    type + ", description file: " + fileName + ").", t);
        }
    }

（9）进行观察 loadResource 实现，主要是用于读取文件操作，并且将方法交由 loadClass 来加载类信息。加载类信息也是最重要的方法所在。

    private void loadResource(Map<String, Class<?>> extensionClasses, ClassLoader classLoader,
                              java.net.URL resourceURL, String... excludedPackages) {
        try {
            // 读取文件
            try (BufferedReader reader = new BufferedReader(new InputStreamReader(resourceURL.openStream(), StandardCharsets.UTF_8))) {
                String line;
                while ((line = reader.readLine()) != null) {
                    //#后是注释 截取文件#前面的内容
                    final int ci = line.indexOf('#');
                    if (ci >= 0) {
                        line = line.substring(0, ci);
                    }
                    line = line.trim();
                    // 如果有内容的话
                    if (line.length() > 0) {
                        try {
                            // 则进行加载key=value的形式数据
                            String name = null;
                            int i = line.indexOf('=');
                            if (i > 0) {
                                name = line.substring(0, i).trim();
                                line = line.substring(i + 1).trim();
                            }
                            if (line.length() > 0 && !isExcluded(line, excludedPackages)) {
                                // 对类信息进行加载操作
                                loadClass(extensionClasses, resourceURL, Class.forName(line, true, classLoader), name);
                            }
                        } catch (Throwable t) {
                            IllegalStateException e = new IllegalStateException("Failed to load extension class (interface: " + type + ", class line: " + line + ") in " + resourceURL + ", cause: " + t.getMessage(), t);
                            exceptions.put(line, e);
                        }
                    }
                }
            }
        } catch (Throwable t) {
            logger.error("Exception occurred when loading extension class (interface: " +
                    type + ", class file: " + resourceURL + ") in " + resourceURL, t);
        }
    }

（10）观察 loadClass 类的实现，可以看到这里是最终进行完成类映射的地方。关于Adaptive中的类
实现原理，我们放在这个章节中的偏后面进行细讲。

private void loadClass(Map<String, Class<?>> extensionClasses, java.net.URL resourceURL, Class<?> clazz, String name) throws NoSuchMethodException {
        // 当前扩展点的实现，必须是当前扩展接口的实现才可以
        if (!type.isAssignableFrom(clazz)) {
            throw new IllegalStateException("Error occurred when loading extension class (interface: " +
                    type + ", class line: " + clazz.getName() + "), class "
                    + clazz.getName() + " is not subtype of interface.");
        }
        // 如果是包含了Adaptive注解，则认为是需要对扩展点包装的方法，这里只做了存储操作，存储至 cachedAdaptiveClass中
        if (clazz.isAnnotationPresent(Adaptive.class)) {
            cacheAdaptiveClass(clazz);
        } else if (isWrapperClass(clazz)) {
            // 判断是否是wapper类型, 是否构造函数中有该接口类型的传入
            // wrapper类型的意思是，对当前的扩展点实现封装功能处理
            cacheWrapperClass(clazz);
        } else {
            clazz.getConstructor();
            // 寻找他是否已经定义过了名称, 这里就不继续往里面细看了,主要是获取当前类的
            // org.apache.dubbo.common.Extension注解，如果有的话就使用这个名称，否则的话就是用当前类的 简单名称
            if (StringUtils.isEmpty(name)) {
                name = findAnnotationName(clazz);
                if (name.length() == 0) {
                    throw new IllegalStateException("No such extension name for the class " + clazz.getName() + " in the config " + resourceURL);
                }
            }
            // 否则的话，就对这个名称和class做映射关系
            String[] names = NAME_SEPARATOR.split(name);
            if (ArrayUtils.isNotEmpty(names)) {
                // 如果当前类拥有Activate注解，则将其进行添加到cachedActivates对象中，意味 着需要执行
                cacheActivateClass(clazz, names[0]);
                // 进行名称映射保存
                for (String n : names) {
                    cacheName(clazz, n);
                    saveInExtensionClass(extensionClasses, clazz, n);
                }
            }
        }
    }

当执行完这几个方法之后，会对一下几个字段进行更新:

• cachedAdaptiveClass: 当前Extension类型对应的AdaptiveExtension类型(只能一个)
• cachedWrapperClasses: 当前Extension类型对应的所有Wrapper实现类型(无顺序)
• cachedActivates: 当前Extension实现自动激活实现缓存(map,无序)
• cachedNames: 扩展点实现类对应的名称(如配置多个名称则值为第一个)

4.2 根据name获取扩展点的方法 getExtension

（1） getExtension 方法实现。这里面同样主要作用是根据name对扩展点进行处理和进行加锁来创建真实的引用，其中都是有使用缓存来处理。

    public T getExtension(String name) {
        if (StringUtils.isEmpty(name)) {
            throw new IllegalArgumentException("Extension name == null");
        }
        // 获取当前SPi的默认扩展实现类
        if ("true".equals(name)) {
            return getDefaultExtension();
        }
        // 获取当前类的holder，实现原理和cachedClasses的方式相同，都是建立同一个引用后再进行 加锁
        final Holder<Object> holder = getOrCreateHolder(name);
        Object instance = holder.get();
        if (instance == null) {
            synchronized (holder) {
                instance = holder.get();
                if (instance == null) {
                    //进行真正的实例创建
                    instance = createExtension(name);
                    holder.set(instance);
                }
            }
        }
        return (T) instance;
    }

holder结构：

（2）下面来看看 getOrCreateHolder 是如何保证缓存的。

    private Holder<Object> getOrCreateHolder(String name) {
        // 获取当前名称的和对象Holder的映射关系
        Holder<Object> holder = cachedInstances.get(name);
        if (holder == null) {
            // 如果不存在的话，则使用putIfAbsent的原子操作来设置值，
            // 这个值可以保证多线程的额情 况下有值的时候不处理，没有值进行保存
            cachedInstances.putIfAbsent(name, new Holder<>());
            // 获取真实的holder处理器
            holder = cachedInstances.get(name);
        }
        return holder;
    }

（3）然后我们再来看看 createExtension 的实现，他是具体根据扩展的class名称来进行创建实例的
类。这里也是创建扩展点类的主要实现。下面我们也对其他扩展点注册的方法做说明。

private T createExtension(String name) {
        // 从配置文件中加载所有的扩展类 可以得到配置项名称 到配置类的映射关系
        Class<?> clazz = getExtensionClasses().get(name);
        if (clazz == null) {
            throw findException(name);
        }
        try {
            // 获取是否已经有实例了
            T instance = (T) EXTENSION_INSTANCES.get(clazz);
            if (instance == null) {
                // 没有的话，同样适用putIfAbsent的方式来保证只会创建一个对象并且保存
                EXTENSION_INSTANCES.putIfAbsent(clazz, clazz.newInstance());
                instance = (T) EXTENSION_INSTANCES.get(clazz);
            }
            // 注入其他扩展点的实体，用于扩展点和其他的扩展点相互打通
            injectExtension(instance);
            // 进行遍历所有的包装类信息，分别对包装的类进行包装实例化，并且返回自身引用
            Set<Class<?>> wrapperClasses = cachedWrapperClasses;
            if (CollectionUtils.isNotEmpty(wrapperClasses)) {
                for (Class<?> wrapperClass : wrapperClasses) {
                    instance = injectExtension((T) wrapperClass.getConstructor(type).newInstance(instance));
                }
            }
            initExtension(instance);
            return instance;
        } catch (Throwable t) {
            throw new IllegalStateException("Extension instance (name: " + name + ", class: " +
                    type + ") couldn't be instantiated: " + t.getMessage(), t);
        }
    }

（4） injectExtension 方法观察 此方法是将当前创建的扩展点实例中所需要注入的其他扩展点注入进来

private T injectExtension(T instance) {
        if (objectFactory == null) {
            return instance;
        }
        try {
            // 遍历其中的所有方法
            for (Method method : instance.getClass().getMethods()) {
                // 是否是set方法
                // 1. 以"set"开头
                // 2. 参数长度为1
                // 3. 是公开的方法
                if (!isSetter(method)) {
                    continue;
                }
                /**
                 * Check {@link DisableInject} to see if we need auto injection for this property
                 */
                // 如果设置了取消注册，则不进行处理
                if (method.getAnnotation(DisableInject.class) != null) {
                    continue;
                }
                // 获取参数类型，并且非基础类型(String, Integer等类型)
                Class<?> pt = method.getParameterTypes()[0];
                if (ReflectUtils.isPrimitives(pt)) {
                    continue;
                }
                try {
                    // 获取需要set的扩展点名称
                    String property = getSetterProperty(method);
                    // 从ExtensionLoader中加载指定的扩展点
                    // 比如有一个方法为setRandom(LoadBalance loadBalance)，那么则以为着需 要加载负载均衡中名为random的扩展点
                    Object object = objectFactory.getExtension(pt, property);
                    if (object != null) {
                        method.invoke(instance, object);
                    }
                } catch (Exception e) {
                    logger.error("Failed to inject via method " + method.getName()
                            + " of interface " + type.getName() + ": " + e.getMessage(), e);
                }
            }
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
        }
        return instance;
    }

4.3 Adaptive功能实现原理

Adaptive的主要功能是对所有的扩展点进行封装为一个类，通过URL传入参数的时动态选择需要使用的
扩展点。其底层的实现原理就是动态代理，这里我们会通过源码的形式告诉大家，他是如何通过动态代
理进行加载的。
先来看一下Adaptive示例：

URL url = URL.valueOf("test://localhost/hello?hello.service=human");
final HelloService adaptiveExtension = ExtensionLoader.getExtensionLoader(HelloService.class).getAdaptiveExtension();
String s = adaptiveExtension.sayHello(url);
System.out.println(s);

（1）这里我们 getAdaptiveExtension 方法讲起，这个里面就是真正获取该类。这里可以看到，
ExtentionLoader 中大量的使用了Holder和加锁的方式去进行唯一创建。

    public T getAdaptiveExtension() {
        // 和原先是用相同的方式，进行Holder和加锁的方式来保证只会被创建一次
        Object instance = cachedAdaptiveInstance.get();
        if (instance == null) {
            // 如果直接已经有创建并且错误的情况，则直接返回错误信息，防止重复没必要的创建
            if (createAdaptiveInstanceError != null) {
                throw new IllegalStateException("Failed to create adaptive instance: " +
                        createAdaptiveInstanceError.toString(),
                        createAdaptiveInstanceError);
            }
            synchronized (cachedAdaptiveInstance) {
                instance = cachedAdaptiveInstance.get();
                if (instance == null) {
                    try {
                        // 这里真实的进行创建操作
                        instance = createAdaptiveExtension();
                        cachedAdaptiveInstance.set(instance);
                    } catch (Throwable t) {
                        createAdaptiveInstanceError = t;
                        throw new IllegalStateException("Failed to create adaptive instance: " + t.toString(), t);
                    }
                }
            }
        }
        return (T) instance;
    }

（2）这里我们继续从 createAdaptiveExtension 来去查看实现。这里主要是进行了一些方法封装。

 private T createAdaptiveExtension() {
        try {
            // 这里使用`getAdaptiveExtensionClass`方法进行构建类并且执行实例化
            // 然后和普通的其他class相同，依旧使用injectExtension进行扩展
            return injectExtension((T) getAdaptiveExtensionClass().newInstance());
        } catch (Exception e) {
            throw new IllegalStateException("Can't create adaptive extension " + type + ", cause: " + e.getMessage(), e);
        }
    }
    private Class<?> getAdaptiveExtensionClass() {
        // 确保已经加载了所有的扩展类信息
        getExtensionClasses();
        // 如果已经加载过了，则直接返回
        if (cachedAdaptiveClass != null) {
            return cachedAdaptiveClass;
        }
        // 否则进行构建操作
        return cachedAdaptiveClass = createAdaptiveExtensionClass();

（3）具体再来看 createAdaptiveExtensionClass 方法。这里主要是进行生成Adaptive的代码，并且
进行编译生成class。

    private T createAdaptiveExtension() {
        try {
            // 这里使用`getAdaptiveExtensionClass`方法进行构建类并且执行实例化
            // 然后和普通的其他class相同，依旧使用injectExtension进行扩展
            return injectExtension((T) getAdaptiveExtensionClass().newInstance());
        } catch (Exception e) {
            throw new IllegalStateException("Can't create adaptive extension " + type + ", cause: " + e.getMessage(), e);
        }
    }
    private Class<?> getAdaptiveExtensionClass() {
        // 确保已经加载了所有的扩展类信息
        getExtensionClasses();
        // 如果已经加载过了，则直接返回
        if (cachedAdaptiveClass != null) {
            return cachedAdaptiveClass;
        }
        // 否则进行构建操作
        return cachedAdaptiveClass = createAdaptiveExtensionClass();
    }

（3）具体再来看 createAdaptiveExtensionClass 方法。这里主要是进行生成Adaptive的代码，并且
进行编译生成class。

    private Class<?> createAdaptiveExtensionClass() {
        // 实例化一个新的Adaptive的代码生成器，并且进行代码生成
        String code = new AdaptiveClassCodeGenerator(type, cachedDefaultName).generate();
        // 获取类加载器
        ClassLoader classLoader = findClassLoader();
        // 通过扩展点，寻找编译器, 目前有Java自带的编译器和Javassist的编译器，这里不做细展开
        org.apache.dubbo.common.compiler.Compiler compiler = ExtensionLoader.getExtensionLoader(org.apache.dubbo.common.compiler.Compiler.class).getAdaptiveExtension();
        // 编译并且生成class
        return compiler.compile(code, classLoader);
    }

（4）具体通过 AdaptiveClassLoaderCodeGenerator.generate 方法来进行实现真正的代码生成。

 public String generate() {
        // no need to generate adaptive class since there's no adaptive method found.
        // 如果没有任何方法标记为Adaptive，则不做处理
        if (!hasAdaptiveMethod()) {
            throw new IllegalStateException("No adaptive method exist on extension " + type.getName() + ", refuse to create the adaptive class!");
        }
        // 进行编写代码
        StringBuilder code = new StringBuilder();
        // 生成包信息
        code.append(generatePackageInfo());
        // 生成引用信息
        code.append(generateImports());
        // 生成类声明
        code.append(generateClassDeclaration());
        // 生成每一个方法
        Method[] methods = type.getMethods();
        for (Method method : methods) {
            code.append(generateMethod(method));
        }
        // 输出最后的一个"}"来结束当前类
        code.append("}");
        if (logger.isDebugEnabled()) {
            logger.debug(code.toString());
        }
        return code.toString();
    }

（5）这里主要对其中的每一个方法来做处理。具体主要观看 generateMethod 方法。这里的很多方法
主要是依赖反射机制去进行方法封装，最终拼接为一个最终字符串。其中最关键的方法在于
generateMethodContent 方法来生成代理功能。

   private String generateMethod(Method method) {
        // 方法返回类型
        String methodReturnType = method.getReturnType().getCanonicalName();
        // 方法名称
        String methodName = method.getName();
        // 生成方法内容
        String methodContent = generateMethodContent(method);
        // 生成参数列表
        String methodArgs = generateMethodArguments(method);
        // 方法抛出的异常
        String methodThrows = generateMethodThrows(method);
        // 格式化为一个字符串
        // public %s %s(%s) %s {
        // %s
        //}
        return String.format(CODE_METHOD_DECLARATION, methodReturnType, methodName, methodArgs, methodThrows, methodContent);
    }

（6） generateMethodContent 方法解读。这块儿更推荐通过debug的形式走进来, 看代码也更直接了
当(就可以直接按照常用功能中的SPI章节来debug)。这部分也是整个Adaptive中最为核心的代码，包括
获取扩展点名称并且执行。

    private String generateMethodContent(Method method) {
        // 获取Adaptive注解，只支持含有Adaptive注解方法处理
        Adaptive adaptiveAnnotation = method.getAnnotation(Adaptive.class);
        StringBuilder code = new StringBuilder(512);
        // 没有该注解，直接抛出异常
        // throw new UnsupportedOperationException
        if (adaptiveAnnotation == null) {
            return generateUnsupported(method);
        } else {
            // 获取URL参数的所在位置
            int urlTypeIndex = getUrlTypeIndex(method);
            // found parameter in URL type
            if (urlTypeIndex != -1) {
                // Null Point check
                // 增加判断url不为空的代码
                code.append(generateUrlNullCheck(urlTypeIndex));
            } else {
                // did not find parameter in URL type
                // 获取这个方法中的所有参数列表
                // 寻找每个参数中是否有"get"开头的方法，并且返回值是URL的
                // 如果有则同样认定为找到，否则抛出异常
                code.append(generateUrlAssignmentIndirectly(method));
            }
            // 获取扩展点的适配名称
            String[] value = getMethodAdaptiveValue(adaptiveAnnotation);
            // 判断是否有参数是Invocation类
            // 这里判断的主要目的在于，拥有Invocation时，则获取扩展名称的方式发生改变
            // 存在Invocation时，通过getMethodParameter，否则通过getParameter来执行
            // getMethodParameter是dubboURL中特有的，用于将"test.a"转换为"testA"的形式
            boolean hasInvocation = hasInvocationArgument(method);
            // 增加有Invocation类时的不为空判断
            code.append(generateInvocationArgumentNullCheck(method));
            // 生成获取扩展点名称的方法
            code.append(generateExtNameAssignment(value, hasInvocation));
            // check extName == null?
            // 检查扩展点不能为空
            code.append(generateExtNameNullCheck(value));
            // 获取扩展点实现
            code.append(generateExtensionAssignment());
            // return statement
            // 返回扩展点中的真实调用
            code.append(generateReturnAndInvocation(method));
        }
        return code.toString();
    }

跟踪示例代码可以看出它是按照请求URL动态生成代理类代码 然后调用编译器进行编译获取字节码文件 从而获取代理对象，此代理对象内部生成了对应的按照名称获取不同扩展点实现的方法。这就是Adaptive功能的核心实现逻辑

5、集群容错源码剖析

在对集群相关代码进行分析之前，这里有必要先来介绍一下集群容错的所有组件。包含 Cluster、
Cluster Invoker、Directory、Router 和 LoadBalance 等。
（下图需记住）

集群工作过程可分为两个阶段，
第一个阶段是在服务消费者初始化期间，集群 Cluster 实现类为服务消费者创建 Cluster Invoker 实例，即上图中的 merge 操作。
第二个阶段是在服务消费者进行远程调用
时。以 FailoverClusterInvoker 为例，该类型 Cluster Invoker 首先会调用 Directory 的 list 方法列举
Invoker 列表（可将 Invoker 简单理解为服务提供者）。Directory 的用途是保存 Invoker列表，可简单
类比为 List。其实现类 RegistryDirectory 是一个动态服务目录，可感知注册中心配置的变化，它所持
有的 Invoker 列表会随着注册中心内容的变化而变化。每次变化后，RegistryDirectory 会动态增删
Invoker，并调用 Router 的 route 方法进行路由，过滤掉不符合路由规则的 Invoker。当
FailoverClusterInvoker 拿到 Directory 返回的 Invoker 列表后，它会通过 LoadBalance 从 Invoker 列
表中选择一个 Invoker。最后 FailoverClusterInvoker 会将参数传给 LoadBalance 选择出的 Invoker
实例的 invoke 方法，进行真正的远程调用。

Dubbo 主要提供了这样几种容错方式：

• Failover Cluster - 失败自动切换 失败时会重试其它服务器
• Failfast Cluster - 快速失败 请求失败后快速返回异常结果 不重试
• Failsafe Cluster - 失败安全 出现异常 直接忽略 会对请求做负载均衡
• Failback Cluster - 失败自动恢复 请求失败后 会自动记录请求到失败队列中
• Forking Cluster - 并行调用多个服务提供者 其中有一个返回 则立即返回结果

5.1 信息缓存接口Directory

Directory是Dubbo中的一个接口，主要用于缓存当前可以被调用的提供者列表信息。我们在消费者进行调用时都会通过这个接口来获取所有的提供者列表，再进行后续处理。
（1）我们先来看看 Directory 接口，这里比较简单，我们可以通过 Directory 来找到指定服务中的提供者信息列表。

public interface Directory<T> extends Node {
    /**
     * get service type.
     * 获取服务的类型,也就是我们demo中所使用的HelloService
     * @return service type.
     */
    Class<T> getInterface();
    /**
     * list invokers.
     *根据本次调用的信息来获取所有可以被执行的提供者信息
     * @return invokers
     */
    List<Invoker<T>> list(Invocation invocation) throws RpcException;
    //获取所有的提供者信息
    List<Invoker<T>> getAllInvokers();
    URL getConsumerUrl();
}

（2） Directory 中有一个基础的实现类，主要是对一些通用的方法封装，主要还是依靠真正的实现。
其中可以看看 AbstractDirectory中的list 方法。通过这个方式我们能知道，真正实现还是依靠于真
正子类汇总的 doList 方法。

public abstract class AbstractDirectory<T> implements Directory<T> {
    @Override
    public List<Invoker<T>> list(Invocation invocation) throws RpcException {
        if (destroyed) {
            throw new RpcException("Directory already destroyed .url: " + getUrl());
        }
        // 交给子类进行处理
        return doList(invocation);
    }
    //抽象类
    protected abstract List<Invoker<T>> doList(Invocation invocation) throws RpcException;
}

（3）我们可以继续往下看，他的实现子类是 RegistryDirectory#doList 方法。我们可以看到这里的
实现也相对比较简单，主要依靠routerChain去决定真实返回的提供者列表。

   @Override
    public List<Invoker<T>> doList(Invocation invocation) {
        if (forbidden) {
            // 当没有提供者的时候会直接抛出异常
            // 1. No service provider 2. Service providers are disabled
            throw new RpcException(RpcException.FORBIDDEN_EXCEPTION, "No provider available from registry " +
                    getUrl().getAddress() + " for service " + getConsumerUrl().getServiceKey() + " on consumer " +
                    NetUtils.getLocalHost() + " use dubbo version " + Version.getVersion() +
                    ", please check status of providers(disabled, not registered or in blacklist).");
        }
        if (multiGroup) {
            return this.invokers == null ? Collections.emptyList() : this.invokers;
        }
        List<Invoker<T>> invokers = null;
        try {
            // Get invokers from cache, only runtime routers will be executed.
            // 交给路由chain去处理并且获取所有的invokers
            invokers = routerChain.route(getConsumerUrl(), invocation);
        } catch (Throwable t) {
            logger.error("Failed to execute router: " + getUrl() + ", cause: " + t.getMessage(), t);
        }
        return invokers == null ? Collections.emptyList() : invokers;
    }

（4）路由是如何获取Invoker 列表的呢? 我们观察这个方法: RegistryProtocol.refer ,这里面也是
Invoker 生成的部分关键代码。 这部分代码在上节服务消费过程中已有体现

    @Override
    @SuppressWarnings("unchecked")
    public <T> Invoker<T> refer(Class<T> type, URL url) throws RpcException {
        // 获取注册中心的地址URL(主要用于转换协议)，比如我们是使用的zookeeper，那么他就会转换 为zookeeper://
        url = getRegistryUrl(url);
        // 获取注册中心配置信息
        Registry registry = registryFactory.getRegistry(url);
        if (RegistryService.class.equals(type)) {
            return proxyFactory.getInvoker((T) registry, type, url);
        }
        // 适用于多个分组时使用
        // group="a,b" or group="*"
        Map<String, String> qs = StringUtils.parseQueryString(url.getParameterAndDecoded(REFER_KEY));
        String group = qs.get(GROUP_KEY);
        if (group != null && group.length() > 0) {
            if ((COMMA_SPLIT_PATTERN.split(group)).length > 1 || "*".equals(group)) {
                return doRefer(getMergeableCluster(), registry, type, url);
            }
        }
        // 真正进行构建invoker和我们上面的Directory
        return doRefer(cluster, registry, type, url);
    }