---

title: Dubbo SPI机制分析
tags: Dubbo,SPI,源码
grammar_cjkRuby: true

---

Dubbo 的扩展点加载从 JDK 标准的 SPI (Service Provider Interface) 扩展点发现机制加强而来。 Dubbo 改进了 JDK 标准的 SPI 的以下问题：

• JDK 标准的 SPI 会一次性实例化扩展点所有实现，如果有扩展实现初始化很耗时，但如果没用上也加载，会很浪费资源。
• 如果扩展点加载失败，连扩展点的名称都拿不到了。比如：JDK 标准的 ScriptEngine，通过 getName() 获取脚本类型的名称，但如果 RubyScriptEngine 因为所依赖的 jruby.jar 不存在，导致 RubyScriptEngine 类加载失败，这个失败原因被吃掉了，和 ruby 对应不起来，当用户执行 ruby 脚本时，会报不支持 ruby，而不是真正失败的原因。
• 增加了对扩展点 IoC 和 AOP 的支持，一个扩展点可以直接 setter 注入其它扩展点。

源码分析

dubbo的Extension基本架构如图所示：

1539264553280.png

这里最重要的类就是ExtensionLoader.

获取动态自适应拓展实现类

首先分析

ExtensionLoader.getExtensionLoader(Protocol.class).getAdaptiveExtension()

getAdaptiveExtension()

首先分析此方法：

    public T getAdaptiveExtension() {
        //1、先从自适应实例缓存中获取实例
        Object instance = cachedAdaptiveInstance.get();
        //2、双重锁检查，如果实例不存在，则生成实例
        if (instance == null) {
            if (createAdaptiveInstanceError == null) {
                //cachedAdaptiveInstance存放Adaptive修饰类的实例
                synchronized (cachedAdaptiveInstance) {
                    instance = cachedAdaptiveInstance.get();
                    if (instance == null) {
                        try {
                            //3、生成实例
                            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;
    }

• 首先从自适应实例缓存cachedAdaptiveInstance中获取@Adaptive修饰的类
• 如果实例为空，则进行双重锁检查模式创建一个自适应适配器拓展点

createAdaptiveExtension

    private T createAdaptiveExtension() {
        try {
            //1、先获取自适应拓展点实现类，然后实例化
            //2、注入
            return injectExtension((T) getAdaptiveExtensionClass().newInstance());
        } catch (Exception e) {
            throw new IllegalStateException("Can not create ad" +
                    "aptive extension " + type + ", cause: " + e.getMessage(), e);
        }
    }

• 首先通过 getAdaptiveExtensionClass() 获取对应的class
• 实例化
• 注入

getAdaptiveExtensionClass

    private Class<?> getAdaptiveExtensionClass() {
        //加载当前拓展点的所有实现，如果有被@Adaptive修饰的实现类，则缓存在cachedAdaptiveClass
        getExtensionClasses();
        //判断是否有被@Adaptive修饰的实现类，有的话则返回
        if (cachedAdaptiveClass != null) {
            return cachedAdaptiveClass;
        }
        //没有@Adaptive修饰的实现类，创建动态自适应拓展点实现
        return cachedAdaptiveClass = createAdaptiveExtensionClass();
    }

• 通过getExtensionClasses加载当前拓展点的所有实现
• 如果有 @Adaptive 修饰的实现类，则缓存在cachedAdaptiveClass，并返回
• 如果没有 @Adaptive 修饰的实现类，则通过createAdaptiveExtensionClass创建动态自适应拓展点实现

getExtensionClasses

首先分析getExtensionClasses：

    private Map<String, Class<?>> getExtensionClasses() {
        //判断拓展点实现类缓存cachedClasses是否为空，如果为空，通过双重所检查模式进行拓展点实现类加载
        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是否为空，如果为空，通过双重锁检查模式进行拓展点实现类加载loadExtensionClasses

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) {
                //每个拓展接口只能有一个拓展实现默认名，如Protocol的默认实现是“dubbo”
                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));
                }
                //设置默认名，如Protocol的为dubbo
                if (names.length == 1) cachedDefaultName = names[0];
            }
        }

        //根据传入类型，对【META-INF/dubbo/internal/】 【META-INF/dubbo/】【 META-INF/services/】
        //进行拓展点实现类的加载
        Map<String, Class<?>> extensionClasses = new HashMap<String, Class<?>>();
        loadDirectory(extensionClasses, DUBBO_INTERNAL_DIRECTORY, type.getName());
        loadDirectory(extensionClasses, DUBBO_INTERNAL_DIRECTORY, type.getName().replace("org.apache", "com.alibaba"));
        loadDirectory(extensionClasses, DUBBO_DIRECTORY, type.getName());
        loadDirectory(extensionClasses, DUBBO_DIRECTORY, type.getName().replace("org.apache", "com.alibaba"));
        loadDirectory(extensionClasses, SERVICES_DIRECTORY, type.getName());
        loadDirectory(extensionClasses, SERVICES_DIRECTORY, type.getName().replace("org.apache", "com.alibaba"));
        return extensionClasses;
    }

