[网络协议]4-Dubbo初学-SPI

Dubbo SPI

SPI(Service Provider Interface)简单来说就是对一个接口进行扩展。可以通过服务加载的方式，获取到所有配置的实现类

一、java SPI机制

创建一个接口

public interface ILog {
    void warn(String msg);
}

两个接口实现

public class ConsoleLogImpl implements ILog {
    public void warn(String msg) {
        System.out.println("console log" + msg + "!");
    }
}

public class FileLogImpl implements ILog {
    public void warn(String msg) {
        System.out.println("File log" + msg + "!");
    }
}

在META-INF/services路径下移ILog接口的全限定名创建文件javaspi.inter.ILog

javaspi.interimpl.ConsoleLogImpl
javaspi.interimpl.FileLogImpl

创建测试类进行测试

public class Main {
    private static ServiceLoader<ILog> services = ServiceLoader.load(ILog.class);

    public static void main(String[] args) {
        Iterator<ILog> iterator = services.iterator();
        while (iterator.hasNext()){
            iterator.next().warn("Hello SPI");
        }
    }
}

可以看到如下的结果：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LXwLdlqR-1639122827777)(/Users/zhouzhouzhuoran/file/dubbo学习笔记/图片/javaspi生成结果.jpg)]

java SPI机制不详细分析，重点看看dubbo的SPI机制

二、dubbo SPI机制详解

与java spi机制不同的地方在于，配置文件的路径以及相应的处理类

在META-INF/dubbo路径下创建对应的ILog路径名命名的文件dubbospi.inter.ILog，配置和java原有的有一定区别

consoleLog = dubbospi.interimpl.ConsoleLogImpl
fileLog = dubbospi.interimpl.FileLogImpl

创建测试类

public class ClassMain {
    public static void main(String[] args) {
        ExtensionLoader<ILog> extensionLoader =
                ExtensionLoader.getExtensionLoader(ILog.class);
        ILog consoleLog = extensionLoader.     ("consoleLog");
        consoleLog.warn("a");
        ILog fileLog = extensionLoader.getExtension("fileLog");
        fileLog.warn("b");
    }
}

结果如下：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pwFgdPLy-1639122827778)(/Users/zhouzhouzhuoran/Library/Application Support/typora-user-images/image-20211112120016936.png)]

后续对这个过程进行源码分析

三、dubbo SPI机制源码分析

第一步当然是获取扩展加载器

1、ExtensionLoader.getExtensionLoader源码分析

传入一个class对象

public static <T> ExtensionLoader<T> getExtensionLoader(Class<T> type) {
    //type类型不能为空
    if (type == null)
        throw new IllegalArgumentException("Extension type == null");
    //type必须是接口
    if (!type.isInterface()) {
        throw new IllegalArgumentException("Extension type(" + type + ") is not interface!");
    }
    //type必须有SPI注解
    if (!withExtensionAnnotation(type)) {
        throw new IllegalArgumentException("Extension type(" + type +
                                           ") is not extension, because WITHOUT @" + SPI.class.getSimpleName() + " Annotation!");
    }
    //EXTENSION_LOADERS：扩展名+扩展类对应的缓存
    ExtensionLoader<T> loader = (ExtensionLoader<T>) EXTENSION_LOADERS.get(type);
    //没有获取到
    if (loader == null) {
        //new一个
        EXTENSION_LOADERS.putIfAbsent(type, new ExtensionLoader<T>(type));
        loader = (ExtensionLoader<T>) EXTENSION_LOADERS.get(type);
    }
    return loader;
}

看看具体new的过程

private ExtensionLoader(Class<?> type) {
    //将Class对象存入type属性
    this.type = type;
    //如果type是一个ExtensionFactory对象，objectFactory则存入null，否则存入ExtensionLoader.getExtensionLoader(ExtensionFactory.class).getAdaptiveExtension()
    objectFactory = (type == ExtensionFactory.class ? null : ExtensionLoader.getExtensionLoader(ExtensionFactory.class).getAdaptiveExtension());
}

