简介
SPI 全称为 Service Provider Interface，是一种服务发现机制。SPI 的本质是将接口实现类的全限定名配置在文件中，并由服务加载器读取配置文件，加载实现类。这样可以在运行时，动态为接口替换实现类。正因此特性，我们可以很容易的通过 SPI 机制为我们的程序提供拓展功能。SPI 机制在第三方框架中也有所应用，比如 Dubbo 就是通过 SPI 机制加载所有的组件。不过，Dubbo 并未使用 Java 原生的 SPI 机制，而是对其进行了增强，使其能够更好的满足需求。在 Dubbo 中，SPI 是一个非常重要的模块。基于 SPI，我们可以很容易的对 Dubbo 进行拓展。如果大家想要学习 Dubbo 的源码，SPI 机制务必弄懂。接下来，我们先来了解一下 Java SPI 与 Dubbo SPI 的用法，然后再来分析 Dubbo SPI 的源码
Dubbo SPI 源码
dubbo SPI 是首先通过 ExtensionLoader 的 getExtensionLoader 方法获取一个 ExtensionLoader 实例，然后再通过 ExtensionLoader 的 getExtension 方法获取拓展类对象。这其中，getExtensionLoader 方法用于从缓存中获取与拓展类对应的 ExtensionLoader，若缓存未命中，则创建一个新的实例。下面从dubbo源码的单元测试处开始分析源码，入口如下图：
简单看一下 ExtensionLoader 类，源码如下：
ExtensionLoader 中最核心的就是加载自己项目 META-INF/services/、META-INF/dubbo/、META-INF/dubbo/internal 这三个目录下的所有class。这里也为后续加载自己扩展类做好了铺垫，自己的扩展类只需要放到这三个目录的任意目录下就可以直接加载到 spring 容器中。
下面接着看 ExtensionLoader 中的 getExtensionLoader 方法，该方法没有什么复杂逻辑，只是获取了 ExtensionLoader 的实例，如下图：
加载class的核心方法就是 ExtensionLoader 的 getExtension 方法，代码如下：
public T getExtension(String name) {
if (StringUtils.isEmpty(name)) {
throw new IllegalArgumentException("Extension name == null");
}
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 方法的过程是怎么样的呢？下面看看代码：
private T createExtension(String name) {
// 从配置文件中获取所有的配置类，得到键值对（key：配置项名称，value：配置类），即配置项名称和配置类的映射关系
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 中注入依赖，最后再赋值给 instance 变量
instance = injectExtension((T) wrapperClass.getConstructor(type).newInstance(instance));
}
}
return instance;
} catch (Throwable t) {
throw new IllegalStateException("Extension instance (name: " + name + ", class: " +
type + ") couldn't be instantiated: " + t.getMessage(), t);
}
}createExtension 方法包含了如下四个步骤：
1、通过 getExtensionClasses 获取所有的拓展类
2、通过反射创建拓展对象
3、向拓展对象中注入依赖
4、将拓展对象包裹在相应的 Wrapper 对象中
以上步骤中，第一个步骤是加载拓展类的关键，第三和第四个步骤是 Dubbo IOC 与 AOP 的具体实现。接下来将会重点分析 getExtensionClasses 方法的逻辑，以及简单介绍 Dubbo IOC 的具体实现
获取指定文件夹下的所有扩展类
在我们通过名称获取拓展类之前，首先需要根据配置文件解析出拓展项名称到拓展类的映射关系表（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 in getExtensionClasses
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;
}
/**
* extract and cache default extension name if exists
*/
private void cacheDefaultExtensionName() {
// 获取spi注解，这里的 type 是 getExtensionLoader 传入的
final SPI defaultAnnotation = type.getAnnotation(SPI.class);
if (defaultAnnotation != null) {
// spi注解value值
String value = defaultAnnotation.value();
if ((value = value.trim()).length() > 0) {
// 以“,”分隔value值，多个值会报错
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 方法主要做了两件事情：
1、解析spi注解，获取默认的扩展类名称
2、加载指定文件下的配置扩展类
loadDirectory 方法是怎么加载配置扩展类的呢，代码如下：
private void loadDirectory(Map<String, Class<?>> extensionClasses, String dir, String type) {
// 具体的文件路径，例如 dir(META-INF/dubbo/internal/) + type (org.apache.dubbo.container.Container) =
// META-INF/dubbo/internal/org.apache.dubbo.container.Container
String fileName = dir + type;
try {
Enumeration<java.net.URL> urls;
ClassLoader classLoader = findClassLoader();
// 根据文件名加载所有的同名文件
if (classLoader != null) {
// classLoader获取资源链接
urls = classLoader.getResources(fileName);
} else {
// classLoader获取资源链接
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);
}
}loadDirectory 方法中通过 classLoader 获取资源链接，然后调用 loadResource 方法加载资源文件， 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;
int i = line.indexOf('=');
if (i > 0) {
// "=" 左边的值为扩展类名称
name = line.substring(0, i).trim();
// "=" 右边的值为扩展类
line = line.substring(i + 1).trim();
}
if (line.length() > 0) {
// 通过反射 Class.forName 方法加载类，然后调用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);
}
}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("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)) {
// 类是否有Adaptive注解，设置AdaptiveClass缓存
cacheAdaptiveClass(clazz);
} else if (isWrapperClass(clazz)) {
// 类是否是 Wrapper类型，设置WrapperClass缓存
cacheWrapperClass(clazz);
} else {
// 普通的扩展类
// 获取无参构造方法
clazz.getConstructor();
if (StringUtils.isEmpty(name)) {
// name为空时则从 Extension 注解中过去，注解还获取不到的话，则使用小写的类名作为名称
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)) {
// 类上是否有 Activate 注解，如果有缓存下来
cacheActivateClass(clazz, names[0]);
for (String n : names) {
// 存储类和类名称映射关系到map中
cacheName(clazz, n);
// 存储类名称和类的映射关系
saveInExtensionClass(extensionClasses, clazz, n);
}
}
}
}
@SuppressWarnings("deprecation")
private String findAnnotationName(Class<?> clazz) {
// 获取Extension注解
org.apache.dubbo.common.Extension extension = clazz.getAnnotation(org.apache.dubbo.common.Extension.class);
if (extension == null) {
// 类名小写作为name
String name = clazz.getSimpleName();
if (name.endsWith(type.getSimpleName())) {
name = name.substring(0, name.length() - type.getSimpleName().length());
}
return name.toLowerCase();
}
// 返回Extension注解value作为name
return extension.value();
}
loadClass 方法逻辑也比较简单，主要有两种操作：
1、设置了AdaptiveClass缓存、WrapperClass缓存、ActivateClass缓存
2、存储了 类对应类名称映射关系 、 类名称对应类的映射关系
Dubbo IOC
Dubbo IOC 是通过 setter 方法注入依赖。Dubbo 首先会通过反射获取到实例的所有方法，然后再遍历方法列表，检测方法名是否具有 setter 方法特征。若有，则通过 ObjectFactory 获取依赖对象，最后通过反射调用 setter 方法将依赖设置到目标对象中。整个过程对应的代码如下：
private T injectExtension(T instance) {
try {
if (objectFactory != null) {
for (Method method : instance.getClass().getMethods()) {
// 获取实例的所有setter方法
if (isSetter(method)) {
/**
* Check {@link DisableInject} to see if we need auto injection for this property
*/
if (method.getAnnotation(DisableInject.class) != null) {
continue;
}
// 获取方法参数类型
Class<?> pt = method.getParameterTypes()[0];
if (ReflectUtils.isPrimitives(pt)) {
continue;
}
try {
// 获取方法对应的属性名，例如 setName 对应属性名 name
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;
}
/**
* return true if and only if:
* <p>
* 1, public
* <p>
* 2, name starts with "set"
* <p>
* 3, only has one parameter
*/
private boolean isSetter(Method method) {
// 方法是 set 开头，public 类型 且只有一个参数
return method.getName().startsWith("set")
&& method.getParameterTypes().length == 1
&& Modifier.isPublic(method.getModifiers());
}上述 objectFactory 变量的类型为 AdaptiveExtensionFactory，AdaptiveExtensionFactory 内部维护了一个 ExtensionFactory 列表，用于存储其他类型的 ExtensionFactory。Dubbo 目前提供了两种 ExtensionFactory，分别是 SpiExtensionFactory 和 SpringExtensionFactory。
AdaptiveExtensionFactory： ExtensionFactory 列表，包含 SpiExtensionFactory 和 SpringExtensionFactory
SpiExtensionFactory ： 创建自适应的拓展类
SpringExtensionFactory： 用于从 Spring 的 IOC 容器中获取所需的拓展类
Dubbo IOC 目前仅支持 setter 方式注入
dubbo SPI 示例demo
1、org.apache.dubbo.container.spring 目录下创建 DemoContainer 文件，如图所示：
代码如下：
package org.apache.dubbo.container.spring;
import org.apache.dubbo.container.Container;
/**
* 测试类
*
* @date 2019-10-21 14:46
**/
public class DemoContainer implements Container {
@Override
public void start() {
System.out.println("start method is run");
}
@Override
public void stop() {
System.out.println("stop method is run");
}
}2、META-INF/dubbo/internal 目前下的 org.apache.dubbo.container.Container 文件增加 demo=org.apache.dubbo.container.spring.DemoContainer，如下图所示：
3、增加测试demo，代码如下：
package org.apache.dubbo.container.spring;
import org.apache.dubbo.common.extension.ExtensionLoader;
import org.apache.dubbo.container.Container;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
/**
* StandaloneContainerTest
*/
public class SpringContainerTest {
@Test
public void testDemo(){
DemoContainer demoContainer = (DemoContainer) ExtensionLoader.getExtensionLoader(Container.class).getExtension("demo");
demoContainer.start();
demoContainer.stop();
}
}运行结果如下图：
参考：
https://dubbo.apache.org/zh-cn/docs/source_code_guide/dubbo-spi.html