java SPI 04-spi dubbo 实现源码解析

ゝ一纸荒年。 2023-02-19 02:29 11阅读 0赞

## 系列目录 ##

[spi 01-spi 是什么？入门使用][spi 01-spi]

[spi 02-spi 的实战解决 slf4j 包冲突问题][spi 02-spi _ slf4j]

[spi 03-spi jdk 实现源码解析][spi 03-spi jdk]

[spi 04-spi dubbo 实现源码解析][spi 04-spi dubbo]

[spi 05-dubbo adaptive extension 自适应拓展][spi 05-dubbo adaptive extension]

[spi 06-自己从零手写实现 SPI 框架][spi 06-_ SPI]

[spi 07-自动生成 SPI 配置文件实现方式][spi 07-_ SPI]

## dubbo spi ##

而Dubbo中最核心的一点就是SPI和自适应扩展，Dubbo的高扩展性以及其它功能都是在这个基础上实现的，理解掌握其原理才能看懂后面的一系列功能的实现原理，对我们平时实现高扩展性也非常有帮助。

针对 java 原生 SPI 的不足，dubbo 做了哪些改进呢？

我们可以一起来看一看。

需要特别说明的是，本篇文章以及本系列其他文章所分析的源码版本均为 dubbo-2.6.4。

## Dubbo SPI 示例 ##

Dubbo 并未使用 Java SPI，而是重新实现了一套功能更强的 SPI 机制。

Dubbo SPI 的相关逻辑被封装在了 ExtensionLoader 类中，通过 ExtensionLoader，我们可以加载指定的实现类。

### 配置差异 ###

Dubbo SPI 所需的配置文件需放置在 META-INF/dubbo 路径下，配置内容如下。

optimusPrime = org.apache.spi.OptimusPrime
    bumblebee = org.apache.spi.Bumblebee

与 Java SPI 实现类配置不同，Dubbo SPI 是通过键值对的方式进行配置，这样我们可以按需加载指定的实现类。

另外，在测试 Dubbo SPI 时，需要在 Robot 接口上标注 `@SPI` 注解。

### 用法演示 ###

下面来演示 Dubbo SPI 的用法：

public class DubboSPITest { 
    
        @Test
        public void sayHello() throws Exception { 
            ExtensionLoader<Robot> extensionLoader = 
                ExtensionLoader.getExtensionLoader(Robot.class);
            Robot optimusPrime = extensionLoader.getExtension("optimusPrime");
            optimusPrime.sayHello();
            Robot bumblebee = extensionLoader.getExtension("bumblebee");
            bumblebee.sayHello();
        }
    
    }

Dubbo SPI 除了支持按需加载接口实现类，还增加了 IOC 和 AOP 等特性，这些特性将会在接下来的源码分析章节中一一进行介绍。

## Dubbo SPI 源码分析 ##

上一章简单演示了 Dubbo SPI 的使用方法。

我们首先通过 ExtensionLoader 的 getExtensionLoader 方法获取一个 ExtensionLoader 实例，然后再通过 ExtensionLoader 的 getExtension 方法获取拓展类对象。

这其中，getExtensionLoader 方法用于从缓存中获取与拓展类对应的 ExtensionLoader，若缓存未命中，则创建一个新的实例。

该方法的逻辑比较简单，本章就不进行分析了。

下面我们从 ExtensionLoader 的 getExtension 方法作为入口，对拓展类对象的获取过程进行详细的分析。

### 对象获取 ###

public T getExtension(String name) { 
        if (name == null || name.length() == 0)
            throw new IllegalArgumentException("Extension name == null");
        if ("true".equals(name)) { 
            // 获取默认的拓展实现类
            return getDefaultExtension();
        }
        // Holder，顾名思义，用于持有目标对象
        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 中
                    holder.set(instance);
                }
            }
        }
        return (T) instance;
    }

ps: 这里使用 DLC 解决了并发安全问题。

上面代码的逻辑比较简单，首先检查缓存，缓存未命中则创建拓展对象。

### 对象创建 ###

下面我们来看一下创建拓展对象的过程是怎样的。