objectFactory的构造，首先是获取ExtensionFactory.class的扩展加载器，然后调用方法返回一个ExtensionFactory扩展对象，然后调用自适应扩展getAdaptiveExtension

ExtensionLoader.getExtensionLoader其实就是初始化了一个ExtensionLoader，存到EXTENSION_LOADERS中

2、extensionLoader.getExtension源码分析

此方法就是去获取指定type对应的具体实现类的对象，下面具体分析

public T getExtension(String name) {
    //空判断
    if (name == null || name.length() == 0)
        throw new IllegalArgumentException("Extension name == null");
    // 获取默认的拓展实现类
    if ("true".equals(name)) {
        return getDefaultExtension();
    }
    // Holder，顾名思义，用于持有目标对象
    Holder<Object> holder = cachedInstances.get(name);
    //缓存获取Holder对象，没有则构建一个
    if (holder == null) {
        cachedInstances.putIfAbsent(name, new Holder<Object>());
        holder = cachedInstances.get(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;
}

①先分析getDefaultExtension，默认实现

public T getDefaultExtension() {
    getExtensionClasses();
    if (null == cachedDefaultName || cachedDefaultName.length() == 0
        || "true".equals(cachedDefaultName)) {
        return null;
    }
    return getExtension(cachedDefaultName);
}

getExtensionClasses方法分析：

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;
}

cachedClasses：普通扩展类缓存，不包括自适应拓展类和wrapper类

继续分析，默认创建方法

private Map<String, Class<?>> loadExtensionClasses() {
    //之前存的type，获取SPI注解
    final SPI defaultAnnotation = type.getAnnotation(SPI.class);
    //获取SPI注解上的默认name
    if (defaultAnnotation != null) {
        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];
        }
    }

    Map<String, Class<?>> extensionClasses = new HashMap<String, Class<?>>();
    //加载对应的类
    loadDirectory(extensionClasses, DUBBO_INTERNAL_DIRECTORY);
    loadDirectory(extensionClasses, DUBBO_DIRECTORY);
    loadDirectory(extensionClasses, SERVICES_DIRECTORY);
    return extensionClasses;
}

最后调用loadDirectory方法去加载对应的class文件，加载成功后会调用getExtension方法获取对应的扩展类，loadDirectory方法后续分析

②对于不是默认实现的情况，分析createExtension这个方法

private T createExtension(String name) {
    //getExtensionClasses：从配置文件中加载所有的拓展类，可得到“配置项名称”到“配置类”的映射关系表
    Class<?> clazz = getExtensionClasses().get(name);
    //异常处理
    if (clazz == null) {
        throw findException(name);
    }
    try {
        //EXTENSION_INSTANCES:扩展类Class对象与具体实现类的缓存
        T instance = (T) EXTENSION_INSTANCES.get(clazz);
        //如果没有获取到，则反射创建一个对象
        if (instance == null) {
            EXTENSION_INSTANCES.putIfAbsent(clazz, clazz.newInstance());
            instance = (T) EXTENSION_INSTANCES.get(clazz);
        }
        //向拓展对象中注入依赖
        injectExtension(instance);
        Set<Class<?>> wrapperClasses = cachedWrapperClasses;
        if (wrapperClasses != null && !wrapperClasses.isEmpty()) {
            // 循环创建 Wrapper 实例
            for (Class<?> wrapperClass : wrapperClasses) {
                // 将当前 instance 作为参数传给 Wrapper 的构造方法，并通过反射创建 Wrapper 实例。
                // 然后向 Wrapper 实例中注入依赖，最后将 Wrapper 实例再次赋值给 instance 变量
                instance = injectExtension((T) wrapperClass.getConstructor(type).newInstance(instance));
            }
        }
        return instance;
    } catch (Throwable t) {
        throw new IllegalStateException("Extension instance(name: " + name + ", class: " +
                                        type + ")  could not be instantiated: " + t.getMessage(), t);
    }
}

上述方法主要做了三个事情

1、通过 getExtensionClasses 获取所有的拓展类

2、向拓展对象中注入依赖injectExtension

3、将拓展对象包裹在相应的 Wrapper 对象中

