Dubbo源码分析之ExtensionLoader源码分析

参考：http://dubbo.apache.org/zh-cn/docs/source_code_guide/dubbo-spi.html

上篇演示了dubbo spi 的一个小demo,这篇来看看源码，能力有限，不喜勿喷。

上篇的测试用例如下：

@Test
public void testExt2() throws Exception {
    ExtensionLoader<Ext2> extensionLoader = ExtensionLoader.getExtensionLoader(Ext2.class);
    Ext2 impl1 = extensionLoader.getExtension("impl1");
    String value = impl1.echo(new UrlHolder(), "2");
    System.err.println(value);
    //==========================
    Ext2 impl2 = extensionLoader.getExtension("impl2");
    String value2 = impl2.echo(new UrlHolder(), "2");
    System.err.println(value2);
}

我们从getExtensionLoader方法跟进。

@SuppressWarnings("unchecked")
//从缓存当中获取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 an interface!");
    }
    if (!withExtensionAnnotation(type)) {
        throw new IllegalArgumentException("Extension type (" + type +
                ") is not an extension, because it is NOT annotated with @" + SPI.class.getSimpleName() + "!");
    }
    ExtensionLoader<T> loader = (ExtensionLoader<T>) EXTENSION_LOADERS.get(type);
    //没有获取到
    if (loader == null) {
        /***
         * putIfAbsent是ConcurrentHashMap的一个方法。
         * putIfAbsent方法主要是在向ConcurrentHashMap中添加键—值对的时候，它会先判断该键值对是否已经存在。
         如果不存在（新的entry），那么会向map中添加该键值对，并返回null。
         如果已经存在，那么不会覆盖已有的值，直接返回已经存在的值。
         */
        EXTENSION_LOADERS.putIfAbsent(type, new ExtensionLoader<T>(type));
        loader = (ExtensionLoader<T>) EXTENSION_LOADERS.get(type);
    }
    return loader;
}

回到testExt2方法

现在来看Ext2 impl1 = extensionLoader.getExtension("impl1");

参数为一个配置文件里面配置的key,跟进getExtension方法。

public T getExtension(String name) {
    if (StringUtils.isEmpty(name)) {
        throw new IllegalArgumentException("Extension name == null");
    }
    //如果name传入的是true则使用默认的
    if ("true".equals(name)) {
        return getDefaultExtension();
    }
    final Holder<Object> holder = getOrCreateHolder(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方法找到getExtensionClasses方法

/**
 * 获取所有的拓展类
 我们在通过名称获取拓展类之前，首先需要根据配置文件解析出拓展项名称到拓展类的映射关系表（Map<名称, 拓展类>），
 之后再根据拓展项名称从映射关系表中取出相应的拓展类即可。相关过程的代码分析如下：
 * @return
 */
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方法

/**
 * synchronized in getExtensionClasses
 * 则通过 loadExtensionClasses 加载拓展类
 * */
private Map<String, Class<?>> loadExtensionClasses() {

    //SPI操作
    cacheDefaultExtensionName();
    Map<String, Class<?>> extensionClasses = new HashMap<>();
    // 加载指定文件夹下的配置文件
    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;
}

再来看一下SPI的操作，跟进cacheDefaultExtensionName方法

/**
 * extract and cache default extension name if exists
 */
private void cacheDefaultExtensionName() {
    // 获取 SPI 注解，这里的 type 变量是在调用 getExtensionLoader 方法时传入的
    final SPI defaultAnnotation = type.getAnnotation(SPI.class);
    if (defaultAnnotation == null) {
        return;
    }
    String value = defaultAnnotation.value();
    if ((value = value.trim()).length() > 0) {
        // 对 SPI 注解内容进行切分
        String[] names = NAME_SEPARATOR.split(value);
        // 检测 SPI 注解内容是否合法，不合法则抛出异常
        if (names.length > 1) {
            throw new IllegalStateException("More than 1 default extension name on extension " + type.getName()
                    + ": " + Arrays.toString(names));
        }
        // 设置默认名称，参考 getDefaultExtension 方法
        if (names.length == 1) {
            cachedDefaultName = names[0];
        }
    }
}

回到loadExtensionClasses方法看loadDirectory方法

private void loadDirectory(Map<String, Class<?>> extensionClasses, String dir, String type) {
    // fileName = 文件夹路径 + type 全限定名
    String fileName = dir + type;
    try {
        Enumeration<java.net.URL> urls;
        ClassLoader classLoader = findClassLoader();
        // 根据文件名加载所有的同名文件
        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 occurred when loading extension class (interface: " +
                type + ", description file: " + fileName + ").", t);
    }
}

看一下加载资源的方法loadResource方法

private void loadResource(Map<String, Class<?>> extensionClasses, ClassLoader classLoader, java.net.URL resourceURL) {
    try {
        try (BufferedReader reader = new BufferedReader(new InputStreamReader(resourceURL.openStream(), StandardCharsets.UTF_8))) {
            // 按行读取配置内容
            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;
                        // 以等于号 = 为界，截取键与值这里也就是我们在文件里看见的    key=value
                        int i = line.indexOf('=');
                        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);
                    }
                }
            }
        }
    } catch (Throwable t) {
        logger.error("Exception occurred when loading extension class (interface: " +
                type + ", class file: " + resourceURL + ") in " + resourceURL, t);
    }
}