loadExtensionClasses() 做了这么几件事：

• 判断当前类型是否是拓展点接口，即传入类型是否由@SPI修饰
• 判断SPI的name的个数，如果大于1，则抛错；否则获取name的值，然后将它设置为默认值 cachedDefaultName
• 对 META-INF/dubbo/internal/ META-INF/dubbo/ META-INF/services/ 进行拓展点实现类的加载

loadDirectory

    private void loadDirectory(Map<String, Class<?>> extensionClasses, String dir, String type) {
        //拼接文件名，如META-INF/dubbo/internal/org.apache.dubbo.rpc.Protocol
        String fileName = dir + type;
        try {
            Enumeration<java.net.URL> urls;
            ClassLoader classLoader = findClassLoader();
            //加载classpath下所有对应type的文件，如META-INF/dubbo/internal/org.apache.dubbo.rpc.Protocol，然后进行合并加载
            if (classLoader != null) {
                urls = classLoader.getResources(fileName);
            } else {
                urls = ClassLoader.getSystemResources(fileName);
            }
            if (urls != null) {
                //遍历所有对应type的文件，如org.apache.dubbo.rpc.Protocol，然后加载class
                while (urls.hasMoreElements()) {
                    //获取绝对路径
                    java.net.URL resourceURL = urls.nextElement();
                    //获取jar下对应文件的class
                    loadResource(extensionClasses, classLoader, resourceURL);
                }
            }
        } catch (Throwable t) {
            logger.error("Exception when load extension class(interface: " +
                    type + ", description file: " + fileName + ").", t);
        }
    }

• 将对应的文档以及类型全路径进行拼接，如META-INF/dubbo/internal/org.apache.dubbo.rpc.Protocol
• 遍历classpath对应路径下的文件，然后扫描加载
  进入loadResource，读取文件内容