接下来，依次分析

2.1通过 getExtensionClasses 获取所有的拓展类，主要是获取class对象

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;
}

具体实现位于加载拓展类方法loadExtensionClasses

private Map<String, Class<?>> loadExtensionClasses() {
    final SPI defaultAnnotation = type.getAnnotation(SPI.class);
    if (defaultAnnotation != null) {
        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];
        }
    }

    Map<String, Class<?>> extensionClasses = new HashMap<String, Class<?>>();
    //META-INF/dubbo/internal/
    loadDirectory(extensionClasses, DUBBO_INTERNAL_DIRECTORY);
    //META-INF/dubbo/
    loadDirectory(extensionClasses, DUBBO_DIRECTORY);
    //META-INF/services/
    loadDirectory(extensionClasses, SERVICES_DIRECTORY);
    return extensionClasses;
}

在上面默认构造中有分析，主要分析loadDirectory，文件加载过程,主要是从META-INF/dubbo/internal/、META-INF/dubbo/、META-INF/services/三个文件夹中获取

private void loadDirectory(Map<String, Class<?>> extensionClasses, String dir) {
    //获取配置文件名
    String fileName = dir + type.getName();
    try {
        Enumeration<java.net.URL> urls;
        //获取加载器
        ClassLoader classLoader = findClassLoader();
        //通过 classLoader 获取所有资源链接
        if (classLoader != null) {
            urls = classLoader.getResources(fileName);
        } else {
            urls = ClassLoader.getSystemResources(fileName);
        }
        if (urls != null) {
            while (urls.hasMoreElements()) {
                java.net.URL resourceURL = urls.nextElement();
                //加载资源
                loadResource(extensionClasses, classLoader, resourceURL);
            }
        }
    } catch (Throwable t) {
        logger.error("Exception when load extension class(interface: " +
                     type + ", description file: " + fileName + ").", t);
    }
}

调用loadResource加载配置文件中的每个class

private void loadResource(Map<String, Class<?>> extensionClasses, ClassLoader classLoader, java.net.URL resourceURL) {
    try {
        //获取流
        BufferedReader reader = new BufferedReader(new InputStreamReader(resourceURL.openStream(), "utf-8"));
        try {
            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 {
                        String name = null;
                        int i = line.indexOf('=');
                        // 以等于号 = 为界，截取name和具体类名
                        if (i > 0) {
                            name = line.substring(0, i).trim();
                            line = line.substring(i + 1).trim();
                        }
                        if (line.length() > 0) {
                            // 首先反射创建类，然后加载类，并通过 loadClass 方法对类进行缓存
                            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);
                    }
                }
            }
        } finally {
            reader.close();
        }
    } catch (Throwable t) {
        logger.error("Exception when load extension class(interface: " +
                type + ", class file: " + resourceURL + ") in " + resourceURL, t);
    }
}

