Dubbo SPI机制学习总结(持续更新...)

参考文章：Dubbo的SPI机制分析

首先来看看 Java SPI 的机制

Java SPI 起初是提供给厂商做插件开发用的，例如数据库驱动java.sql.Driver，市面上各种各样的数据库，不同的数据库底层协议都不一样，为了方便开发者调用数据库而不用关心它们之间的差异，因此必须提供一个统一的接口来规范和约束这些数据库。有了统一的接口，数据库厂商就可以按照规范去开发自己的数据库驱动了。

厂商开发好数据库驱动了，应用如何使用呢？该使用哪个驱动呢？以 MySQL 为例，早期手写 JDBC 时，开发者需要手动注册驱动，现在已经不需要了，就是利用了 SPI 机制。

Java SPI 使用了策略模式，一个接口多种实现，开发者面向接口编程，具体的实现并不在程序中直接硬编码，而是通过外部文件进行配置。

Java SPI 约定了一个规范，使用步骤如下：

编写一个接口。
编写具体实现类。
在 ClassPath 下的META-INF/services，目录创建以接口全限定名命名的文件，文件内容为实现类的全限定名，多个实现用换行符分割。
通过 ServiceLoader 类获取具体实现。

接口：

实现类：

public class Driver extends NonRegisteringDriver implements java.sql.Driver {public Driver() throws SQLException {}static {try {DriverManager.registerDriver(new Driver());} catch (SQLException var1) {throw new RuntimeException("Can't register driver!");}}
}

简单实例

package org.sun.spi.services;/*** 这是java 的 spi, 没有@SPI注解, 类似 mySQL*/
public interface Say {void say();
}

实现类1

package org.sun.spi.impl;import org.sun.spi.services.Say;public class SayImpl implements Say {@Overridepublic void say() {System.out.println("nihao .....");}
}

实现类2

package org.sun.spi.impl;import org.sun.spi.services.Say;public class SayWrapper implements Say {@Overridepublic void say() {System.out.println("hello SayWrapper。。。。");}
}

META-INF/services 文件

测试：

public class Main {public static void main(String[] args) {ServiceLoader<Say> serviceLoader = ServiceLoader.load(Say.class);serviceLoader.forEach(say -> say.say());}

结果：

nihao .....
hello SayWrapper。。。。

Dubbo SPI机制

Dubbo SPI 定义了一套自己的规范，同时对 Java SPI 存在的问题进行了改进，优点如下：

扩展类按需加载，节约资源。
SPI 文件采用 Key=Value 形式，可以根据扩展名灵活获取实现类。
扩展类对象做了缓存，避免重复创建。
扩展类加载失败有详细日志，方便排查。支持 AOP 和 IOC。

Dubbo SPI 使用规范：

编写接口，接口必须加@SPI 注解，代表它是一个可扩展的接口。
编写实现类。
在 ClassPath 下的META-INF/dubbo，目录创建以接口全限定名命名的文件，文件内容为 Key=Value 格式，Key 是扩展点的名称，Value 是扩展点实现类的全限定名。
通过 ExtensionLoader 类获取扩展点实现。

Dubbo 默认会扫描META-INF/services
、META-INF/dubbo
、META-INF/dubbo/internal
三个目录下的配置，第一个是为了兼容 Java SPI，第三个是 Dubbo 内部使用的扩展点。

测试用例

// TODO

源码分析：

ExtensionLoader.getExtensionLoader

getExtension()

public T getExtension(String name, boolean wrap) {checkDestroyed();if (StringUtils.isEmpty(name)) {throw new IllegalArgumentException("Extension name == null");}// 如果 name 为true，则返回一个默认的扩展点if ("true".equals(name)) {return getDefaultExtension();}String cacheKey = name;if (!wrap) {cacheKey += "_origin";}// 创建或者返回一个holder对象， 用于缓存扩展类的实例final Holder<Object> holder = getOrCreateHolder(cacheKey);Object instance = holder.get();// 如果缓存不存在则创建一个实例if (instance == null) {// 同步设置，懒汉模式synchronized (holder) {instance = holder.get();if (instance == null) {instance = createExtension(name, wrap);holder.set(instance);}}}return (T) instance;

PS : 有意思的类，学习

/*** 持有一个泛型* Helper Class for hold a value.*/
public class Holder<T> {// 保证线程可见性private volatile T value;public void set(T value) {this.value = value;}public T get() {return value;}}

上述代码就是先查缓存，如果未命中，则创建一个扩展对象，createExtension() 应该就是去指定的路径下查找name 对应的扩展点实现，并且实例化之后返回。

@SuppressWarnings("unchecked")private T createExtension(String name, boolean wrap) {// 根据 name 返回扩展类Class<?> clazz = getExtensionClasses().get(name);if (clazz == null || unacceptableExceptions.contains(name)) {throw findException(name);}try {// 从缓存中查找该类是否已经初始化// ConcurrentMap<Class<?>, Object> extensionInstances = new ConcurrentHashMap<>(64);T instance = (T) extensionInstances.get(clazz);if (instance == null) {// 如果没有，则重新创建一个实例并加入缓存， 反射机制extensionInstances.putIfAbsent(clazz, createExtensionInstance(clazz));instance = (T) extensionInstances.get(clazz);// 初始化前的相关操作instance = postProcessBeforeInitialization(instance, name);// 依赖注入injectExtension(instance);instance = postProcessAfterInitialization(instance, name);}if (wrap) {// 通过 Wrapper 进行包装List<Class<?>> wrapperClassesList = new ArrayList<>();if (cachedWrapperClasses != null) {wrapperClassesList.addAll(cachedWrapperClasses);wrapperClassesList.sort(WrapperComparator.COMPARATOR);Collections.reverse(wrapperClassesList);}if (CollectionUtils.isNotEmpty(wrapperClassesList)) {for (Class<?> wrapperClass : wrapperClassesList) {Wrapper wrapper = wrapperClass.getAnnotation(Wrapper.class);boolean match = (wrapper == null) ||((ArrayUtils.isEmpty(wrapper.matches()) || ArrayUtils.contains(wrapper.matches(), name)) &&!ArrayUtils.contains(wrapper.mismatches(), name));if (match) {instance = injectExtension((T) wrapperClass.getConstructor(type).newInstance(instance));instance = postProcessAfterInitialization(instance, name);}}}}// Warning: After an instance of Lifecycle is wrapped by cachedWrapperClasses, it may not still be Lifecycle instance, this application may not invoke the lifecycle.initialize hook.initExtension(instance);return instance;} catch (Throwable t) {throw new IllegalStateException("Extension instance (name: " + name + ", class: " +type + ") couldn't be instantiated: " + t.getMessage(), t);}}

继续跟踪getExtensionClasses

从缓存中获取已经被加载的扩展类
如果未命中缓存，则调用loadExtensionClasses 加载扩展类

 private Map<String, Class<?>> getExtensionClasses() {// Holder<Map<String, Class<?>>> cachedClasses = new Holder<>();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*/private Map<String, Class<?>> loadExtensionClasses() {checkDestroyed();// 获得当前type扩展接口的默认扩展对象， 并且缓存cacheDefaultExtensionName();Map<String, Class<?>> extensionClasses = new HashMap<>();for (LoadingStrategy strategy : strategies) {// 加载指定文件目录下的配置文件loadDirectory(extensionClasses, strategy, type.getName());// compatible with old ExtensionFactoryif (this.type == ExtensionInjector.class) {loadDirectory(extensionClasses, strategy, ExtensionFactory.class.getName());}}return extensionClasses;}

(精彩后续，请看下回分解)