loadResource

     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('=');
                            if (i > 0) {
                                name = line.substring(0, i).trim();
                                line = line.substring(i + 1).trim();
                            }
                            if (line.length() > 0) {
                                //循环加载拓展接口实现类
                                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，等号后面的内容为拓展点实现类的全路径
• 根据name和拓展点实现类全路径，加载class

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.");
        }
        //如果是自定义的适配拓展实现类，则设置cachedAdaptiveClass，并返回
        if (clazz.isAnnotationPresent(Adaptive.class)) {
            if (cachedAdaptiveClass == null) {
                cachedAdaptiveClass = clazz;
            } else if (!cachedAdaptiveClass.equals(clazz)) {
                throw new IllegalStateException("More than 1 adaptive class found: "
                        + cachedAdaptiveClass.getClass().getName()
                        + ", " + clazz.getClass().getName());
            }
        //如果是包装类的话，走包装类的逻辑，即加载存储在cachedWrapperClasses：ProtocolFilterWrapper，ProtocolListenerWrapper
        } 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) {
                name = findAnnotationName(clazz);
                if (name.length() == 0) {
                    throw new IllegalStateException("No such extension name for the class " + clazz.getName() + " in the config " + resourceURL);
                }
            }
            //分割name，获取name数组
            String[] names = NAME_SEPARATOR.split(name);
            if (names != null && names.length > 0) {
                //判断是否被@Active修饰的拓展点实现类，如果是，则使用cachedActivates缓存
                Activate activate = clazz.getAnnotation(Activate.class);
                if (activate != null) {
                    cachedActivates.put(names[0], activate);
                } else {
                    // support com.alibaba.dubbo.common.extension.Activate
                    com.alibaba.dubbo.common.extension.Activate oldActivate = clazz.getAnnotation(com.alibaba.dubbo.common.extension.Activate.class);
                    if (oldActivate != null) {
                        cachedActivates.put(names[0], oldActivate);
                    }
                }
                //同一个实现类对应多个name，以name=>class形式存放于extensionClasses，adaptive修饰的不会存放，包装类不会存放
                for (String n : names) {
                    if (!cachedNames.containsKey(clazz)) {
                        cachedNames.put(clazz, n);
                    }
                    Class<?> c = extensionClasses.get(n);
                    if (c == null) {
                        extensionClasses.put(n, clazz);
                    } else if (c != clazz) {
                        throw new IllegalStateException("Duplicate extension " + type.getName() + " name " + n + " on " + c.getName() + " and " + clazz.getName());
                    }
                }
            }
        }
    }

这个方法做了这么几件事：

• 拦截没有实现指定类型的拓展点实现类

• 如果传入class是由@Adaptive修饰，那么使用cachedAdaptiveClass缓存，只能缓存一个

• 如果是包装类，符合以下条件clazz.getConstructor(type),使用Set（cachedWrapperClasses)存储
  

  1539323479853.png

• 除了两种类型之外，剩下的就是普通的拓展点实现类，判断是否由@Active的自动激活的类型，如果是，使用Map缓存cachedActivates以name->Active的形式存储；然后分割name得到对应的name数组,遍历数组，使用cachedNames缓存以class->name的形式存储，同时，以name->class的形式存储在缓存cachedClasses中

至此，getExtensionClasses的逻辑走完，梳理下它的逻辑：
1、判断拓展点实现类的缓存cachedClasses是否为空，如果为空，进行加载操作
2、根据传入类型，获取SPI注解的值，然后设置默认名cachedDefaultNam
3、在META-INF/dubbo/internal/ META-INF/dubbo/ META-INF/services/这三个目录下进行拓展点加载
4、遍历文件（文件名为传入类型type的全路径名称）内容，然后根据name->className加载class：

• 如果是@Adaptive修饰，那么将当前class缓存在cachedAdaptiveClass,该值是单例
• 如果是包装类，如ProtocolFilterWrapper，ProtocolListenerWrapper，则将class缓存在set集合cachedWrapperClasses中
• 如果是普通的拓展点实现类
  • 如果当前类是@Active修饰的，那么使用缓存cachedActivates以name->Active的形式进行缓存;
  • 将name以","的形式进行分割成数组，然后遍历;用缓存cachedNames以class->name的形式存储当前拓展点实现类的多个名称，同时，以name->class的形式将拓展点实现类缓存在cachedClasses

到这里，已经完成了相关拓展点实现类、@Adaptive修饰的拓展点实现类、@Active修饰的拓展点实现类、包装Wrapper拓展点实现类的加载，回到getAdaptiveExtensionClass,当前缓存cachedAdaptiveClass如果不为空，则说明有@Adaptive修饰的拓展点实现类，直接返回，如果没有，则开始创建动态自适应拓展点createAdaptiveExtensionClass.