逻辑很简单，就是读取配置文件的每一行的类容，对于每个name，调用loadClass加载对应的类，主要是loadClass方法，具体分析

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 when load extension class(interface: " +
                type + ", class line: " + clazz.getName() + "), class "
                + clazz.getName() + "is not subtype of interface.");
    }
    //判断是否有Adaptive注解
    if (clazz.isAnnotationPresent(Adaptive.class)) {
        if (cachedAdaptiveClass == null) {
            // 设置 cachedAdaptiveClass缓存
            cachedAdaptiveClass = clazz;
        } else if (!cachedAdaptiveClass.equals(clazz)) {
            throw new IllegalStateException("More than 1 adaptive class found: "
                    + cachedAdaptiveClass.getClass().getName()
                    + ", " + clazz.getClass().getName());
        }
        //是否是Wrapper对象
        //cachedWrapperClasses中缓存wapper对象
    } else if (isWrapperClass(clazz)) {
        Set<Class<?>> wrappers = cachedWrapperClasses;
        if (wrappers == null) {
            cachedWrapperClasses = new ConcurrentHashSet<Class<?>>();
            wrappers = cachedWrapperClasses;
        }
        wrappers.add(clazz);
    } else {
        //获取构造器
        clazz.getConstructor();
        if (name == null || name.length() == 0) {
            //此处如果没有设置名字，则调用findAnnotationName获取
            name = findAnnotationName(clazz);
            //如果还是没有，则抛出异常
            if (name.length() == 0) {
                throw new IllegalStateException("No such extension name for the class " + clazz.getName() + " in the config " + resourceURL);
            }
        }
        //name分割
        String[] names = NAME_SEPARATOR.split(name);
        if (names != null && names.length > 0) {
            //获取Activate注解
            Activate activate = clazz.getAnnotation(Activate.class);
            //如果类上有 Activate 注解，则使用 names 数组的第一个元素作为键，
            // 存储 name 到 Activate 注解对象的映射关系
            if (activate != null) {
                cachedActivates.put(names[0], activate);
            }
            //cachedNames：class对象与name之间的对应关系
            for (String n : names) {
                if (!cachedNames.containsKey(clazz)) {
                    cachedNames.put(clazz, n);
                }
                Class<?> c = extensionClasses.get(n);
                //如果extensionClasses没有则直接put
                if (c == null) {
                    extensionClasses.put(n, clazz);
                    //如果有了且和Class对象不一致，则报错，一个name对应了多个Class对象
                } else if (c != clazz) {
                    throw new IllegalStateException("Duplicate extension " + type.getName() + " name " + n + " on " + c.getName() + " and " + clazz.getName());
                }
            }
        }
    }
}

分析到这，基本可以清楚获取所有的拓展类的整个过程，此处进行一个总结：

1、设置一个缓存，从缓存获取，否则调用加载方法。

2、解析SPI注解，这个注解的value属性会被解析为name，然后去加载指定的资源文件夹

3、加载时，会对文件的每一行进行解析，去掉注释、以等号分割等（其中还有一些相关注解的解析）

4、通过全限定名以及类加载器加载创建Class对象，并存入extensionClasses中。

等号前面没有name时，获取name的方法

private String findAnnotationName(Class<?> clazz) {
    com.alibaba.dubbo.common.Extension extension = clazz.getAnnotation(com.alibaba.dubbo.common.Extension.class);
    if (extension == null) {
        //获取其雷鸣
        String name = clazz.getSimpleName();
        //如果是以接口类名结尾，则截取前面的部分，如果不是，则直接返回其小写类名
        if (name.endsWith(type.getSimpleName())) {
            name = name.substring(0, name.length() - type.getSimpleName().length());
        }
        return name.toLowerCase();
    }
    return extension.value();
}

2.2 向拓展对象中注入依赖injectExtension

经过2.1，我们获取到了扩展类的实例，接下来主要分析下依赖注入的过程injectExtension

private T injectExtension(T instance) {
    try {
        //初始化的时候获取
        if (objectFactory != null) {
            //遍历目标类的所有方法
            for (Method method : instance.getClass().getMethods()) {
                // 检测方法是否以 set 开头，且方法仅有一个参数，且方法访问级别为 public
                if (method.getName().startsWith("set")
                        && method.getParameterTypes().length == 1
                        && Modifier.isPublic(method.getModifiers())) {
                    // 获取 setter 方法参数类型
                    Class<?> pt = method.getParameterTypes()[0];
                    try {
                        // 获取属性名，比如 setName 方法对应属性名 name
                        String property = method.getName().length() > 3 ? method.getName().substring(3, 4).toLowerCase() + method.getName().substring(4) : "";
                        // 从 ObjectFactory 中获取依赖对象
                        Object object = objectFactory.getExtension(pt, property);
                        if (object != null) {
                            // 通过反射调用 setter 方法设置依赖
                            method.invoke(instance, object);
                        }
                    } catch (Exception e) {
                        logger.error("fail to inject via method " + method.getName()
                                + " of interface " + type.getName() + ": " + e.getMessage(), e);
                    }
                }
            }
        }
    } catch (Exception e) {
        logger.error(e.getMessage(), e);
    }
    return instance;
}

这个方法很简单，dubbo只支持用setter注入的方式。

