dubbo 自适应SPI机制源码分析

朱雀 2023-02-18 14:20 35阅读 0赞

在之前博客中，我们介绍了JAVA SPI 以及 Dubbo  SPI 的基本使用以及源码分析，通过指定扩展点类型，可以创建扩展点的实现类，但是在dubbo中，有些时候并不期望直接创建出一个具体的扩展点实现，而是期望创建出一个未知类型的扩展点实现，在调用这个未知类型扩展点的扩展方法时，通过参数判断具体创建哪个类型的扩展点实现，然后在执行具体方法，看起来有些绕，请看接下来的具体使用。

简单来说就是

Animal接口有2个实现扩展点实现：dog和cat两个实现类，能不能根据实际情况动态传入参数并选择调用哪个方法呢，这个思想类似于工厂模式+策略模式 ，那dubbo如何动态确定使用的是哪个扩展点呢？

Dubbo提出了一种思路，可以通过在运行期动态生成一个 *自适应扩展点实现类* 来要解决上面的问题：

*  首先需要确定扩展点中哪些方法需要调用不同的扩展点实现，可以通过`@Adaptive`注解来标注需要生成自适应扩展点实现的类和方法。
 *  其次增加使用具体扩展点实现的条件，可以通过参数 **URL** 来指定。URL 包括协议、权限信息、参数等一系列信息。

同样我们先直接上代码 看下效果

在扩展点接口中新增加一个say(Url url)接口，并标注@Adaptive注解，Url是Dubbo的总线，我们dubbo就是通过获取url中的属性，来决定加载哪一个具体的SPI实现，url中的参数是key-value对，@Adaptive后面的type(根据自己的需要进行调整)表示获取url中key为type的value值。

package org.alexsotob.dubbo.SPI;
    
    import com.alibaba.dubbo.common.URL;
    import com.alibaba.dubbo.common.extension.Adaptive;
    import com.alibaba.dubbo.common.extension.SPI;
    
    @SPI
    public interface Animal {
    
        String getName();
    
        @Adaptive("type")
        void say(URL url);
    
    }

实现类

package org.alexsotob.dubbo.SPI.impl;
    
    import com.alibaba.dubbo.common.URL;
    import org.alexsotob.dubbo.SPI.Animal;
    
    public class Cat implements Animal {
        public Cat() {
            System.out.println("cat init !!!");
        }
    
        @Override
        public String getName() {
            return "I am cat";
        }
    
        @Override
        public void say(URL url) {
            System.out.println("喵喵喵~~~");
        }
    
    
    }

package org.alexsotob.dubbo.SPI.impl;
    
    import com.alibaba.dubbo.common.URL;
    import org.alexsotob.dubbo.SPI.Animal;
    
    public class Dog implements Animal {
        public Dog() {
            System.out.println("dog init !!!");
        }
    
        @Override
        public String getName() {
            return "I am dog";
        }
        @Override
        public void say(URL url) {
            System.out.println("汪汪汪~~~");
        }
    }

指定dubbo加载类

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbmd4dWVsZWkwMzY_size_16_color_FFFFFF_t_70][]

测试

package org.alexsotob.dubbo.SPI;
    
    import com.alibaba.dubbo.common.URL;
    import com.alibaba.dubbo.common.extension.ExtensionLoader;
    
    import java.util.HashMap;
    import java.util.Map;
    
    public class DubboSPITest {
    
        public static void main(String[] args) {
            ExtensionLoader<Animal> extensionLoader = ExtensionLoader.getExtensionLoader(Animal.class);        //按需获取实现类对象
            Animal animal = extensionLoader.getAdaptiveExtension();
            Map<String,String> map = new HashMap<String,String>();
            map.put("type","dog");
            URL url = new URL("","",1,map);
            animal.say(url);
            System.out.println("#################分割线#####################");
            map.put("type","cat");
            url = new URL("","",1,map);
            animal.say(url);
        }
    
    }

结果如下

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbmd4dWVsZWkwMzY_size_16_color_FFFFFF_t_70 1][]

正如介绍中所说，自适应扩展点，是指创建除了一个不确定类型的扩展点，通过extensionLoader.getAdaptiveExtension()，该方法我们并没有指定类型，我们构建了url参数，在url中执行了dog类型，因此最终通过自适应扩展点执行speak(url)方法时，加载了Dog扩展点，并执行，这和之前的用法比起来，我们将具体SPI实现类的加载时机，从创建阶段推迟到了方法的执行阶段，属于懒加载的一种实现思路。同时这里我们可以看到根据我们不同的输入信息，调用了不同的实现类，**整体思想就是“工厂模式+策略模式+懒加载+单例+配置文件”**