createAdaptiveExtensionClass

    private Class<?> createAdaptiveExtensionClass() {
        String code = createAdaptiveExtensionClassCode();
        ClassLoader classLoader = findClassLoader();
        //动态编译Extension，名字为typeName+"$Adaptive",如Protocol$Adaptive
        //Protocol$Adaptive的主要功能
        //1. 从url或扩展接口获取扩展接口实现类的名称；
        //2.根据名称，获取实现类ExtensionLoader.getExtensionLoader(扩展接口类).getExtension(扩展接口实现类名称)，然后调用实现类的方法。
        //需要明白一点dubbo的内部传参基本上都是基于Url来实现的，也就是说Dubbo是基于URL驱动的技术
        //所以，适配器类的目的是在运行期获取扩展的真正实现来调用，解耦接口和实现，这样的话要不我们自己实现适配器类，要不dubbo帮我们生成，而这些都是通过Adpative来实现。
        org.apache.dubbo.common.compiler.Compiler compiler = ExtensionLoader.getExtensionLoader(org.apache.dubbo.common.compiler.Compiler.class).getAdaptiveExtension();
        return compiler.compile(code, classLoader);
    }

上面这个方法，通过动态代理直接生成class，名为typeName+$Adaptive，debug得到Protocol$Adaptive,源码内容为

package com.wl.dubbo;

/**
 * @Author: liumenglong
 * @Date: 2018/9/29 22:48
 * @Description:
 */

import com.alibaba.dubbo.common.extension.ExtensionLoader;

public class Protocol$Adaptive implements com.alibaba.dubbo.rpc.Protocol {
    public void 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!");
    }

    public int getDefaultPort() {
        throw new UnsupportedOperationException("method public abstract int com.alibaba.dubbo.rpc.Protocol.getDefaultPort() of interface com.alibaba.dubbo.rpc.Protocol is not adaptive method!");
    }

    public com.alibaba.dubbo.rpc.Invoker refer(java.lang.Class arg0, com.alibaba.dubbo.common.URL arg1) throws com.alibaba.dubbo.rpc.RpcException {
        if (arg1 == null) throw new IllegalArgumentException("url == null");
        com.alibaba.dubbo.common.URL url = arg1;
        //根据URL获取到对应的拓展名，如果没有指定，则默认取“dubbo”
        String extName = (url.getProtocol() == null ? "dubbo" : url.getProtocol());
        if (extName == null)
            throw new IllegalStateException("Fail to get extension(com.alibaba.dubbo.rpc.Protocol) name from url(" + url.toString() + ") use keys([protocol])");
        //根据拓展名获取对应的拓展点实现类
        com.alibaba.dubbo.rpc.Protocol extension = (com.alibaba.dubbo.rpc.Protocol) ExtensionLoader.getExtensionLoader(com.alibaba.dubbo.rpc.Protocol.class).getExtension(extName);
        //调用实际拓展点的refer方法，如DubboProtocol
        return extension.refer(arg0, arg1);
    }

    public com.alibaba.dubbo.rpc.Exporter export(com.alibaba.dubbo.rpc.Invoker arg0) throws com.alibaba.dubbo.rpc.RpcException {
        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();
        //根据URL获取到对应的拓展名，如果没有指定，则默认取“dubbo”
        String extName = (url.getProtocol() == null ? "dubbo" : url.getProtocol());
        if (extName == null)
            throw new IllegalStateException("Fail to get extension(com.alibaba.dubbo.rpc.Protocol) name from url(" + url.toString() + ") use keys([protocol])");
        //根据拓展名获取对应的拓展点实现类
        com.alibaba.dubbo.rpc.Protocol extension = 
                (com.alibaba.dubbo.rpc.Protocol) ExtensionLoader.
                        getExtensionLoader(com.alibaba.dubbo.rpc.Protocol.class).getExtension(extName);
        //调用实际拓展点的export方法，如DubboProtocol
        return extension.export(arg0);
    }
}

何为动态自适应拓展点，就是通过传入的Url对象，获取到相应的拓展点名称，根据拓展名获取到具体的拓展点实现类，从而调用该实现类的方法，这个方法很好的体现了对修改关闭对拓展开放的原则，用户如果需要实现新的拓展点实现类，只需要按规则配置好相应的类和文件即可，无需修改核心代码。

再回到createAdaptiveExtension,

 return injectExtension((T) getAdaptiveExtensionClass().newInstance());