2.3、创建wrapper对象

也是采用injectExtension完成实例的注入和包装

四、自适应拓展

说到自适应拓展主要是自适应拓展类Adaptive实现，实质上是一个代理类，代理的对象采用SPI加载获取。下面从源码的角度去分析。

1、自适应注解类

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE, ElementType.METHOD})
public @interface Adaptive {
    String[] value() default {};
}

运行时注解，可用于类和方法，有一个value值，一般用于方法上，类上只有AdaptiveCompiler 和 AdaptiveExtensionFactory，我们重点分析注解在方法上的

2、源码分析

2.1、getAdaptiveExtension方法

自适应拓展类的调用方法为getAdaptiveExtension，在getExtensionLoader方法中就有该方法的调用

public T getAdaptiveExtension() {
    // 从缓存中获取自适应拓展
    Object instance = cachedAdaptiveInstance.get();
    if (instance == null) {
        if (createAdaptiveInstanceError == null) {
            synchronized (cachedAdaptiveInstance) {
                instance = cachedAdaptiveInstance.get();
                if (instance == null) {
                    try {
                        // 创建自适应拓展
                        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;
}

老操作了，先从缓存获取，未获取到则直接创建存入缓存，然后从缓存获取，重点来看createAdaptiveExtension方法

2.2、createAdaptiveExtension方法

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

这个方法就一行代码，但是包含三个逻辑

调用 getAdaptiveExtensionClass 方法获取自适应拓展 Class 对象

通过反射进行实例化

调用 injectExtension 方法向拓展实例中注入依赖

后面两个已经很熟悉了，主要分析getAdaptiveExtensionClass方法

顺便简单说下此处injectExtension方法的作用，Dubbo 中有两种类型的自适应拓展，一种是手工编码的，一种是自动生成的。手工编码的自适应拓展中可能存在着一些依赖，而自动生成的 Adaptive 拓展则不会依赖其他类。这里调用 injectExtension 方法的目的是为手工编码的自适应拓展注入依赖

2.3、getAdaptiveExtensionClass 方法

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

主要包含三个逻辑

调用 getExtensionClasses 获取所有的拓展类

检查缓存，若缓存不为空，则返回缓存

若缓存为空，则调用 createAdaptiveExtensionClass 创建自适应拓展类

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

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);
}

重点是这个自适应拓展代码生成

3、自适应拓展代码生成

这个方法较长，分成几个部分分析

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

    //========================生成类======================
    // 生成 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(" {");

    //以 Dubbo 的 Protocol 接口为例，生成的代码如下：
    //package com.alibaba.dubbo.rpc;
    //import com.alibaba.dubbo.common.extension.ExtensionLoader;
    //public class Protocol$Adaptive implements com.alibaba.dubbo.rpc.Protocol {
    
    //}
    
    
    //=====================生成方法===================
    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 注解，则生成 throw new UnsupportedOperationException(...) 代码
            code.append("throw new UnsupportedOperationException(\"method ")
                .append(method.toString()).append(" of interface ")
                .append(type.getName()).append(" is not adaptive method!\");");
            //以 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!");
        } else {
            int urlTypeIndex = -1;
            // 遍历参数列表，确定 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 (int i = 0; i < pts.length; ++i) {
                if (pts[i].equals(URL.class)) {
                    urlTypeIndex = i;
                    break;
                }
            }
            //urlTypeIndex有值，说明有URL参数
            if (urlTypeIndex != -1) {
                // urlTypeIndex != -1，表示参数列表中存在 URL 参数
                // 为 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;
                            break LBL_PTS;
                        }
                    }
                }
                if (attribMethod == null) {
                    // 如果所有参数中均不包含可返回 URL 的 getter 方法，则抛出异常
                    throw new IllegalStateException("fail to create adaptive class for interface " + type.getName()
                                                    + ": not found url parameter or url attribute in parameters of method " + method.getName());
                }

                // 为可返回 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);
            }

            //以 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 注解值 =================
            String[] value = adaptiveAnnotation.value();
            // value 为空数组
            if (value.length == 0) {
                // 获取类名，并将类名转换为字符数组
                char[] charArray = type.getSimpleName().toCharArray();
                StringBuilder sb = new StringBuilder(128);
                // 遍历字节数组
                for (int i = 0; i < charArray.length; i++) {
                    // 检测当前字符是否为大写字母
                    if (Character.isUpperCase(charArray[i])) {
                        if (i != 0) {
                            // 向 sb 中添加点号
                            sb.append(".");
                        }
                        // 将字符变为小写，并添加到 sb 中
                        sb.append(Character.toLowerCase(charArray[i]));
                    } else {
                        // 添加字符到 sb 中
                        sb.append(charArray[i]);
                    }
                }
                value = new String[]{sb.toString()};
            }
            //上面的处理：比如 LoadBalance 经过处理后，得到 load.balance。
            
            //================= 检测 Invocation 参数===============
            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 = argi.getMethodName();
                    s = String.format("\nString methodName = arg%d.getMethodName();", i);
                    code.append(s);
                    // 设置 hasInvocation 为 true
                    hasInvocation = true;
                    break;
                }
            }

            //=========================生成拓展名获取逻辑======================
            // 设置默认拓展名，cachedDefaultName 源于 SPI 注解值，默认情况下，
            // SPI 注解值为空串，此时 cachedDefaultName = null
            String defaultExtName = cachedDefaultName;
            String getNameCode = null;
            // 遍历 value，这里的 value 是 Adaptive 的注解值，前面分析过 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")
                                //getMethodParameter这个方法是获取url中methodName.loadbalance的值，如果没有则获取loadbalance的值，如果还没有则返回默认值
                                getNameCode = String.format("url.getMethodParameter(methodName, \"%s\", \"%s\")", value[i], defaultExtName);
                        else
                            // 生成的代码功能等价于下面的代码：
                            // url.getParameter(value[i], defaultExtName)
                            //getParameter方法返回url中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);

            
            //===================生成拓展加载与目标方法调用逻辑=======================
            // 生成拓展获取代码，格式如下：
            // type全限定名 extension = (type全限定名)ExtensionLoader全限定名
            //     .getExtensionLoader(type全限定名.class).getExtension(extName);
            // Tips: 格式化字符串中的 %<s 表示使用前一个转换符所描述的参数，即 type 全限定名
            s = String.format("\n%s extension = (%<s)%s.getExtensionLoader(%s.class).getExtension(extName);",
                              type.getName(), ExtensionLoader.class.getSimpleName(), type.getName());
            code.append(s);

            // 如果方法返回值类型非 void，则生成 return 语句。
            if (!rt.equals(void.class)) {
                code.append("\nreturn ");
            }

            // 生成目标方法调用逻辑，格式为：
            //     extension.方法名(arg0, arg2, ..., argN);
            s = String.format("extension.%s(", method.getName());
            code.append(s);
            for (int i = 0; i < pts.length; i++) {
                if (i != 0)
                    code.append(", ");
                code.append("arg").append(i);
            }
            code.append(");");
        }
        //以 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);

        //==============生成完整的方法 
        // public + 返回值全限定名 + 方法名 + (
        codeBuilder.append("\npublic ").append(rt.getCanonicalName()).append(" ").append(method.getName()).append("(");
        // 添加参数列表代码
        for (int i = 0; i < pts.length; i++) {
            if (i > 0) {
                codeBuilder.append(", ");
            }
            codeBuilder.append(pts[i].getCanonicalName());
            codeBuilder.append(" ");
            codeBuilder.append("arg").append(i);
        }
        codeBuilder.append(")");
        // 添加异常抛出代码
        if (ets.length > 0) {
            codeBuilder.append(" throws ");
            for (int i = 0; i < ets.length; i++) {
                if (i > 0) {
                    codeBuilder.append(", ");
                }
                codeBuilder.append(ets[i].getCanonicalName());
            }
        }
        //加入方法code
        codeBuilder.append(" {");
        codeBuilder.append(code.toString());
        codeBuilder.append("\n}");
    }
    //收尾}
    codeBuilder.append("\n}");
    //以 Protocol 的 refer 方法为例，上面代码生成的内容如下：
    //public com.alibaba.dubbo.rpc.Invoker refer(java.lang.Class arg0, com.alibaba.dubbo.common.URL arg1) {
    //}
    if (logger.isDebugEnabled()) {
        logger.debug(codeBuilder.toString());
    }
    return codeBuilder.toString();
}

