Dubbo中的SPI源码分析

前言

本来是在写Dubbo的消费者初始化过程源码解析的，结果源码看着看着发现SPI还是其中一个比较重要的知识点，因此先跳出来单独写一篇关于Dubbo中SPI的。

什么是SPI

这里不准备讲太多，简单说一下我所知道的JDK中的SPI技术，大概描述一下就是，一个接口I有多个实现类A、B、C，我可以通过ServiceLoader.load(I.class)这样加载接口的方式得到它的实现类列表，而我具体需要加载A、B、C中的哪几个不需要硬编码在代码中，而是可以在META-INF下的某个文件中配置。有一个大概的概念之后，我们开始进入正题来看Dubbo中的SPI使用。

源码解析

在Dubbo中的ReferenceConfig类有如下的常量定义，这就是Dubbo中典型的SPI应用

    private static final Protocol refprotocol = ExtensionLoader.getExtensionLoader(Protocol.class).getAdaptiveExtension();

    private static final Cluster cluster = ExtensionLoader.getExtensionLoader(Cluster.class).getAdaptiveExtension();
    
    private static final ProxyFactory proxyFactory = ExtensionLoader.getExtensionLoader(ProxyFactory.class).getAdaptiveExtension();

接下来以proxyFactory对象的生成过程进行分析。首先来看一下getExtensionLoader(Class type)方法的源码

    @SuppressWarnings("unchecked")
    public static  ExtensionLoader getExtensionLoader(Class 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 loader = (ExtensionLoader) EXTENSION_LOADERS.get(type);
        if (loader == null) {
            EXTENSION_LOADERS.putIfAbsent(type, new ExtensionLoader(type));
            loader = (ExtensionLoader) EXTENSION_LOADERS.get(type);
        }
        return loader;
    }

这里的EXTENSION_LOADERS是一个ConcurrentMap，key和value的定义如下

    private static final ConcurrentMap, ExtensionLoader> EXTENSION_LOADERS        = new ConcurrentHashMap, ExtensionLoader>();

从源码可以看出getExtensionLoader方法主要就是根据传入的类型从EXTENSION_LOADERS找到对应的ExtensionLoader对象，如果不存在就通过new ExtensionLoader(type)创建一个再返回，就是一个简单的单例模式。接下来看一下ExtensionLoader这个构造方法。

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

代码量比较少，首先将type设为一个全局的变量，然后的流程是当传入的参数类型为ExtensionFactory时，objectFactory赋值为null，否则递归调用ExtensionLoader.getExtensionLoader(ExtensionFactory.class).getAdaptiveExtension()方法给objectFactory赋值。那么需要来看一下getAdaptiveExtension()方法了。

    @SuppressWarnings("unchecked")
    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;
    }

可以看到这里是一个很经典的双重检查锁的单例模式实现，保证了instance对象的单例，慢慢来分析。首先看一下cachedAdaptiveInstance对象和它的类定义

    private final Holder