1.读dubbo spi机制源码

首先从获取拓展加载器说起

    @Override
    @SuppressWarnings("unchecked")
    public  ExtensionLoader getExtensionLoader(Class type) {
        checkDestroyed();
        if (type == null) {
            throw new IllegalArgumentException("Extension type == null");
        }
        if (!type.isInterface()) {
            throw new IllegalArgumentException("Extension type (" + type + ") is not an interface!");
        }
        if (!withExtensionAnnotation(type)) {
            throw new IllegalArgumentException("Extension type (" + type +
                ") is not an extension, because it is NOT annotated with @" + SPI.class.getSimpleName() + "!");
        }

        // 1. find in local cache
        ExtensionLoader loader = (ExtensionLoader) extensionLoadersMap.get(type);

        ExtensionScope scope = extensionScopeMap.get(type);
        if (scope == null) {
            SPI annotation = type.getAnnotation(SPI.class);
            scope = annotation.scope();
            extensionScopeMap.put(type, scope);
        }

        if (loader == null && scope == ExtensionScope.SELF) {
            // create an instance in self scope
            loader = createExtensionLoader0(type);
        }

        // 2. find in parent
        if (loader == null) {
            if (this.parent != null) {
                loader = this.parent.getExtensionLoader(type);
            }
        }

        // 3. create it
        if (loader == null) {
            loader = createExtensionLoader(type);
        }

        return loader;
    }

①首先去当前对象的extensionLoadersMap(ConcurrentHashMap)属性成员中获取是否有对应type Class类的加载器
②再到当前对象的extensionScopeMap(ConcurrentHashMap)属性成员中获取对应type Class的Spi注解scope属性范围
③如果没有,就去获取type Class上面的SPI注解
④拿到SPI注解中Scope的值(默认是ExtensionScope.APPLICATION)
⑤存入当前对象的extensionScopeMap(ConcurrentHashMap)属性成员中
⑥如果第①步拿到的成员是空,且第②步拿到的scope是self,则创建一个self的loader
⑦如果scope属性值不是self且属性成员parent不为空,那么到parent中取获取加载器
⑧如果还获取不到，那么开始创建loader

这里我们重点跟踪下第⑧部的默认创建loader步骤

    private  ExtensionLoader createExtensionLoader(Class type) {
        ExtensionLoader loader = null;
        if (isScopeMatched(type)) {
            // if scope is matched, just create it
            loader = createExtensionLoader0(type);
        }
        return loader;
    }

①检查下type Class上面的SPI注解里面的scope默认值是否和传进来的一致
②如果scope匹配,则开始创建

    private  ExtensionLoader createExtensionLoader0(Class type) {
        checkDestroyed();
        ExtensionLoader loader;
        // ①直接通过new 一个ExtensionLoader对象(这里就会进行这个对象的一些初始化操作了,后续一些用到的属性都是在这个初始化操作完成的,我们后面遇到再重点提起)
        // ②存入当前对象成员属性extensionLoadersMap
        extensionLoadersMap.putIfAbsent(type, new ExtensionLoader(type, this, scopeModel));
        // ③直接从当前对象成员属性extensionLoadersMap根据type获取对应的loader返回
        loader = (ExtensionLoader) extensionLoadersMap.get(type);
        return loader;
    }

①直接通过new 一个ExtensionLoader对象(这里就会进行这个对象的一些初始化操作了,后续一些用到的属性都是在这个初始化操作完成的,我们后面遇到再重点提起)
②存入当前对象成员属性extensionLoadersMap
③直接从当前对象成员属性extensionLoadersMap根据type获取对应的loader返回

好，此时我们已经拿到ExtensionLoader对象了，可以调用getExtension来获取对应实例

    public T getExtension(String name) {
        // ①根据名字及允许包装来获取实例
        T extension = getExtension(name, true);
        // ②如果没有获取到,则抛异常
        if (extension == null) {
            throw new IllegalArgumentException("Not find extension: " + name);
        }
        return extension;
    }

①根据名字及允许包装来获取实例
②如果没有获取到,则抛异常

    public T getExtension(String name, boolean wrap) {
        checkDestroyed();
        if (StringUtils.isEmpty(name)) {
            throw new IllegalArgumentException("Extension name == null");
        }
        // ①如果name是"true"则获取默认的spi对象
        if ("true".equals(name)) {
            return getDefaultExtension();
        }
        // ②获取cacheKey，如果不允许包装,则通过拼接_origin来控制返回原对象
        String cacheKey = name;
        if (!wrap) {
            cacheKey += "_origin";
        }
        // ③获取生成的cacheKey对应的holder
        final Holder