dubbo-SPI机制
借用dubbo官网介绍的设计图，如下：
image
** 说明：图中从下至上分为十层，各层均为单向依赖，右边的黑色箭头代表层之间的依赖关系，每一层都可以剥离上层被复用，其中，Service 和 Config 层为 API，其它各层均为 SPI。**
为了更好的从源码的角度去看设计，需要先理清楚SPI到底是什么东西～
一、基本介绍
SPI 全称为Service Provider Interface,是一种服务发现机制。
本质：将接口实现类的全限定名配置在文件中，并由服务加载器读取配置文件，加载实现类。
好处：优势体现在可以动态的替换实现类，这样可以更好的为我们的程序提供扩展功能。
二、SPI示例
2.1 java SPI 示例
首先定义一个接口：
package com.test;
import com.alibaba.dubbo.common.extension.SPI;
// @SPI("apple")
public interface Fruit {
void eat();
}
两个不同的实现类：
package com.test;
public class Apple implements Fruit {
@Override
public void eat() {
System.out.println("Hello, I am apple");
}
}
package com.test;
public class Banana implements Fruit {
@Override
public void eat() {
System.out.println("Hello, I am Banana.");
}
}
接下来 META-INF/services 文件夹下创建一个文件，名称为 Fruit 的全限定名 com.test.Fruit。文件内容为实现类的全限定的类名，如下：
image
com.test.Apple
com.test.Banana
测试如下：
package com.test;
import com.alibaba.dubbo.common.extension.ExtensionLoader;
import java.util.ServiceLoader;
public class JavaSPITest {
public static void main(String[] args) {
// java spi机制
ServiceLoader<Fruit> serviceLoader = ServiceLoader.load(Fruit.class);
System.out.println("Java SPI");
serviceLoader.forEach(Fruit::eat);
// dubbo spi机制
ExtensionLoader<Fruit> extensionLoader =
ExtensionLoader.getExtensionLoader(Fruit.class);
Fruit apple = extensionLoader.getExtension("apple");
apple.eat();
Fruit banana = extensionLoader.getExtension("banana");
banana.eat();
}
}
Hello, I am apple
Hello, I am Banana.
Process finished with exit code 0
Dubbo 并未使用 Java SPI，而是重新实现了一套功能更强的 SPI 机制。Dubbo SPI 的相关逻辑被封装在了 ExtensionLoader 类中，通过 ExtensionLoader，我们可以加载指定的实现类。Dubbo SPI 所需的配置文件需放置在** META-INF/dubbo** 路径下（同样在该路径下根据接口的全限定名称创建文件），配置内容如下：
apple=com.test.Apple
banana=com.test.Banana
与 Java SPI 实现类配置不同，Dubbo SPI 是通过键值对的方式进行配置，这样我们可以按需加载指定的实现类。另外，在测试 Dubbo SPI 时，需要在** Fruit 接口上标注 @SPI 注解**。
另外，还增加了IOC和AOP等特性，这部分在源码解析时会体现。
统一说明一下，Java SPI 和Dubbo SPI区别？
1.Java SPI虽然也实现了延迟加载，但是基本只能遍历全部，做不到按需进行指定实例化，导致了资源浪费。
2.Dubbo SPI实现了按需加载指定的实现类，另外还增加IOC和AOP等特性。
三、Dubbo SPI 源码分析
代码如下：
ExtensionLoader<Fruit> extensionLoader = ExtensionLoader.getExtensionLoader(Fruit.class);
Fruit apple = extensionLoader.getExtension("apple");
说明：首先通过 ExtensionLoader 的 getExtensionLoader 方法获取一个 ExtensionLoader 实例，然后再通过 ExtensionLoader 的 getExtension 方法获取拓展类对象。这其中，getExtensionLoader 方法用于从缓存中获取与拓展类对应的 ExtensionLoader，若缓存未命中，则创建一个新的实例。
代码如下：
private static final ConcurrentMap<Class<?>, ExtensionLoader<?>> EXTENSION_LOADERS = new ConcurrentHashMap();
// ...
public static <T> ExtensionLoader<T> getExtensionLoader(Class<T> type) {
if (type == null) {
throw new IllegalArgumentException("Extension type == null");
} else if (!type.isInterface()) {
throw new IllegalArgumentException("Extension type(" + type + ") is not interface!");
} else if (!withExtensionAnnotation(type)) {
throw new IllegalArgumentException("Extension type(" + type + ") is not extension, because WITHOUT @" + SPI.class.getSimpleName() + " Annotation!");
} else {
// loader从缓存中获取
ExtensionLoader<T> loader = (ExtensionLoader)EXTENSION_LOADERS.get(type);
if (loader == null) {
// 没有则新建，将loader放入map中
EXTENSION_LOADERS.putIfAbsent(type, new ExtensionLoader(type));
loader = (ExtensionLoader)EXTENSION_LOADERS.get(type);
}
return loader;
}
}
public T getExtension(String name) {
if (StringUtils.isEmpty(name)) {
throw new IllegalArgumentException("Extension name == null");
}
if ("true".equals(name)) {
// 获取默认的拓展实现类
return getDefaultExtension();
}
// Holder，用于持有目标对象
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中
holder.set(instance);
}
}
}
return (T) instance;
}
重点来看看双重检查具体做了哪些事情，有哪些门道～上代码
package org.apache.dubbo.common.utils;
/**
* 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;
}
}
代码中使用了volatile关键字，有什么作用呢？具体请见解析java-volatile解析
private static final ConcurrentMap<Class<?>, Object> EXTENSION_INSTANCES = new ConcurrentHashMap<>(64);
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("...");
}
}
createExtension 方法包含了如下的步骤：
1.通过 getExtensionClasses 获取所有的拓展类
2.通过反射创建拓展对象
3.向拓展对象中注入依赖
4.将拓展对象包裹在相应的 Wrapper 对象中
第一个步骤加载扩展类的关键，第三和第四个步骤是Dubbo IOC和AOP的具体实现。
3.1 获取所有的扩展类
在通过名称获取拓展类之前，首先需要根据配置文件解析出拓展项名称到拓展类的映射关系表（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() {
// 提取以及缓存可能存在的默认扩展类名称
cacheDefaultExtensionName();
//加载策略
Map<String, Class<?>> extensionClasses = new HashMap<>();
for (LoadingStrategy strategy : strategies) {
loadDirectory(extensionClasses, strategy.directory(), type.getName(), strategy.preferExtensionClassLoader(), strategy.overridden(), strategy.excludedPackages());
loadDirectory(extensionClasses, strategy.directory(), type.getName().replace("org.apache", "com.alibaba"), strategy.preferExtensionClassLoader(), strategy.overridden(), strategy.excludedPackages());
}
return extensionClasses;
}
/**
* extract and cache default extension name if exists
*/
private void cacheDefaultExtensionName() {
final SPI defaultAnnotation = type.getAnnotation(SPI.class);
if (defaultAnnotation == null) {
return;
}
String value = defaultAnnotation.value();
if ((value = value.trim()).length() > 0) {
String[] names = NAME_SEPARATOR.split(value);
if (names.length > 1) {
throw new IllegalStateException("More than 1 default extension name on extension " + type.getName()
+ ": " + Arrays.toString(names));
}
if (names.length == 1) {
cachedDefaultName = names[0];
}
}
}
loadExtensionClasses 方法总共做了两件事情，一是对 SPI 注解进行解析，二是调用 loadDirectory 方法加载指定文件夹配置文件。
加载策略代码如下：
private static volatile LoadingStrategy[] strategies = loadLoadingStrategies();
// ...
private static LoadingStrategy[] loadLoadingStrategies() {
return stream(load(LoadingStrategy.class).spliterator(), false)
.sorted()
.toArray(LoadingStrategy[]::new);
}
public static <S> ServiceLoader<S> load(Class<S> service) {
ClassLoader cl = Thread.currentThread().getContextClassLoader();
return ServiceLoader.load(service, cl);
}
LoadingStrategy.png
加载过程解析
ServiceLoader.load方法，利用的是jdk自带的spi机制，加载 LoadingStrategy类的实现类，
jdk的spi机制约定了，接口实现类的描述文件存放位置为：META-INF/services/，文件名称为接口的全限定名，即 org.apache.dubbo.common.extension.LoadingStrategy，文件内容如下：
org.apache.dubbo.common.extension.DubboInternalLoadingStrategy
org.apache.dubbo.common.extension.DubboLoadingStrategy
org.apache.dubbo.common.extension.ServicesLoadingStrategy
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("...");
}
}