这一部分代码比较长，总的来说就是自适应拓展类的代码拼接，可以根据注释多看几遍应该就能理解了。

第二次看完这部分，对这个代码重构做一个简单的总结：

这一部分的解析主要是针对Adaptive注解的处理，首先，这个注解的作用是返回注解value属性中设置的值在url中赋值的扩展类。什么意思呢？以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;
}

如果我传入的url中有&client=xxxx，则connect方法返回的就是xxxx的扩展类。那dubbo是如何实现这个功能的呢？

首先是调用Transporter的connect方法时，实际调用的是Transporter$Adaptive类，这个类是重新构建，具体怎么构建的就是上述的过程。过程可以简单的分为几步（对上面分析进行一个总结）：

1、判断整个类的所有方法中，是否包含Adaptive注解，如果没有方法包含，则抛出异常，如果有，则进行解析。

2、package、import（此处只需要引入ExtensionLoader）、class三行

3、遍历每个方法，无Adaptive注解的，方法体为直接抛出异常

4、对于有Adaptive注解的，首先获取到URL对象，两种途径，直接从方法入参中获取，或者从所有方法的getUrl方法获取（能够返回Url对象的方法）

5、处理Adaptive注解的value值，用于匹配URL中的参数

6、判断方法参数中是否有com.alibaba.dubbo.rpc.Invocation参数

