02_dubbo的SPI

【dubbo为什么不采用JDK自带的SPI】

1.JDK自带的SPI（ServiceLoader）会一次性实例化扩展点所有实现，基本只能通过遍历全部获取，也就是接口的实现类全部加载并实例化一遍，如果我们不想使用某些类，它也会被加载并且实例化，这就导致了浪费。

2.增加了对扩展点IOC和AOP的支持，一个扩展点可以直接setter注入其他扩展点。

【dubbo的SPI新增的功能】

1.dubbo的SPI可以方便地获取某一个想要的扩展实现，Java自带的SPI机制没有实现这样的功能。

2.对于扩展实现IOC依赖注入功能：

举例来说：接口A，实现类为A1，A2。接口B，实现类为B1，B2。

现在A1含有setB(B b)方法，会自动注入一个接口B的实现类，此时注入B1还是B2呢？都不是，而是注入一个动态生成的接口B的实现者B$Adpative，该实现者B$Adaptive能够根据参数的不同，自动引用B1或者B2来完成相应的功能。

3.对扩展采用装饰器模式进行功能增强，类似AOP实现的功能。

还是上面的例子，接口A的另一个实现者AWrapper1，大体内容如下：

class AWrapper1 implements A{
    private A a;
    AWrapper1（A a）{
        this.a=a;
    }
}

因此，我们在采用某一个接口A的实现者A1的时候，其实已经自动被AWrapper1包装起来了。

【dubbo的SPI的约定】

1.SPI文件存储路径在“META-INF/dubbo/internal” 目录下，并且文件名为接口的全路径名，即为“接口的包名+接口名”

2.每个SPI文件里面的格式定义为：“扩展名=具体的类名”

例如：

dubbo=com.alibaba.dubbo.rpc.protocol.dubbo.DubboProtocol

【dubbo SPI 分析】

[ 目的 ]：获取一个接口的实现类的对象。

[ 途径 ]：

/*ExtensionLoader类*/
ExtensionLoader.getExtension(String name)

[ 3种实现路径 ]

/**
 * ExtensionLoader类下的方法得到一个ExtensionLoader实例
 * 有三种实现路径
 **/
 //实现路径1：为改接口new一个ExtensionLoader，然后缓存起来
getExtensionLoader(Class<T> type)
//实现路径2:获取一个扩展装饰类，如果@Adaptive注解在类上，就是一个装饰类；如果注解在方法上就是一个动态代理类，例如Protocol$Adaptive
getAdaptiveExtension()
//实现路径3：获取一个对象
getExtension(String name) 

【dubbo SPI 源码分析】

[这三行SPI代码]

package com.dubbo.spi;
import com.alibaba.dubbo.common.extension.ExtensionLoader;
import com.alibaba.dubbo.rpc.Protocol;

/**
 * Created by HigginCui on 2018/9/5.
 */
public class ExtensionTest {
    public static void main(String[] args) {
        ExtensionLoader<Protocol> loader = ExtensionLoader.getExtensionLoader(Protocol.class);
        final Protocol dubboProtocol = loader.getExtension("dubbo");
        final Protocol adaptiveExtension = loader.getAdaptiveExtension();
    }
}

【 1.Protocol接口的定义 】

package com.alibaba.dubbo.rpc;

import com.alibaba.dubbo.common.URL;
import com.alibaba.dubbo.common.extension.Adaptive;
import com.alibaba.dubbo.common.extension.SPI;

/**
 * Protocol. (API/SPI, Singleton, ThreadSafe)
 *
 * @author william.liangf
 */
@SPI("dubbo")
public interface Protocol {

    /**
     * 获取缺省端口，当用户没有配置端口时使用。
     *
     * @return 缺省端口
     */
    int getDefaultPort();

    /**
     * 暴露远程服务：<br>
     * 1. 协议在接收请求时，应记录请求来源方地址信息：RpcContext.getContext().setRemoteAddress();<br>
     * 2. export()必须是幂等的，也就是暴露同一个URL的Invoker两次，和暴露一次没有区别。<br>
     * 3. export()传入的Invoker由框架实现并传入，协议不需要关心。<br>
     *
     * @param <T>     服务的类型
     * @param invoker 服务的执行体
     * @return exporter 暴露服务的引用，用于取消暴露
     * @throws RpcException 当暴露服务出错时抛出，比如端口已占用
     */
    @Adaptive
    <T> Exporter<T> export(Invoker<T> invoker) throws RpcException;