跟进加载类的方法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 occurred when loading extension class (interface: " +
                type + ", class line: " + clazz.getName() + "), class "
                + clazz.getName() + " is not subtype of interface.");
    }
    // 检测目标类上是否有 Adaptive 注解
    if (clazz.isAnnotationPresent(Adaptive.class)) {
        // 设置 cachedAdaptiveClass缓存
        cacheAdaptiveClass(clazz);

    } else if (isWrapperClass(clazz)) {// 检测 clazz 是否是 Wrapper 类型
        cacheWrapperClass(clazz);
    } else {
        // 程序进入此分支，表明 clazz 是一个普通的拓展类
        clazz.getConstructor();
        if (StringUtils.isEmpty(name)) {
            // 如果 name 为空，则尝试从 Extension 注解中获取 name，或使用小写的类名作为 name
            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 (ArrayUtils.isNotEmpty(names)) {
            // 如果类上有 Activate 注解，则使用 names 数组的第一个元素作为键，
            // 存储 name 到 Activate 注解对象的映射关系
            cacheActivateClass(clazz, names[0]);
            for (String n : names) {
                cacheName(clazz, n);
                // 存储 Class 到名称的映射关系
                saveInExtensionClass(extensionClasses, clazz, n);
            }
        }
    }
}

在次回到

看见画红色的方法没，这个就是dubbo的IOC实现

我们现在来分析下

跟进injectExtension方法

Dubbo IOC 是通过 setter 方法注入依赖。Dubbo 首先会通过反射获取到实例的所有方法，然后再遍历方法列表，检测方法名是否具有 setter 方法特征。若有，则通过 ObjectFactory 获取依赖对象，最后通过反射调用 setter 方法将依赖设置到目标对象中。整个过程对应的代码如下：

private T injectExtension(T instance) {
    if (objectFactory == null) {
        return instance;
    }
    try {
        //遍历获取实例对象的所有方法
        for (Method method : instance.getClass().getMethods()) {
            //判断方法是否有setter 方法特征
            // 检测方法是否以 set 开头，且方法仅有一个参数，且方法访问级别为 public
            if (!isSetter(method)) {
                continue;
            }
            /**
             * 看看我们是否需要这个属性的自动注入
             * Check {@link DisableInject}
             */
            if (method.getAnnotation(DisableInject.class) != null) {
                continue;
            }
            Class<?> pt = method.getParameterTypes()[0];
            if (ReflectUtils.isPrimitives(pt)) {
                continue;
            }
            try {
                // 获取 setter 方法参数类型
                String property = getSetterProperty(method);
                // 从 ObjectFactory 中获取依赖对象
                Object object = objectFactory.getExtension(pt, property);
                if (object != null) {
                    // 通过反射调用 setter 方法设置依赖
                    method.invoke(instance, object);
                }
            } catch (Exception e) {
                logger.error("Failed to inject via method " + method.getName()
                        + " of interface " + type.getName() + ": " + e.getMessage(), e);
            }
        }
    } catch (Exception e) {
        logger.error(e.getMessage(), e);
    }
    return instance;
}

Dubbo 目前提供了两种 ExtensionFactory，分别是 SpiExtensionFactory 和 SpringExtensionFactory。前者用于创建自适应的拓展，后者是用于从 Spring 的 IOC 容器中获取所需的拓展。

Dubbo IOC 目前仅支持 setter 方式注入。

以上就是dubbo的SPI源码，注释都写在代码里面的，如有错误之处欢迎各位盆友指正，谢谢@@@~~~~