7、根据value值获取URL中的扩展对象名，并通过ExtensionLoader实例化对应的扩展类，如果方法有返回值，则会返回对应的扩展对象的实现方法

8、完成方法、异常抛出，方法参数，完成整个类的重写。

4、getActivateExtension源码分析

Activate注解主要包含了5个参数，可以定义在类和方法上

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE, ElementType.METHOD})
public @interface Activate {
    //调用getActivateExtension的入参group如果在注解的group，则激活
    String[] group() default {};

    //调用getActivateExtension的入参value匹配url得到对应的values，会激活values对应的key
    //value的作用：如果value不是url中的一个key|.value不是url中的一个key，不会被激活
    String[] value() default {};

    //填写扩展点列表，表示那些扩展点要在本扩展点之前
    String[] before() default {};

    //填写扩展点列表，表示那些扩展点要在本扩展点之后
    String[] after() default {};

    //整型，直接的排序信息
    int order() default 0;
}

首先理解下Activate注解的用法

public class Test1Filter implements Filter {
    @Override
    public Result invoke(Invoker<?> invoker, Invocation invocation) throws RpcException {
        return null;
    }
}
@Activate(group = Constants.PROVIDER,order = 2)
public class Test2Filter implements Filter {
    @Override
    public Result invoke(Invoker<?> invoker, Invocation invocation) throws RpcException {
        return null;
    }
}
@Activate(group = Constants.CONSUMER,order = 3)
public class Test3Filter implements Filter {
    @Override
    public Result invoke(Invoker<?> invoker, Invocation invocation) throws RpcException {
        return null;
    }
}
@Activate(group = {Constants.PROVIDER,Constants.CONSUMER},order = 4)
public class Test4Filter implements Filter {
    @Override
    public Result invoke(Invoker<?> invoker, Invocation invocation) throws RpcException {
        return null;
    }
}

@Activate(group = {Constants.PROVIDER,Constants.CONSUMER},order = 5,value = "test5")
public class Test5Filter implements Filter {
    @Override
    public Result invoke(Invoker<?> invoker, Invocation invocation) throws RpcException {
        return null;
    }
}