上面的getAdaptiveExtensionClass已经完成相应class的加载，且通过newInstance完成了实例化，接下来进行注入injectExtension

injectExtension

private T injectExtension(T instance) {
    try {
        //如果当前objectFactory不为空，说明传入type不是ExtensionFactory类型（具体原因见当前类的构造方法），则可以注入
        if (objectFactory != null) {
            for (Method method : instance.getClass().getMethods()) {
                //判断方法是否以set为前缀，且方法参数个数是1个，且方法是public的，如果是，进入注入逻辑
                if (method.getName().startsWith("set")
                        && method.getParameterTypes().length == 1
                        && Modifier.isPublic(method.getModifiers())) {
                    //获取该方法的class类型
                    Class<?> pt = method.getParameterTypes()[0];
                    try {
                        //获取属性名称
                        String property = method.getName().length() > 3 ? method.getName().substring(3, 4).toLowerCase() + method.getName().substring(4) : "";
                        // 根据类型和属性名称，获取实例
                        Object object = objectFactory.getExtension(pt, property);
                        if (object != null) {
                            //进行注入
                            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;
}

• 判断objectFactory，如果objectFactory不为空，说明说明传入type不是ExtensionFactory类型，满足注入的第一个条件
• 遍历当前对象的方法，如果方法满足以下条件，进行注入
  • 前缀为"set"
  • 是public修饰的
  • 参数个数是一个
• 获取属性的类型class以及注入的属性的名称，通过objectFactory进行实例的获取
• 调用method.invoke(instance, object);进行注入

这里首先分析objectFactory,因此需回到ExtensionLoader.getExtensionLoader,本来应该先分析这个方法，但由于getExtensionLoader不影响前面加载拓展点实现类的逻辑，故先不讲解，且前面加载拓展点实现类的逻辑是理解ExtensionLoader.getExtensionLoader的基础，因此，直到注入这里，再对ExtensionLoader.getExtensionLoader进行分析.

getExtensionLoader

  //工厂方法，根据传入类型获取对应ExtensionLoader
    public static <T> ExtensionLoader<T> getExtensionLoader(Class<T> type) {
        //传入的类型必须是接口且不为空，且必须是SPI修饰的可拓展点
        if (type == null)
            throw new IllegalArgumentException("Extension type == null");
        if (!type.isInterface()) {
            throw new IllegalArgumentException("Extension type(" + type + ") is not interface!");
        }
        if (!withExtensionAnnotation(type)) {
            throw new IllegalArgumentException("Extension type(" + type +
                    ") is not extension, because WITHOUT @" + SPI.class.getSimpleName() + " Annotation!");
        }

        //ExtensionLoader会存放在缓存之中，EXTENSION_LOADERS：type=>ExtensionLoader
        ExtensionLoader<T> loader = (ExtensionLoader<T>) EXTENSION_LOADERS.get(type);
        if (loader == null) {
            //将ExtensionLoader放到缓存EXTENSION_LOADERS之中
            EXTENSION_LOADERS.putIfAbsent(type, new ExtensionLoader<T>(type));
            loader = (ExtensionLoader<T>) EXTENSION_LOADERS.get(type);
        }
        return loader;
    }

这里主要是对非SPI修饰的类进行拦截，然后根据传入类型type从EXTENSION_LOADERS缓存中获取实例，如果为空，则进行实例创建，然后添加到缓存中。
对实例创建的过程new ExtensionLoader<T>(type)进行解析：
进入该构造函数：

   private ExtensionLoader(Class<?> type) {
        this.type = type;
        objectFactory = (type == ExtensionFactory.class ? null : ExtensionLoader.getExtensionLoader(ExtensionFactory.class).getAdaptiveExtension());
    }

由于当前type非ExtensionFactory,故调用ExtensionLoader.getExtensionLoader(ExtensionFactory.class).getAdaptiveExtension(),由上面可得，当调用ExtensionLoader.getAdaptiveExtension的时候,如果该拓展点的实现类有被@Adaptive修饰的,则返回该实例，而查看ExtensionFactory接口的实现类可得,有符合该条件的实现类，如图

1539342675108.png

因此，objectFactory不为空，且是AdaptiveExtensionFactory.

public class AdaptiveExtensionFactory implements ExtensionFactory {

    private final List<ExtensionFactory> factories;

    public AdaptiveExtensionFactory() {
        ExtensionLoader<ExtensionFactory> loader = ExtensionLoader.getExtensionLoader(ExtensionFactory.class);
        List<ExtensionFactory> list = new ArrayList<ExtensionFactory>();
        //获取该拓展点的所有实现类的名称，并进行遍历
        for (String name : loader.getSupportedExtensions()) {
            //往list里面添加根据name获取到的拓展点实例
            list.add(loader.getExtension(name));
        }
        factories = Collections.unmodifiableList(list);
    }

    @Override
    public <T> T getExtension(Class<T> type, String name) {
        //遍历所有的ExtensionFactory，当获取到的extension不为空的时候，则返回结果；
        //如果是SPI拓展点，这里最后调用SpiExtensionFactory.getExtension，然后调用ExtensionLoader.getAdaptiveExtension方法返回拓展点实例
        //如果非SPI拓展点，这里通过SpringExtensionFactory获取
        // SpringExtensionFactory不支持SPI拓展点实例的获取，详见SpringExtensionFactory的getExtension方法
        for (ExtensionFactory factory : factories) {
            T extension = factory.getExtension(type, name);
            if (extension != null) {
                return extension;
            }
        }
        return null;
    }

}

首先看AdaptiveExtensionFactory的构造方法，获取ExtensionFactory的所有拓展点实现类，然后使用list列表factories存储，这里list的内容为SpiExtensionFactory、SpringExtensionFactory，如图

1539343310182.png

再看AdaptiveExtensionFactory.getExtension(Class<T> type, String name):

• 遍历factories
• 通过获取到的ObjectFactory.getExtension，获取到对应拓展点实例

  • 如果是传入的类型是SPI拓展点，那么通过SpiExtensionFactory获取，返回值被@Adaptive修饰的拓展点或者动态自适应拓展点
    

    1539348046129.png

  • 如果传入类型非SPI拓展点，通过SpringExtensionFactory获取，从IOC容器中获取
    

    1539348577083.png

到这里，注入的逻辑也分析结束，总结下注入的逻辑：

• 如果当前type非ExtensionFactory类型，则可以进行注入
• ExtensionLoader的objectFactory为AdaptiveExtensionFactory
• 如果注入的类型是SPI修饰的接口，那么获取到的值为@Adaptive修饰的拓展点或者动态自适应拓展点
• 如果注入的类型非SPI修饰的接口，那么获取的值是通过name或者注入类型type从IOC容器中获取

总结

走读了以上代码，对此过程做个总结：

• 实例化ExtensionLoader，对当前ExtensionLoader的objectFactory设值为AdaptiveExtensionFactory，以注册式单例存储在缓存EXTENSION_LOADERS1,类型为ConcurrentMap<Class<?>, ExtensionLoader<?>>
• 加载当前拓展点实现类，读取指定文件下的指定文件，分为三种类型的class的加载：
  • @Adaptive修饰的实现类的加载，存储在缓存cachedAdaptiveClass
  • 包装类，存储在Set缓存cachedWrapperClasses
  • 普通的实现类（包含@Active修饰的，且用缓存cachedActivates存储，形式为name->Active）存储在cachedClasses，存储形式为name->class,且为注册式单例存储
• 如果当前拓展点有@Adaptive修饰的实现类,则返回该实现类的实例，且存储在缓存cachedAdaptiveClass,该值为单例，不可修改
• 如果当前拓展点没有@Adaptive修饰的实现类,返回动态自适应拓展点实现类，例如Protocol的动态自适应拓展点实现类为Protocol$Adaptive,该拓展点的方法调用其实是根据传入Url的protocol的类型来获取具体的拓展点实现类，如配置为dubbo协议的拓展点实现类为DubboProtocol

参考

扩展点加载