大致看下具体的执行流程：

![20181222225300570][]

接下来我们将从源码的角度分析下如何进行的实现：

1.通过ExtensionLoader.getAdaptiveExtension()方法获得扩展点的是自适应实现类，使用cachedAdaptiveInstance 缓存实例对象。因为我们使用静态工厂来创建单一实例对象ExtensionLoader，所以需要使用volatile修饰实例对象以保证线程安全性。

// 创建两个缓存，一个保存创建成功的自适应扩展点实现类，一个保存失败后的异常信息，
    private final Holder<Object> cachedAdaptiveInstance = new Holder<Object> ();
    private volatile Throwable createAdaptiveInstanceError = null;
    
    @SuppressWarnings("unchecked")
    public T getAdaptiveExtension() {   
        // 查找实例
        Object instance = cachedAdaptiveInstance.get ();
        if (instance == null) {
            // 创建异常缓存，避免失败后重复创建，浪费系统资源
            if (createAdaptiveInstanceError == null) {
                synchronized (cachedAdaptiveInstance) {
                    instance = cachedAdaptiveInstance.get ();
                    if (instance == null) {
                        try {
                            // 实例对象为空，则新增createAdaptiveExtension()
                            instance = createAdaptiveExtension ();                    
                            cachedAdaptiveInstance.set (instance);
                        } catch (Throwable t) {
                            // 捕获异常，将异常添加到缓存；再抛出,防止吞掉异常
                            createAdaptiveInstanceError = t;
                            throw new IllegalStateException ("fail to create adaptive instance: " + t.toString (), t);
                        }
                    }
                }
            } else {
                throw new IllegalStateException ("fail to create adaptive instance: " + createAdaptiveInstanceError.toString (), createAdaptiveInstanceError);
            }
        }
    
        return (T) instance;
    }

2.getAdaptiveExtension 方法首先会检查缓存，缓存未命中，则调用 createAdaptiveExtension 方法创建自适应拓展。下面，我们看一下 createAdaptiveExtension 方法的代码。

private T createAdaptiveExtension() {
        try {
            // 获取自适应拓展类，并通过反射实例化
            return injectExtension((T) getAdaptiveExtensionClass().newInstance());
        } catch (Exception e) {
            throw new IllegalStateException("Can not create adaptive extension ...");
        }
    }

createAdaptiveExtension 方法的代码比较少，但却包含了三个逻辑，分别如下：

1）调用 getAdaptiveExtensionClass 方法获取自适应拓展 Class  
  2）对象通过反射进行实例化  
  3）调用 injectExtension 方法向拓展实例中注入依赖  
  前两个逻辑比较好理解，第三个逻辑用于向自适应拓展对象中注入依赖。这个逻辑看似多余，但有存在的必要，这里简单说明一下。前面说过，Dubbo 中有两种类型的自适应拓展，一种是手工编码的，一种是自动生成的。手工编码的自适应拓展中可能存在着一些依赖，而自动生成的 Adaptive 拓展则不会依赖其他类。这里调用 injectExtension 方法的目的是为手工编码的自适应拓展注入依赖，这一点需要大家注意一下。

3.接下来调用`getAdaptiveExtensionClass`方法生成扩展类代码：

private Class<?> getAdaptiveExtensionClass() {
        // 通过 SPI 获取所有的拓展类
        getExtensionClasses();
        // 检查缓存，若缓存不为空，则直接返回缓存
        if (cachedAdaptiveClass != null) {
            return cachedAdaptiveClass;
        }
        // 创建自适应拓展类
        return cachedAdaptiveClass = createAdaptiveExtensionClass();
    }

getAdaptiveExtensionClass 方法同样包含了三个逻辑，如下：

1）调用 getExtensionClasses 获取所有的拓展类  
  2）检查缓存，若缓存不为空，则返回缓存  
  3）若缓存为空，则调用 createAdaptiveExtensionClass 创建自适应拓展类  
  首先从第一个逻辑说起，getExtensionClasses 这个方法用于获取某个接口的所有实现类。比如该方法可以获取 Protocol 接口的 DubboProtocol、HttpProtocol、InjvmProtocol 等实现类。在获取实现类的过程中，如果某个实现类被 Adaptive 注解修饰了，那么该类就会被赋值给 cachedAdaptiveClass 变量。此时，上面步骤中的第二步条件成立（缓存不为空），直接返回 cachedAdaptiveClass 即可。如果所有的实现类均未被 Adaptive 注解修饰，那么执行第三步逻辑，创建自适应拓展类。