    /**
     * 引用远程服务：<br>
     * 1. 当用户调用refer()所返回的Invoker对象的invoke()方法时，协议需相应执行同URL远端export()传入的Invoker对象的invoke()方法。<br>
     * 2. refer()返回的Invoker由协议实现，协议通常需要在此Invoker中发送远程请求。<br>
     * 3. 当url中有设置check=false时，连接失败不能抛出异常，并内部自动恢复。<br>
     *
     * @param <T>  服务的类型
     * @param type 服务的类型
     * @param url  远程服务的URL地址
     * @return invoker 服务的本地代理
     * @throws RpcException 当连接服务提供方失败时抛出
     */
    @Adaptive
    <T> Invoker<T> refer(Class<T> type, URL url) throws RpcException;

    /**
     * 释放协议：<br>
     * 1. 取消该协议所有已经暴露和引用的服务。<br>
     * 2. 释放协议所占用的所有资源，比如连接和端口。<br>
     * 3. 协议在释放后，依然能暴露和引用新的服务。<br>
     */
    void destroy();

}

[ 两个核心注解 ]

@SPI：指定一个接口为SPI接口（可扩展接口）

package com.alibaba.dubbo.common.extension;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * 扩展点接口的标识。
 * 扩展点声明配置文件，格式修改。
 * 以Protocol示例，配置文件META-INF/dubbo/com.xxx.Protocol内容：
 * 由 com.foo.XxxProtocol
 *    com.foo.YyyProtocol
 * 改成使用KV格式
 *    xxx=com.foo.XxxProtocol
 *    yyy=com.foo.YyyProtocol
 * 原因：
 * 当扩展点的static字段或方法签名上引用了三方库，
 * 如果三方库不存在，会导致类初始化失败，
 * Extension标识Dubbo就拿不到了，异常信息就和配置对应不起来。
 *
 * 比如:
 * Extension("mina")加载失败，
 * 当用户配置使用mina时，就会报找不到扩展点，
 * 而不是报加载扩展点失败，以及失败原因。
 *
 */
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE})
public @interface SPI {
    /**
     * 缺省扩展点名。
     */
    String value() default "";

}

 @Adaptive：该注解可以注解在两个地方

1.接口上：例如AdaptiveExtensionFactory（该类不是工厂类，有特殊逻辑）

AdaptiveCompiler（实际上是工厂类，但是不能动态生成，否则会形成死循环）

2.接口的方法上：会动态生成相应的动态类，（实际上是一个工厂，工厂设计模式），例如Protocol$Adapter，这个接口极其重要，后续的整个服务暴露和服务调用都会调用到该接口的两个方法。

package com.alibaba.dubbo.common.extension;

import com.alibaba.dubbo.common.URL;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * 在{@link ExtensionLoader}生成Extension的Adaptive Instance时，为{@link ExtensionLoader}提供信息。
 */
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE, ElementType.METHOD})
public @interface Adaptive {

    /**
     * 从{@link URL}的Key名，对应的Value作为要Adapt成的Extension名。
     * 如果{@link URL}这些Key都没有Value，使用 用 缺省的扩展（在接口的{@link SPI}中设定的值）。
     * 比如，String[] {"key1", "key2"}，表示
     * 先在URL上找key1的Value作为要Adapt成的Extension名；
     * key1没有Value，则使用key2的Value作为要Adapt成的Extension名。
     * key2没有Value，使用缺省的扩展。
     * 如果没有设定缺省扩展，则方法调用会抛出{@link IllegalStateException}。
     * 如果不设置则缺省使用Extension接口类名的点分隔小写字串。
     * 即对于Extension接口{@code com.alibaba.dubbo.xxx.YyyInvokerWrapper}的缺省值为String[] {"yyy.invoker.wrapper"}
  */
    String[] value() default {};
}