public static void main(String[] args){
    ExtensionLoader extensionLoader = ExtensionLoader.getExtensionLoader(Filter.class);

    URL url=new URL("","",3);
    url=url.addParameter("filterValue", "test5");
    //2,4
    List list=extensionLoader.getActivateExtension(url,"",Constants.PROVIDER);
    System.out.println(list);
    
    //3,4
    list=extensionLoader.getActivateExtension(url,"",Constants.CONSUMER);
    System.out.println(list);
    
    //3，4，5
    list=extensionLoader.getActivateExtension(url,"filterValue",Constants.CONSUMER);
    System.out.println(list);
}

主要看下Activate注解的调用入口getActivateExtension

//首先说明该方法的三个参数的意义：
//url：传入的URL对象（例子中的url），values：匹配url中的参数key（例子中的filterValue），group：某一个固定的key（例子中的Constants.CONSUMER、Constants.PROVIDER）
public List<T> getActivateExtension(URL url, String[] values, String group) {
    List<T> exts = new ArrayList<T>();
    //names包含了所有values集合
    List<String> names = values == null ? new ArrayList<String>(0) : Arrays.asList(values);
    //如果传入了-default参数，则所有Activate扩展点都不会被激活
    if (!names.contains(Constants.REMOVE_VALUE_PREFIX + Constants.DEFAULT_KEY)) {
        //加载所有扩展类
        getExtensionClasses();
        //cachedActivates这个在获取ExtensionLoader的时候就获取了所有扩展类名与Activate注解的map
        //遍历所有存在activate注解的name
        for (Map.Entry<String, Activate> entry : cachedActivates.entrySet()) {
            String name = entry.getKey();
            Activate activate = entry.getValue();
            //如果注解上的group包含了传入的group，则需要激活该name的扩展类
            if (isMatchGroup(group, activate.group())) {
                //激活
                T ext = getExtension(name);
                //1、传入的values没有该扩展名，2、传入的values没有-name（扩展点名），3、url中有对应value，则真正添加
                if (!names.contains(name)
                        && !names.contains(Constants.REMOVE_VALUE_PREFIX + name)
                        && isActive(activate, url)) {
                    exts.add(ext);
                }
            }
        }
        //根据order排序，before和after排序，具体排序规则可以看ActivateComparator
        Collections.sort(exts, ActivateComparator.COMPARATOR);
    }
    //处理传入的value字段
    List<T> usrs = new ArrayList<T>();
    for (int i = 0; i < names.size(); i++) {
        String name = names.get(i);
        //-开头直接不处理，如果values传入了-name，也不进行加载
        if (!name.startsWith(Constants.REMOVE_VALUE_PREFIX)
                && !names.contains(Constants.REMOVE_VALUE_PREFIX + name)) {
        	//default可以控制default之前的所有节点
        	if (Constants.DEFAULT_KEY.equals(name)) {
                if (!usrs.isEmpty()) {
                    exts.addAll(0, usrs);
                    usrs.clear();
                }
            } else {
                T ext = getExtension(name);
                usrs.add(ext);
            }
        }
    }
    if (!usrs.isEmpty()) {
        exts.addAll(usrs);
    }
    return exts;
}

（扩展点名），3、url中有对应value，则真正添加
if (!names.contains(name)
&& !names.contains(Constants.REMOVE_VALUE_PREFIX + name)
&& isActive(activate, url)) {
exts.add(ext);
}
}
}
//根据order排序，before和after排序，具体排序规则可以看ActivateComparator
Collections.sort(exts, ActivateComparator.COMPARATOR);
}
//处理传入的value字段
List usrs = new ArrayList();
for (int i = 0; i < names.size(); i++) {
String name = names.get(i);
//-开头直接不处理，如果values传入了-name，也不进行加载
if (!name.startsWith(Constants.REMOVE_VALUE_PREFIX)
&& !names.contains(Constants.REMOVE_VALUE_PREFIX + name)) {
//default可以控制default之前的所有节点
if (Constants.DEFAULT_KEY.equals(name)) {
if (!usrs.isEmpty()) {
exts.addAll(0, usrs);
usrs.clear();
}
} else {
T ext = getExtension(name);
usrs.add(ext);
}
}
}
if (!usrs.isEmpty()) {
exts.addAll(usrs);
}
return exts;
}