这里包含两种情况，一种是直接拿cachedAdaptiveClass里对象，一种通过createAdaptiveExtensionClass生成。那么cachedAdaptiveClass中的值是什么呢？

之前文章有介绍过在类上面的@Adaptive注解，在getExtensionClasses方法中，如果遇到类上面有@Adaptive注解的，将该类放入cachedAdaptiveClass。

其中`loadClass`会把扩展实现类中有`@Adaptive`注解的类放入`cachedAdaptiveClass`。这样`getAdaptiveExtensionClass`时会直接获取。

![20181222225300588][]

简单回顾下代码

private void loadClass(Map<String, Class<?>> extensionClasses, Class<?> clazz, String name) {
        // 判断是类上是否有Adaptive注解，如果包含Adaptive注解，则加入cachedAdaptiveClass缓存
        // Dubbo 目前只有两个扩展点使用类上Adaptive注解，Compile 和 ExtensionFactory
        if (clazz.isAnnotationPresent (Adaptive.class)) {
            if (cachedAdaptiveClass == null) {
                cachedAdaptiveClass = clazz;
            } else {
                // 判断唯一性
                if (cachedAdaptiveClass != clazz) {
                    throw new IllegalStateException (" adaptiveClass is redundance : " + cachedAdaptiveClass.getClass ().getName ());
                }
            }
        } else{
            extensionClasses.put (name, clazz); 
        }
    }

如果`cachedAdaptiveClass`为`null`，那么需要通过`createAdaptiveExtensionClass`来生成自适应扩展点实现类：

private Class<?> createAdaptiveExtensionClass() {
        // 构建自适应拓展代码
        String code = createAdaptiveExtensionClassCode();
        ClassLoader classLoader = findClassLoader();
        // 获取编译器实现类
        com.alibaba.dubbo.common.compiler.Compiler compiler = ExtensionLoader.getExtensionLoader(com.alibaba.dubbo.common.compiler.Compiler.class).getAdaptiveExtension();
        // 编译代码，生成 Class
        return compiler.compile(code, classLoader);
    }

createAdaptiveExtensionClass 方法用于生成自适应拓展类，该方法首先会生成自适应拓展类的源码，然后通过 Compiler 实例（Dubbo 默认使用 javassist 作为编译器）编译源码，得到代理类 Class 实例。

`Compiler`也是一个扩展点，用来生成自适应扩展点**Class**类对象：

@SPI("javassist")
    public interface Compiler {
        Class<?> compile(String code, ClassLoader classLoader);
    }

他默认的自适应扩展点实现类`AdaptiveCompiler`，根据第三步可知，该实现类会放入`cachedAdaptiveClass`中，在调用`getAdaptiveExtension`时，返回该实现类：

// 代理模式，该类的compile方法实际上执行Compile默认扩展点实现类
    // JavassistCompiler的Compile方法
    @Adaptive
    public class AdaptiveCompiler implements Compiler {
        //
        @Override
        public Class<?> compile(String code, ClassLoader classLoader) {
            Compiler compiler;
            ExtensionLoader<Compiler> loader = ExtensionLoader.getExtensionLoader (Compiler.class);
            compiler = loader.getDefaultExtension ();
            return compiler.compile (code, classLoader);
        }
    }

`createAdaptiveExtensionClass`方法最后`compiler.compile (code, classLoader);`实际上为调用`JavassistCompiler`的`Complie`方法。

看一下Compile扩展点的类图：

![20181222225300606][]

`Compile`作为一个扩展点，为了符合框架中对自适应扩展点的统一调用规范，使用注解在`AdaptiveCompiler`类上，并使用委托代理模式，实际调用为Compile扩展点的默认实现类`JavassistCompiler`的Compile方法。

接下来我们继续看自适应拓展类代码生成

createAdaptiveExtensionClassCode 方法代码略多，约有两百行代码。因此本节将会对该方法的代码进行拆分分析，以帮助大家更好的理解代码逻辑。

这里看一个生成的代理类