private T createExtension(String name) { 
        // 从配置文件中加载所有的拓展类，可得到“配置项名称”到“配置类”的映射关系表
        Class<?> clazz = getExtensionClasses().get(name);
        if (clazz == null) { 
            throw findException(name);
        }
        try { 
            T instance = (T) EXTENSION_INSTANCES.get(clazz);
            if (instance == null) { 
                // 通过反射创建实例
                EXTENSION_INSTANCES.putIfAbsent(clazz, clazz.newInstance());
                instance = (T) EXTENSION_INSTANCES.get(clazz);
            }
            // 向实例中注入依赖
            injectExtension(instance);
            Set<Class<?>> wrapperClasses = cachedWrapperClasses;
            if (wrapperClasses != null && !wrapperClasses.isEmpty()) { 
                // 循环创建 Wrapper 实例
                for (Class<?> wrapperClass : wrapperClasses) { 
                    // 将当前 instance 作为参数传给 Wrapper 的构造方法，并通过反射创建 Wrapper 实例。
                    // 然后向 Wrapper 实例中注入依赖，最后将 Wrapper 实例再次赋值给 instance 变量
                    instance = injectExtension(
                        (T) wrapperClass.getConstructor(type).newInstance(instance));
                }
            }
            return instance;
        } catch (Throwable t) { 
            throw new IllegalStateException("...");
        }
    }

ps: 这是实现了 IOC

createExtension 方法的逻辑稍复杂一下，包含了如下的步骤：

1.  通过 getExtensionClasses 获取所有的拓展类
2.  通过反射创建拓展对象
3.  向拓展对象中注入依赖
4.  将拓展对象包裹在相应的 Wrapper 对象中

以上步骤中，第一个步骤是加载拓展类的关键，第三和第四个步骤是 Dubbo IOC 与 AOP 的具体实现。

在接下来的章节中，将会重点分析 getExtensionClasses 方法的逻辑，以及简单介绍 Dubbo IOC 的具体实现。

### 获取所有的拓展类 ###

我们在通过名称获取拓展类之前，首先需要根据配置文件解析出拓展项名称到拓展类的映射关系表，之后再根据拓展项名称从映射关系表中取出相应的拓展类即可。

相关过程的代码分析如下：

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;
    }

这里也是先检查缓存，若缓存未命中，则通过 synchronized 加锁。

加锁后再次检查缓存，并判空。

此时如果 classes 仍为 null，则通过 loadExtensionClasses 加载拓展类。

下面分析 loadExtensionClasses 方法的逻辑。

private Map<String, Class<?>> loadExtensionClasses() { 
        // 获取 SPI 注解，这里的 type 变量是在调用 getExtensionLoader 方法时传入的
        final SPI defaultAnnotation = type.getAnnotation(SPI.class);
        if (defaultAnnotation != null) { 
            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...");
                }
    
                // 设置默认名称，参考 getDefaultExtension 方法
                if (names.length == 1) { 
                    cachedDefaultName = names[0];
                }
            }
        }
    
        Map<String, Class<?>> extensionClasses = new HashMap<String, Class<?>>();
        // 加载指定文件夹下的配置文件
        loadDirectory(extensionClasses, DUBBO_INTERNAL_DIRECTORY);
        loadDirectory(extensionClasses, DUBBO_DIRECTORY);
        loadDirectory(extensionClasses, SERVICES_DIRECTORY);
        return extensionClasses;
    }

ps： 这里会进行 `@SPI` 注解的一些判断和处理。个人感觉通过注解，可以达到更加灵活的控制。

loadExtensionClasses 方法总共做了两件事情，一是对 SPI 注解进行解析，二是调用 loadDirectory 方法加载指定文件夹配置文件。

SPI 注解解析过程比较简单，无需多说。

下面我们来看一下 loadDirectory 做了哪些事情。

private void loadDirectory(Map<String, Class<?>> extensionClasses, String dir) { 
        // fileName = 文件夹路径 + type 全限定名 
        String fileName = dir + type.getName();
        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("...");
        }
    }

ps: 这个和 java 的家在加载非常类似。

loadDirectory 方法先通过 classLoader 获取所有资源链接，然后再通过 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 方法对类进行缓存
                                loadClass(extensionClasses, resourceURL, 
                                          Class.forName(line, true, classLoader), name);
                            }
                        } catch (Throwable t) { 
                            IllegalStateException e = new IllegalStateException("Failed to load extension class...");
                        }
                    }
                }
            } finally { 
                reader.close();
            }
        } catch (Throwable t) { 
            logger.error("Exception when load extension class...");
        }
    }