【2.获取ExtensionLoader】

ExtensionLoader可以类比JDK-SPI中的ServiceLoader。

[ ExtensionLoader中的类属性 ]

public class ExtensionLoader<T> {
    /** 存放SPI文件的三个目录,其中META-INF/services/也是jdk的SPI文件的存放目录 */
    private static final String SERVICES_DIRECTORY = "META-INF/services/";
    private static final String DUBBO_DIRECTORY = "META-INF/dubbo/";
    /**这个是最终jar包中存放spi文件的位置**/
    private static final String DUBBO_INTERNAL_DIRECTORY = DUBBO_DIRECTORY + "internal/";
    private static final Pattern NAME_SEPARATOR = Pattern.compile("\\s*[,]+\\s*");
    /** key: SPI接口Class   value: 该接口的ExtensionLoader */
    private static final ConcurrentMap<Class<?>, ExtensionLoader<?>> EXTENSION_LOADERS = new ConcurrentHashMap<Class<?>, ExtensionLoader<?>>();
    /** key: SPI接口Class   value: SPI实现类的对象实例 */
    private static final ConcurrentMap<Class<?>, Object> EXTENSION_INSTANCES = new ConcurrentHashMap<Class<?>, Object>();
}

[ ExtensionLoader中的实例属性（上述的是类属性(static)，即所有该类的实例都共享。实例属性是每一个类的实例私有） ]

public class ExtensionLoader<T> {

    private final Class<?> type;   //SPI接口Class

    private final ExtensionFactory objectFactory;  //SPI实现类的对象实例的创建工程

    /** key: ExtensionClass的Class   value: SPI的实现类的key **/
    private final ConcurrentMap<Class<?>, String> cachedNames = new ConcurrentHashMap<Class<?>, String>();  

    /** 存放所有的ExtensionClass **/
    private final Holder<Map<String, Class<?>>> cachedClasses = new Holder<Map<String, Class<?>>>();

    private final Map<String, Activate> cachedActivates = new ConcurrentHashMap<String, Activate>();

    /**缓存创建好的ExtensionClass实例**/
    private final ConcurrentMap<String, Holder<Object>> cachedInstances = new ConcurrentHashMap<String, Holder<Object>>();

    /** 缓存创建好的适配器实例 **/
    private final Holder<Object> cachedAdaptiveInstance = new Holder<Object>();

    /**存储类上带有@Adaptive注解的Class**/
    private volatile Class<?> cachedAdaptiveClass = null;

    /** 默认SPI文件中的key **/
    private String cachedDefaultName;

    /** 存储在创建适配器实例这个过程中发生的错误 **/
    private volatile Throwable createAdaptiveInstanceError;

    /**存放具有一个type入参构造器的实现类 Class对象**/
    private Set<Class<?>> cachedWrapperClasses;

    /**key:实现列的全类名  value:exception,防止真正的异常被吞掉 **/
    private Map<String, IllegalStateException> exceptions = new ConcurrentHashMap<String, IllegalStateException>();
}

[ 注意 ]

com.alibaba.dubbo.rpc.Protocol 文件中整体路径和文件的内容如下

registry=com.alibaba.dubbo.registry.integration.RegistryProtocol
dubbo=com.alibaba.dubbo.rpc.protocol.dubbo.DubboProtocol
filter=com.alibaba.dubbo.rpc.protocol.ProtocolFilterWrapper
listener=com.alibaba.dubbo.rpc.protocol.ProtocolListenerWrapper
mock=com.alibaba.dubbo.rpc.support.MockProtocol
injvm=com.alibaba.dubbo.rpc.protocol.injvm.InjvmProtocol
rmi=com.alibaba.dubbo.rpc.protocol.rmi.RmiProtocol
hessian=com.alibaba.dubbo.rpc.protocol.hessian.HessianProtocol
com.alibaba.dubbo.rpc.protocol.http.HttpProtocol
com.alibaba.dubbo.rpc.protocol.webservice.WebServiceProtocol
thrift=com.alibaba.dubbo.rpc.protocol.thrift.ThriftProtocol
memcached=com.alibaba.dubbo.rpc.protocol.memcached.MemcachedProtocol