//
    // Source code recreated from a .class file by IntelliJ IDEA
    // (powered by Fernflower decompiler)
    //
    
    package org.alexsotob.dubbo.SPI;
    
    import com.alibaba.dubbo.common.URL;
    import com.alibaba.dubbo.common.extension.ExtensionLoader;
    
    public class Animal$Adaptive implements Animal {
        public Animal$Adaptive() {
        }
    
        public String getName() {
            throw new UnsupportedOperationException("method public abstract java.lang.String org.alexsotob.dubbo.SPI.Animal.getName() of interface org.alexsotob.dubbo.SPI.Animal is not adaptive method!");
        }
    
        public void say(URL var1) {
            if (var1 == null) {
                throw new IllegalArgumentException("url == null");
            } else {
                String var3 = var1.getParameter("type");
                if (var3 == null) {
                    throw new IllegalStateException("Fail to get extension(org.alexsotob.dubbo.SPI.Animal) name from url(" + var1.toString() + ") use keys([type])");
                } else {
                    Animal var4 = (Animal)ExtensionLoader.getExtensionLoader(Animal.class).getExtension(var3);
                    var4.say(var1);
                }
            }
        }
    }

在Animal$Adaptive中：

say()：根据注解@Adaptive(\{"type"\})中的type，然后获取URL参数中的对应值也就是扩展点实现类别名，获取该实现类并调用say方法。

就是根据相应的Key字段动态进行策略调用

在生成代理类源码之前，createAdaptiveExtensionClassCode 方法首先会通过反射检测接口方法是否包含 Adaptive 注解。对于要生成自适应拓展的接口，Dubbo 要求该接口至少有一个方法被 Adaptive 注解修饰。若不满足此条件，就会抛出运行时异常。相关代码如下：

// 通过反射获取所有的方法
    Method[] methods = type.getMethods();
    boolean hasAdaptiveAnnotation = false;
    // 遍历方法列表
    for (Method m : methods) {
        // 检测方法上是否有 Adaptive 注解
        if (m.isAnnotationPresent(Adaptive.class)) {
            hasAdaptiveAnnotation = true;
            break;
        }
    }
    
    if (!hasAdaptiveAnnotation)
        // 若所有的方法上均无 Adaptive 注解，则抛出异常
        throw new IllegalStateException("No adaptive method on extension ...");

下面内容比较枯燥，主要是讲解生成代码的方法

**生成类**

通过 Adaptive 注解检测后，即可开始生成代码。代码生成的顺序与 Java 文件内容顺序一致，首先会生成 package 语句，然后生成 import 语句，紧接着生成类名等代码。整个逻辑如下：

// 生成 package 代码：package + type 所在包
    codeBuilder.append("package ").append(type.getPackage().getName()).append(";");
    // 生成 import 代码：import + ExtensionLoader 全限定名
    codeBuilder.append("\nimport ").append(ExtensionLoader.class.getName()).append(";");
    // 生成类代码：public class + type简单名称 + $Adaptive + implements + type全限定名 + {
    codeBuilder.append("\npublic class ")
        .append(type.getSimpleName())
        .append("$Adaptive")
        .append(" implements ")
        .append(type.getCanonicalName())
        .append(" {");
    
    // ${生成方法}
    
    codeBuilder.append("\n}");

这里使用 $\{…\} 占位符代表其他代码的生成逻辑，该部分逻辑将在随后进行分析。上面代码不是很难理解，下面直接通过一个例子展示该段代码所生成的内容。以 Dubbo 的 Protocol 接口为例，生成的代码如下：

package com.alibaba.dubbo.rpc;
    import com.alibaba.dubbo.common.extension.ExtensionLoader;
    public class Protocol$Adaptive implements com.alibaba.dubbo.rpc.Protocol {
        // 省略方法代码
    }

**生成方法**  
  一个方法可以被 Adaptive 注解修饰，也可以不被修饰。这里将未被 Adaptive 注解修饰的方法称为“无 Adaptive 注解方法”，下面我们先来看看此种方法的代码生成逻辑是怎样的。  
4.2.3.1 无 Adaptive 注解方法代码生成逻辑  
  对于接口方法，我们可以按照需求标注 Adaptive 注解。以 Protocol 接口为例，该接口的 destroy 和 getDefaultPort 未标注 Adaptive 注解，其他方法均标注了 Adaptive 注解。Dubbo 不会为没有标注 Adaptive 注解的方法生成代理逻辑，对于该种类型的方法，仅会生成一句抛出异常的代码。生成逻辑如下：