loadResource 方法用于读取和解析配置文件，并通过反射加载类，最后调用 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("...");
        }
    
        // 检测目标类上是否有 Adaptive 注解
        if (clazz.isAnnotationPresent(Adaptive.class)) { 
            if (cachedAdaptiveClass == null) { 
                // 设置 cachedAdaptiveClass缓存
                cachedAdaptiveClass = clazz;
            } else if (!cachedAdaptiveClass.equals(clazz)) { 
                throw new IllegalStateException("...");
            }
            
        // 检测 clazz 是否是 Wrapper 类型
        } else if (isWrapperClass(clazz)) { 
            Set<Class<?>> wrappers = cachedWrapperClasses;
            if (wrappers == null) { 
                cachedWrapperClasses = new ConcurrentHashSet<Class<?>>();
                wrappers = cachedWrapperClasses;
            }
            // 存储 clazz 到 cachedWrapperClasses 缓存中
            wrappers.add(clazz);
            
        // 程序进入此分支，表明 clazz 是一个普通的拓展类
        } else { 
            // 检测 clazz 是否有默认的构造方法，如果没有，则抛出异常
            clazz.getConstructor();
            if (name == null || name.length() == 0) { 
                // 如果 name 为空，则尝试从 Extension 注解中获取 name，或使用小写的类名作为 name
                name = findAnnotationName(clazz);
                if (name.length() == 0) { 
                    throw new IllegalStateException("...");
                }
            }
            // 切分 name
            String[] names = NAME_SEPARATOR.split(name);
            if (names != null && names.length > 0) { 
                Activate activate = clazz.getAnnotation(Activate.class);
                if (activate != null) { 
                    // 如果类上有 Activate 注解，则使用 names 数组的第一个元素作为键，
                    // 存储 name 到 Activate 注解对象的映射关系
                    cachedActivates.put(names[0], activate);
                }
                for (String n : names) { 
                    if (!cachedNames.containsKey(clazz)) { 
                        // 存储 Class 到名称的映射关系
                        cachedNames.put(clazz, n);
                    }
                    Class<?> c = extensionClasses.get(n);
                    if (c == null) { 
                        // 存储名称到 Class 的映射关系
                        extensionClasses.put(n, clazz);
                    } else if (c != clazz) { 
                        throw new IllegalStateException("...");
                    }
                }
            }
        }
    }

如上，loadClass 方法操作了不同的缓存，比如 cachedAdaptiveClass、cachedWrapperClasses 和 cachedNames 等等。

除此之外，该方法没有其他什么逻辑了。

## 参考资料 ##

[dubbo SPI 官方文档][dubbo SPI]

[dubbo adaptive extension 官方文档][dubbo adaptive extension]

[Dubbo——SPI 及自适应扩展原理][Dubbo_SPI]

[深入理解 SPI 机制][SPI]

[spi 01-spi]: https://houbb.github.io/2018/08/02/spi-01-intro
[spi 02-spi _ slf4j]: https://houbb.github.io/2018/08/02/spi-02-log-adaptor
[spi 03-spi jdk]: https://houbb.github.io/2018/08/02/spi-03-java-source-code
[spi 04-spi dubbo]: https://houbb.github.io/2018/08/02/spi-04-dubbo-spi
[spi 05-dubbo adaptive extension]: https://houbb.github.io/2018/08/02/spi-05-dubbo-adaptive-extension
[spi 06-_ SPI]: https://houbb.github.io/2018/08/02/spi-06-hand-write
[spi 07-_ SPI]: https://houbb.github.io/2018/08/02/spi-07-auto-generate
[dubbo SPI]: http://dubbo.apache.org/zh-cn/docs/source_code_guide/dubbo-spi.html
[dubbo adaptive extension]: http://dubbo.apache.org/zh-cn/docs/source_code_guide/adaptive-extension.html
[Dubbo_SPI]: https://www.cnblogs.com/yewy/p/13111828.html
[SPI]: https://www.cnblogs.com/zhangww/p/12024759.html