redis=com.alibaba.dubbo.rpc.protocol.redis.RedisProtocol

对于上述Protocol接口的实现类，ExtensionLoader分三种情况来分别存储对应的实现者，分别是下面三个实例属性：

private volatile Class<?> cachedAdaptiveClass = null;

private Set<Class<?>> cachedWrapperClasses;

private final Holder<Map<String, Class<?>>> cachedClasses = new Holder<Map<String, Class<?>>>();

情况1：如果这个class含有Adaptive注解，则将这个class设置为Class<?> cacheAdaptiveClass；

情况2：尝试获取带对应接口参数的构造器，如果能够获取到，则说明这个class是一个装饰器类，存放到Set<Class<?>> cachedWraperClasses；

情况3：如果没有上述构造器，则获取class上的SPI注解，根据该注解的定义的name作为key，存放至 Holder<Map<String,Class<?>>> cachedClasses中

[  ExtensionLoader.getExtensionLoader(Protocol.class)方法 ]

/**
 * 1.校验参数type：非空+是接口+含有@SPI注解
 * 2.根据type接口，从全局缓存EXTENSIONS_LOADERS中获取ExtensionLoader，若有直接返回；如果没有则先创建，放入缓存，再返回
 */
public static <T> ExtensionLoader<T> getExtensionLoader(Class<T> type) {
        if (type == null)
            throw new IllegalArgumentException("Extension type == null");
        if (!type.isInterface()) {
            throw new IllegalArgumentException("Extension type(" + type + ") is not interface!");
        }
        if (!withExtensionAnnotation(type)) {
            throw new IllegalArgumentException("Extension type(" + type +
                    ") is not extension, because WITHOUT @" + SPI.class.getSimpleName() + " Annotation!");
        }

        ExtensionLoader<T> loader = (ExtensionLoader<T>) EXTENSION_LOADERS.get(type);
        if (loader == null) {
            EXTENSION_LOADERS.putIfAbsent(type, new ExtensionLoader<T>(type));
            loader = (ExtensionLoader<T>) EXTENSION_LOADERS.get(type);
        }
        return loader;
    }

[ new ExtensionLoader<T>(type)构造方法 ]

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

分析：

当前目标创建的ExtensionLoader对象(自行命名为ExtensionLoader对象1)的type为com.alibaba.dubbo.rpc.Protocol，所以会执行

ExtensionLoader.getExtensionLoader(ExtensionFactory.class).getAdaptiveExtension());

那需要首先创建ExtensionFactory，可以看出对应的ExtensionFactory同样也是一个SPI接口，且没有指定默认的实现类。

@SPI
public interface ExtensionFactory {
    /**
     * Get extension.*/
    <T> T getExtension(Class<T> type, String name);
}

ExtensionLoader.getExtensionLoader(ExtensionFactory.class)过程与上面类似，只是我们需要创建另外一个ExtensionLoader对象（我们取名为ExtensionLoader对象2），type为com.alibaba.dubbo.common.extension.ExtensionFactory，而objectFactory是null，之后这个ExtensionLoader对象2会被放入EXTENSION_LOADERS缓存中。

之后执行ExtensionLoader对象2的getAdaptiveExtension()方法：

/**
 * 首先从cahcedAdaptiveInstance缓存中取得AdaptiveExtension实例
 * 如果不为null，直接返回
 * 如果为null，先createAdaptiveExtension()创建AdaptiveExtension实例，之后放入cachedAdaptiveInstance缓存中，最后返回
 */