for (Method method : methods) {
        
        // 省略无关逻辑
    
        Adaptive adaptiveAnnotation = method.getAnnotation(Adaptive.class);
        StringBuilder code = new StringBuilder(512);
        // 如果方法上无 Adaptive 注解，则生成 throw new UnsupportedOperationException(...) 代码
        if (adaptiveAnnotation == null) {
            // 生成的代码格式如下：
            // throw new UnsupportedOperationException(
            //     "method " + 方法签名 + of interface + 全限定接口名 + is not adaptive method!”)
            code.append("throw new UnsupportedOperationException(\"method ")
                .append(method.toString()).append(" of interface ")
                .append(type.getName()).append(" is not adaptive method!\");");
        } else {
            // 省略无关逻辑
        }
        
        // 省略无关逻辑
    }

以 Protocol 接口的 destroy 方法为例，上面代码生成的内容如下：

throw new UnsupportedOperationException(
                "method public abstract void com.alibaba.dubbo.rpc.Protocol.destroy() of interface com.alibaba.dubbo.rpc.Protocol is not adaptive method!");

获取 URL 数据

前面说过方法代理逻辑会从 URL 中提取目标拓展的名称，因此代码生成逻辑的一个重要的任务是从方法的参数列表或者其他参数中获取 URL 数据。举例说明一下，我们要为 Protocol 接口的 refer 和 export 方法生成代理逻辑。在运行时，通过反射得到的方法定义大致如下：

Invoker refer(Class<T> arg0, URL arg1) throws RpcException;
    Exporter export(Invoker<T> arg0) throws RpcException;

对于 refer 方法，通过遍历 refer 的参数列表即可获取 URL 数据，这个还比较简单。对于 export 方法，获取 URL 数据则要麻烦一些。export 参数列表中没有 URL 参数，因此需要从 Invoker 参数中获取 URL 数据。获取方式是调用 Invoker 中可返回 URL 的 getter 方法，比如 getUrl。如果 Invoker 中无相关 getter 方法，此时则会抛出异常。整个逻辑如下：

for (Method method : methods) {
        Class<?> rt = method.getReturnType();
        Class<?>[] pts = method.getParameterTypes();
        Class<?>[] ets = method.getExceptionTypes();
    
        Adaptive adaptiveAnnotation = method.getAnnotation(Adaptive.class);
        StringBuilder code = new StringBuilder(512);
        if (adaptiveAnnotation == null) {
            // ${无 Adaptive 注解方法代码生成逻辑}
        } else {
        	int urlTypeIndex = -1;
            // 遍历参数列表，确定 URL 参数位置
            for (int i = 0; i < pts.length; ++i) {
                if (pts[i].equals(URL.class)) {
                    urlTypeIndex = i;
                    break;
                }
            }
            
            // urlTypeIndex != -1，表示参数列表中存在 URL 参数
            if (urlTypeIndex != -1) {
                // 为 URL 类型参数生成判空代码，格式如下：
                // if (arg + urlTypeIndex == null) 
                //     throw new IllegalArgumentException("url == null");
                String s = String.format("\nif (arg%d == null) throw new IllegalArgumentException(\"url == null\");",
                                         urlTypeIndex);
                code.append(s);
    
                // 为 URL 类型参数生成赋值代码，形如 URL url = arg1
                s = String.format("\n%s url = arg%d;", URL.class.getName(), urlTypeIndex);
                code.append(s);
                
            // 参数列表中不存在 URL 类型参数
            } else {
                String attribMethod = null;
    
                LBL_PTS:
                // 遍历方法的参数类型列表
                for (int i = 0; i < pts.length; ++i) {
                    // 获取某一类型参数的全部方法
                    Method[] ms = pts[i].getMethods();
                    // 遍历方法列表，寻找可返回 URL 的 getter 方法
                    for (Method m : ms) {
                        String name = m.getName();
                        // 1. 方法名以 get 开头，或方法名大于3个字符
                        // 2. 方法的访问权限为 public
                        // 3. 非静态方法
                        // 4. 方法参数数量为0
                        // 5. 方法返回值类型为 URL
                        if ((name.startsWith("get") || name.length() > 3)
                            && Modifier.isPublic(m.getModifiers())
                            && !Modifier.isStatic(m.getModifiers())
                            && m.getParameterTypes().length == 0
                            && m.getReturnType() == URL.class) {
                            urlTypeIndex = i;
                            attribMethod = name;
                            
                            // 结束 for (int i = 0; i < pts.length; ++i) 循环
                            break LBL_PTS;
                        }
                    }
                }
                if (attribMethod == null) {
                    // 如果所有参数中均不包含可返回 URL 的 getter 方法，则抛出异常
                    throw new IllegalStateException("fail to create adaptive class for interface ...");
                }
    
                // 为可返回 URL 的参数生成判空代码，格式如下：
                // if (arg + urlTypeIndex == null) 
                //     throw new IllegalArgumentException("参数全限定名 + argument == null");
                String s = String.format("\nif (arg%d == null) throw new IllegalArgumentException(\"%s argument == null\");",
                                         urlTypeIndex, pts[urlTypeIndex].getName());
                code.append(s);
    
                // 为 getter 方法返回的 URL 生成判空代码，格式如下：
                // if (argN.getter方法名() == null) 
                //     throw new IllegalArgumentException(参数全限定名 + argument getUrl() == null);
                s = String.format("\nif (arg%d.%s() == null) throw new IllegalArgumentException(\"%s argument %s() == null\");",
                                  urlTypeIndex, attribMethod, pts[urlTypeIndex].getName(), attribMethod);
                code.append(s);
    
                // 生成赋值语句，格式如下：
                // URL全限定名 url = argN.getter方法名()，比如 
                // com.alibaba.dubbo.common.URL url = invoker.getUrl();
                s = String.format("%s url = arg%d.%s();", URL.class.getName(), urlTypeIndex, attribMethod);
                code.append(s);
            }
            
            // 省略无关代码
        }
        
        // 省略无关代码
    }

