Dubbo SPI使用

SPI简介

        SPI 全称为 Service Provider Interface，是一种服务发现机制，刚好与java jdk的类加载机制进行了一个互补。SPI 的本质是将接口实现类的全限定名配置在文件中，并由服务加载器读取配置文件，加载实现类。这样可以在运行时，动态为接口替换实现类。正因此特性，我们可以很容易的通过 SPI 机制为我们的程序提供拓展功能。SPI 机制在第三方框架中也有所应用，比如 Dubbo 就是通过 SPI 机制加载所有的组件。不过，Dubbo 并未使用 Java 原生的 SPI 机制，而是对其进行了增强，使其能够更好的满足需求。在 Dubbo 中，SPI 是一个非常重要的模块。基于 SPI，我们可以很容易的对 Dubbo 进行拓展。如果大家想要学习 Dubbo 的源码，SPI 机制务必弄懂。接下来，我们先来了解一下 Java SPI 与 Dubbo SPI 的用法，然后再来分析 Dubbo SPI 的源码。

Dubbo 并未使用 Java SPI，而是重新实现了一套功能更强的 SPI 机制。Dubbo SPI 的相关逻辑被封装在了 ExtensionLoader 类中，通过 ExtensionLoader，我们可以加载指定的实现类。

SPI示例

        Dubbo SPI所需的配置文件需要放在META-INF/dubbo路径下，与java SPI类似，dubbo SPI的文件名称也是取的是接口的全路径：com.yangfan.spi.dubbo.api.Robot；

optimusPrime = com.yangfan.spi.dubbo.impl.OptimusPrime
bumblebee = com.yangfan.spi.dubbo.impl.Bumblebee
com.yangfan.spi.dubbo.impl.RobotWrapper

与java SPI所不同的是它需要通过键值得方式进行配置，这样我们可以按需加载指定的实现类，具体实现是通过流的方式一行行读取然后根据“=”将具体的实现类信息缓存起来，详情见下面的loadResource及loadClass

 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;int i = line.indexOf('=');if (i > 0) {name = line.substring(0, i).trim();line = line.substring(i + 1).trim();}if (line.length() > 0) {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);}

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.");}if (clazz.isAnnotationPresent(Adaptive.class)) {cacheAdaptiveClass(clazz);} else if (isWrapperClass(clazz)) {cacheWrapperClass(clazz);} else {clazz.getConstructor();if (StringUtils.isEmpty(name)) {name = findAnnotationName(clazz);if (name.length() == 0) {throw new IllegalStateException("No such extension name for the class " + clazz.getName() + " in the config " + resourceURL);}}String[] names = NAME_SEPARATOR.split(name);if (ArrayUtils.isNotEmpty(names)) {cacheActivateClass(clazz, names[0]);for (String n : names) {cacheName(clazz, n);saveInExtensionClass(extensionClasses, clazz, n);}}}}

在测试类中我们可以通过配置文件配置的键值的键来加载指定的实现类，具体的操作代码如下，

@Testpublic void testDubboSPI() {ExtensionLoader<Robot> extensionLoader = ExtensionLoader.getExtensionLoader(Robot.class);Robot optimusPrime = extensionLoader.getExtension("optimusPrime");optimusPrime.sayHello();Robot bumblebee = extensionLoader.getExtension("bumblebee");bumblebee.sayHello();}

运行结果如下：

Hello,I am OptimusPrime
Hello,I am Bumblebee

Dubbo SPI 源码分析

上面简单演示了 Dubbo SPI 的使用方法。我们首先通过 ExtensionLoader 的 getExtensionLoader 方法获取一个 ExtensionLoader 实例，然后再通过 ExtensionLoader 的 getExtension 方法获取拓展类对象。这其中，getExtensionLoader 方法用于从缓存中获取与拓展类对应的 ExtensionLoader，若缓存未命中，则创建一个新的实例。该方法的逻辑比较简单，本章就不进行分析了。下面我们从 ExtensionLoader 的 getExtension 方法作为入口，对拓展类对象的获取过程进行详细的分析。

 public T getExtension(String name) {if (StringUtils.isEmpty(name)) {throw new IllegalArgumentException("Extension name == null");}//获取more的扩展实现类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;}

上面的代码首先是检查缓存，如果缓存未命中，则创建扩展对象，下面分析一下扩展对象的创建过程

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 (CollectionUtils.isNotEmpty(wrapperClasses)) {//循环创建包装类for (Class<?> wrapperClass : wrapperClasses) {// 将当前 instance 作为参数传给 Wrapper 的构造方法，并通过反射创建 Wrapper 实例。// 然后向 Wrapper 实例中注入依赖，最后将 Wrapper 实例再次赋值给 instance 变量instance = injectExtension((T) wrapperClass.getConstructor(type).newInstance(instance));}}initExtension(instance);return instance;} catch (Throwable t) {throw new IllegalStateException("Extension instance (name: " + name + ", class: " +type + ") couldn't be instantiated: " + t.getMessage(), t);}}

核心流程如下图，我习惯把总结为“委托模式aop”，因为实际方法调用仍然是调用作为熟悉传给包装类的具体的接口实现类。这也是Dubbo IOC与AOP的具体实现

总结一下，createExtension主要做了四件事情：

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

加载所有的扩展类

首先需要根据配置文件解析出拓展项名称到拓展类的映射关系，数据存储方式为：Map<名称，拓展类>，后续都是通过拓展类的名称获取到相应的拓展类，源码如下：

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注解的方式，详情自己研究下cacheDefaultExtensionName();Map<String, Class<?>> extensionClasses = new HashMap<>();// internal extension load from ExtensionLoader's ClassLoader first//加载指定文件夹下的配置文件loadDirectory(extensionClasses, DUBBO_INTERNAL_DIRECTORY, type.getName(), true);loadDirectory(extensionClasses, DUBBO_INTERNAL_DIRECTORY, type.getName().replace("org.apache", "com.alibaba"), true);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;}

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

下面研究下 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("...");}
}

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，或使用小写的类名作为 namename = 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 等等。除此之外，该方法没有其他什么逻辑了。