public T getAdaptiveExtension() {
    Object instance = cachedAdaptiveInstance.get();
    if (instance == null) {
        if (createAdaptiveInstanceError == null) {
            synchronized (cachedAdaptiveInstance) {
                instance = cachedAdaptiveInstance.get();
                if (instance == null) {
                    try {
                        instance = createAdaptiveExtension();  //创建AdaptiveExtension实例
                        cachedAdaptiveInstance.set(instance); //之后放入cachedAdaptiveInstance缓存中
                    } 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()创建AdaptiveExtension源码

/**
 * createAdaptiveExtension()
 *   -- getAdaptiveExtensionClass()  //从dubbo-spi配置文件中获取AdaptiveExtensionClass
 *       --getExtensionClasses()
 *          --loadExtensionClasses()
 *             --loadFile(Map<String,Class<?>> extensionClasses, String dir)
 *        -- getAdaptiveExtensionClass() //创建动态代理类
 * --injectExtension(T instance)  //dubbo的ioc
 */
private T createAdaptiveExtension() {
        try {
            return injectExtension((T) getAdaptiveExtensionClass().newInstance());
        } catch (Exception e) {
            throw new IllegalStateException("Can not create adaptive extenstion " + type + ", cause: " + e.getMessage(), e);
        }
}

再看getAdaptiveExtensionClass()方法

 /**
  * 获取ExtensionClasses和适配类
  * 如果实现类上有带有@Adaptive注解，直接创建修饰类
  * 如果方法上带有@Adaptive注解，动态生成代理类
  **/
private Class<?> getAdaptiveExtensionClass() {
        getExtensionClasses();
        if (cachedAdaptiveClass != null) {
            return cachedAdaptiveClass;
        }
        return cachedAdaptiveClass = createAdaptiveExtensionClass();
}

再看getExtensionClasses()方法

/**
 * 先从Holder<Map<String, Class<?>>> cachedClasses缓存中获取所有的ExtensionClass，如果有，直接返回；
 * 如果没有，通过loadExtensionClasses()从SPI文件中取读取，之后写入缓存
 **/
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()方法

/**
 * 1.从@SPI注解中将默认值解析出来，并缓存到String cachedDefaultName 中
 * 2.从SPI文件中获取对应的value（SPI文件中是key-value格式）并存储到Map<String, Class<?>> extensionClasses局部变量上
 * 注意：loadExtensionClasses方法已经同步过
 **/
private Map<String, Class<?>> loadExtensionClasses() {
        final SPI defaultAnnotation = type.getAnnotation(SPI.class);
        if (defaultAnnotation != null) {
            String value = defaultAnnotation.value();
            if (value != null && (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<?>>();
        loadFile(extensionClasses, DUBBO_INTERNAL_DIRECTORY);
        loadFile(extensionClasses, DUBBO_DIRECTORY);
        loadFile(extensionClasses, SERVICES_DIRECTORY);
        return extensionClasses;
    }

再看非常重要的方法：loadFile(Map<String,Class<?>> extensionClasses, String dir)方法：

/**
 * 1.加载dir目录下的指定type的文件（如：/META-INF/dubbo/internal/com.alibaba.dubbo.common.extension.ExtensionFactory）
 * 2.遍历文件中的每一行
 *    2.1 获取实现类key和value，例如 name=spi，line=com.alibaba.dubbo.common.extension.factory.SpiExtensionFactory
 *    2.2 根据line创建Class对象
 *    2.3 将具有@Adaptive注解的实现类的Class对象放在 volatile Class<?> cachedAdaptiveClass缓存中，注意该缓存只能存放一个具有@Adaptive注解的实现类的Class对象，如果有两个同时满足，则抛异常
 *    2.4~2.6都是针对不含@Adaptive注解的实现类的Class对象
 *    2.4 查看类是否含有一个type入参的构造方法，如果有（就是wrapper类），将当前的Class对象存放至Set<Class<?>> cachedWrapperClasses缓存中
 *    2.5 如果类不含有一个type入参的构造方法，获取无参构造方法，如果Class对象具有@Active注解，将改对象以<实现类的key, active>格式存储起来，即Map<String, Activate> cachedActivates
 *    2.6 最后，将<Class对象， 实现类的key>存入ConcurrentMap<Class<?>, String> cachedNames进行缓存，并将这些Class存入loadFile(Map<String, Class<?>> extensionClasses, String dir)的入参extensionClasses中
 *
 **/
private void loadFile(Map<String, Class<?>> extensionClasses, String dir) {
......
}

上述的方法，分别从三个目录里查找SPI文件并进行加载，在这里只有META-INF/dubbo/internal/com.alibaba.dubbo.common.extension.ExtensionFactory中有值，内容如下：

其中，AdaptiveExtensionFactory在类上有@Adaptive注解。

执行过后，

cachedAdaptiveClass=class com.alibaba.dubbo.common.extension.factory.AdaptiveExtensionFactory

extendionClasses = [{"spring","class com.alibaba.dubbo.config.spring.extension.SpringExtensionFactory"}, {"spi", "class com.alibaba.dubbo.common.extension.factory.SpiExtensionFactory"}]，后续这个集合会存储在cachedClasses缓存中。

上面一直在讲getAdaptiveExtensionClass().newInstance()这句代码中的getAdaptiveExtensionClass()方法，

该方法返回一个com.alibaba.dubbo.common.extension.factory.AdaptiveExtensionFactory类，在看下其newInstance()代码，之后再来看下其newInstance()代码，调用这个方法，默认会执行AdaptiveExtensionFactory的无参构造方法，这里给出AdaptiveExtensionFactory的完整代码。

package com.alibaba.dubbo.common.extension.factory;

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

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

/**
 * AdaptiveExtensionFactory
 *
 * @author william.liangf
 */
@Adaptive
public class AdaptiveExtensionFactory implements ExtensionFactory {

    private final List<ExtensionFactory> factories;

    /**
      * 遍历cachedClasses中缓存的extensionClasses的key，之后根据key来实例化对应的实现类，最后放置到EXTENSION_INSTANCES缓存中
     **/
    public AdaptiveExtensionFactory() {
        ExtensionLoader<ExtensionFactory> loader = ExtensionLoader.getExtensionLoader(ExtensionFactory.class);
        List<ExtensionFactory> list = new ArrayList<ExtensionFactory>();
        for (String name : loader.getSupportedExtensions()) {
            list.add(loader.getExtension(name));
        }
        factories = Collections.unmodifiableList(list);
    }

    public <T> T getExtension(Class<T> type, String name) {
        for (ExtensionFactory factory : factories) {
            T extension = factory.getExtension(type, name);
            if (extension != null) {
                return extension;
            }
        }
        return null;
    }

}

从上可以看出，这个装饰器类只是实例化好了各个ExtensionFactory（这里是指SpiExtensionFactory和SpringExtensionFactory），后续通过工厂获取实现类实例都是由具体的工厂来完成。

来看一下实例化代码的地方，即 loader.getExtension(name)方法：

/**
     * 返回指定名字的扩展。如果指定名字的扩展不存在，则抛异常
     * 从cachedInstances缓存中获取name对应的实例，如果没有，通过createExtension(name)创建，之后放入缓存。
     *  getExtension(String name)
     *    --createExtension(String name)
     *    ----injectExtension( T instance )
     *
     */
    @SuppressWarnings("unchecked")
    public T getExtension(String name) {
        if (name == null || name.length() == 0)
            throw new IllegalArgumentException("Extension name == null");
        if ("true".equals(name)) {
            return getDefaultExtension();
        }
        Holder<Object> holder = cachedInstances.get(name);
        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;
    }

在看一下createExtension(String name)方法

private T createExtension(String name) {
        /**从cachedClasses缓存中获取所有的实现类map，之后通过name获取到对应的实现类的Class对象**/
        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, (T) clazz.newInstance());
                instance = (T) EXTENSION_INSTANCES.get(clazz);
            }
            injectExtension(instance);
            Set<Class<?>> wrapperClasses = cachedWrapperClasses;
            if (wrapperClasses != null && wrapperClasses.size() > 0) {
                for (Class<?> wrapperClass : wrapperClasses) {
                    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);
        }
    }

这里，就体现了了dubbo-SPI比JDK-SPI的好处：dubbo-SPI不需要遍历所有的实现类来获取想要的内容，可以直接通过name来获取。

看下

ExtensionLoader<Protocol> loader = ExtensionLoader.getExtensionLoader(Protocol.class);

的执行结果：

在执行完

final Protocol dubboProtocol = loader.getExtension("dubbo");

结果（两张图）

【参考文档】

https://www.cnblogs.com/java-zhao/p/7617285.html