上面代码有点多，需要耐心看一下。这段代码主要目的是为了获取 URL 数据，并为之生成判空和赋值代码。以 Protocol 的 refer 和 export 方法为例，上面的代码为它们生成如下内容（代码已格式化）：

refer:
    if (arg1 == null) 
        throw new IllegalArgumentException("url == null");
    com.alibaba.dubbo.common.URL url = arg1;
    
    export:
    if (arg0 == null) 
        throw new IllegalArgumentException("com.alibaba.dubbo.rpc.Invoker argument == null");
    if (arg0.getUrl() == null) 
        throw new IllegalArgumentException("com.alibaba.dubbo.rpc.Invoker argument getUrl() == null");
    com.alibaba.dubbo.common.URL url = arg0.getUrl();

获取 Adaptive 注解值  
  Adaptive 注解值 value 类型为 String\[\]，可填写多个值，默认情况下为空数组。若 value 为非空数组，直接获取数组内容即可。若 value 为空数组，则需进行额外处理。处理过程是将类名转换为字符数组，然后遍历字符数组，并将字符放入 StringBuilder 中。若字符为大写字母，则向 StringBuilder 中添加点号，随后将字符变为小写存入 StringBuilder 中。比如 LoadBalance 经过处理后，得到 load.balance。

检测 Invocation 参数  
  此段逻辑是检测方法列表中是否存在 Invocation 类型的参数，若存在，则为其生成判空代码和其他一些代码。相应的逻辑如下：

for (Method method : methods) {
        Class<?> rt = method.getReturnType();
        Class<?>[] pts = method.getParameterTypes();    // 获取参数类型列表
        Class<?>[] ets = method.getExceptionTypes();
    
        Adaptive adaptiveAnnotation = method.getAnnotation(Adaptive.class);
        StringBuilder code = new StringBuilder(512);
        if (adaptiveAnnotation == null) {
            // ${无 Adaptive 注解方法代码生成逻辑}
        } else {
            // ${获取 URL 数据}
            
            // ${获取 Adaptive 注解值}
            
            boolean hasInvocation = false;
            // 遍历参数类型列表
            for (int i = 0; i < pts.length; ++i) {
                // 判断当前参数名称是否等于 com.alibaba.dubbo.rpc.Invocation
                if (pts[i].getName().equals("com.alibaba.dubbo.rpc.Invocation")) {
                    // 为 Invocation 类型参数生成判空代码
                    String s = String.format("\nif (arg%d == null) throw new IllegalArgumentException(\"invocation == null\");", i);
                    code.append(s);
                    // 生成 getMethodName 方法调用代码，格式为：
                    //    String methodName = argN.getMethodName();
                    s = String.format("\nString methodName = arg%d.getMethodName();", i);
                    code.append(s);
                    
                    // 设置 hasInvocation 为 true
                    hasInvocation = true;
                    break;
                }
            }
        }
        
        // 省略无关逻辑
    }

生成拓展名获取逻辑  
  本段逻辑用于根据 SPI 和 Adaptive 注解值生成“获取拓展名逻辑”，同时生成逻辑也受 Invocation 类型参数影响，综合因素导致本段逻辑相对复杂。本段逻辑可能会生成但不限于下面的代码：  
  String extName = (url.getProtocol() == null ? “dubbo” : url.getProtocol());  
  或

String extName = url.getMethodParameter(methodName, “loadbalance”, “random”);  
  亦或是

String extName = url.getParameter(“client”, url.getParameter(“transporter”, “netty”));

本段逻辑复杂之处在于条件分支比较多，大家在阅读源码时需要知道每个条件分支的意义是什么，否则不太容易看懂相关代码。下面开始分析本段逻辑。

for (Method method : methods) {
        Class<?> rt = method.getReturnType();
        Class<?>[] pts = method.getParameterTypes();
        Class<?>[] ets = method.getExceptionTypes();
    
        Adaptive adaptiveAnnotation = method.getAnnotation(Adaptive.class);
        StringBuilder code = new StringBuilder(512);
        if (adaptiveAnnotation == null) {
            // $无 Adaptive 注解方法代码生成逻辑}
        } else {
            // ${获取 URL 数据}
            
            // ${获取 Adaptive 注解值}
            
            // ${检测 Invocation 参数}
            
            // 设置默认拓展名，cachedDefaultName 源于 SPI 注解值，默认情况下，
            // SPI 注解值为空串，此时 cachedDefaultName = null
            String defaultExtName = cachedDefaultName;
            String getNameCode = null;
            
            // 遍历 value，这里的 value 是 Adaptive 的注解值，2.2.3.3 节分析过 value 变量的获取过程。
            // 此处循环目的是生成从 URL 中获取拓展名的代码，生成的代码会赋值给 getNameCode 变量。注意这
            // 个循环的遍历顺序是由后向前遍历的。
            for (int i = value.length - 1; i >= 0; --i) {
                // 当 i 为最后一个元素的坐标时
                if (i == value.length - 1) {
                    // 默认拓展名非空
                    if (null != defaultExtName) {
                        // protocol 是 url 的一部分，可通过 getProtocol 方法获取，其他的则是从
                        // URL 参数中获取。因为获取方式不同，所以这里要判断 value[i] 是否为 protocol
                        if (!"protocol".equals(value[i]))
                        	// hasInvocation 用于标识方法参数列表中是否有 Invocation 类型参数
                            if (hasInvocation)
                                // 生成的代码功能等价于下面的代码：
                                //   url.getMethodParameter(methodName, value[i], defaultExtName)
                                // 以 LoadBalance 接口的 select 方法为例，最终生成的代码如下：
                                //   url.getMethodParameter(methodName, "loadbalance", "random")
                                getNameCode = String.format("url.getMethodParameter(methodName, \"%s\", \"%s\")", value[i], defaultExtName);
                        	else
                        		// 生成的代码功能等价于下面的代码：
    	                        //   url.getParameter(value[i], defaultExtName)
    	                        getNameCode = String.format("url.getParameter(\"%s\", \"%s\")", value[i], defaultExtName);
                        else
                        	// 生成的代码功能等价于下面的代码：
                            //   ( url.getProtocol() == null ? defaultExtName : url.getProtocol() )
                            getNameCode = String.format("( url.getProtocol() == null ? \"%s\" : url.getProtocol() )", defaultExtName);
                        
                    // 默认拓展名为空
                    } else {
                        if (!"protocol".equals(value[i]))
                            if (hasInvocation)
                            	// 生成代码格式同上
                                getNameCode = String.format("url.getMethodParameter(methodName, \"%s\", \"%s\")", value[i], defaultExtName);
    	                    else
    	                    	// 生成的代码功能等价于下面的代码：
    	                        //   url.getParameter(value[i])
    	                        getNameCode = String.format("url.getParameter(\"%s\")", value[i]);
                        else
                        	// 生成从 url 中获取协议的代码，比如 "dubbo"
                            getNameCode = "url.getProtocol()";
                    }
                } else {
                    if (!"protocol".equals(value[i]))
                        if (hasInvocation)
                            // 生成代码格式同上
                            getNameCode = String.format("url.getMethodParameter(methodName, \"%s\", \"%s\")", value[i], defaultExtName);
    	                else
    	                	// 生成的代码功能等价于下面的代码：
    	                    //   url.getParameter(value[i], getNameCode)
    	                    // 以 Transporter 接口的 connect 方法为例，最终生成的代码如下：
    	                    //   url.getParameter("client", url.getParameter("transporter", "netty"))
    	                    getNameCode = String.format("url.getParameter(\"%s\", %s)", value[i], getNameCode);
                    else
                        // 生成的代码功能等价于下面的代码：
                        //   url.getProtocol() == null ? getNameCode : url.getProtocol()
                        // 以 Protocol 接口的 connect 方法为例，最终生成的代码如下：
                        //   url.getProtocol() == null ? "dubbo" : url.getProtocol()
                        getNameCode = String.format("url.getProtocol() == null ? (%s) : url.getProtocol()", getNameCode);
                }
            }
            // 生成 extName 赋值代码
            code.append("\nString extName = ").append(getNameCode).append(";");
            // 生成 extName 判空代码
            String s = String.format("\nif(extName == null) " +
                                     "throw new IllegalStateException(\"Fail to get extension(%s) name from url(\" + url.toString() + \") use keys(%s)\");",
                                     type.getName(), Arrays.toString(value));
            code.append(s);
        }
        
        // 省略无关逻辑
    }

上面代码比较复杂，不是很好理解。对于这段代码，建议大家写点测试用例，对 Protocol、LoadBalance 以及 Transporter 等接口的自适应拓展类代码生成过程进行调试。这里我以 Transporter 接口的自适应拓展类代码生成过程举例说明。首先看一下 Transporter 接口的定义，如下：

@SPI("netty")
    public interface Transporter {
    	// @Adaptive({server, transporter})
        @Adaptive({Constants.SERVER_KEY, Constants.TRANSPORTER_KEY}) 
        Server bind(URL url, ChannelHandler handler) throws RemotingException;
    
        // @Adaptive({client, transporter})
        @Adaptive({Constants.CLIENT_KEY, Constants.TRANSPORTER_KEY})
        Client connect(URL url, ChannelHandler handler) throws RemotingException;
    }

下面对 connect 方法代理逻辑生成的过程进行分析，此时生成代理逻辑所用到的变量如下：

String defaultExtName = "netty";
    boolean hasInvocation = false;
    String getNameCode = null;
    String[] value = ["client", "transporter"];

下面对 value 数组进行遍历，此时 i = 1, value\[i\] = “transporter”，生成的代码如下：

getNameCode = url.getParameter(“transporter”, “netty”);  
  接下来，for 循环继续执行，此时 i = 0, value\[i\] = “client”，生成的代码如下：

getNameCode = url.getParameter(“client”, url.getParameter(“transporter”, “netty”));  
  for 循环结束运行，现在为 extName 变量生成赋值和判空代码，如下：

String extName = url.getParameter("client", url.getParameter("transporter", "netty"));
    if (extName == null) {
        throw new IllegalStateException(
            "Fail to get extension(com.alibaba.dubbo.remoting.Transporter) name from url(" + url.toString()
            + ") use keys([client, transporter])");
    }

生成拓展加载与目标方法调用逻辑  
本段代码逻辑用于根据拓展名加载拓展实例，并调用拓展实例的目标方法。相关逻辑如下：

以 Protocol 接口举例说明，上面代码生成的内容如下：

com.alibaba.dubbo.rpc.Protocol extension = (com.alibaba.dubbo.rpc.Protocol) ExtensionLoader
        .getExtensionLoader(com.alibaba.dubbo.rpc.Protocol.class).getExtension(extName);
    return extension.refer(arg0, arg1);

生成完整的方法  
  本节进行代码生成的收尾工作，主要用于生成方法定义的代码。相关逻辑如下：

以 Protocol 的 refer 方法为例，上面代码生成的内容如下：

public com.alibaba.dubbo.rpc.Invoker refer(java.lang.Class arg0, com.alibaba.dubbo.common.URL arg1) {
        // 方法体
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbmd4dWVsZWkwMzY_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200618143625495.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbmd4dWVsZWkwMzY=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbmd4dWVsZWkwMzY_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20200618143712776.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbmd4dWVsZWkwMzY=,size_16,color_FFFFFF,t_70
[20181222225300570]: https://img-blog.csdnimg.cn/20181222225300570
[20181222225300588]: https://img-blog.csdnimg.cn/20181222225300588
[20181222225300606]: https://img-blog.csdnimg.cn/20181222225300606