Dubbo源码解析之SPI机制
1. 简介
Dubbo 并未使用 Java 原生的 SPI 机制，而是对其进行了加强，使其可以更好的知足需求。在 Dubbo 中，SPI 是一个很是重要的模块。基于 SPI，咱们能够很容易的对 Dubbo 进行拓展。java
2. 源码分析
Dubbo SPI 的相关逻辑被封装在了 ExtensionLoader 类中，经过 ExtensionLoader，咱们能够加载指定的实现类。Dubbo SPI 所需的配置文件需放置在 META-INF/dubbo 路径下。数组
咱们首先经过 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;
}
复制代码
上面代码的逻辑比较简单，首先检查缓存，缓存未命中则建立拓展对象。下面咱们来看一下建立拓展对象的过程是怎样的。app
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 方法的逻辑稍复杂一下，包含了以下的步骤：源码分析
- 经过 getExtensionClasses 获取全部的拓展类
- 经过反射建立拓展对象
- 向拓展对象中注入依赖
- 将拓展对象包裹在相应的 Wrapper 对象中
以上步骤中，第一个步骤是加载拓展类的关键，第三和第四个步骤是 Dubbo IOC 与 AOP 的具体实现。在接下来的章节中，将会重点分析 getExtensionClasses 方法的逻辑，以及简单介绍 Dubbo IOC 的具体实现。url
3. 获取全部的拓展类
咱们在经过名称获取拓展类以前，首先须要根据配置文件解析出拓展项名称到拓展类的映射关系表（Map<名称, 拓展类>），以后再根据拓展项名称从映射关系表中取出相应的拓展类便可。相关过程的代码分析以下：spa
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 方法的逻辑。.net
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;
}
复制代码
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("...");
}
}
复制代码
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 IOC 方面的内容。
4. Dubbo IOC
Dubbo IOC 是经过 setter 方法注入依赖。Dubbo 首先会经过反射获取到实例的全部方法，而后再遍历方法列表，检测方法名是否具备 setter 方法特征。如有，则经过 ObjectFactory 获取依赖对象，最后经过反射调用 setter 方法将依赖设置到目标对象中。整个过程对应的代码以下：
private T injectExtension(T instance) {
try {
if (objectFactory != null) {
// 遍历目标类的全部方法
for (Method method : instance.getClass().getMethods()) {
// 检测方法是否以 set 开头，且方法仅有一个参数，且方法访问级别为 public
if (method.getName().startsWith("set")
&& method.getParameterTypes().length == 1
&& Modifier.isPublic(method.getModifiers())) {
// 获取 setter 方法参数类型
Class<?> pt = method.getParameterTypes()[0];
try {
// 获取属性名，好比 setName 方法对应属性名 name
String property = method.getName().length() > 3 ?
method.getName().substring(3, 4).toLowerCase() +
method.getName().substring(4) : "";
// 从 ObjectFactory 中获取依赖对象
Object object = objectFactory.getExtension(pt, property);
if (object != null) {
// 经过反射调用 setter 方法设置依赖
method.invoke(instance, object);
}
} catch (Exception e) {
logger.error("fail to inject via method...");
}
}
}
}
} catch (Exception e) {
logger.error(e.getMessage(), e);
}
return instance;
}
复制代码
在上面代码中，objectFactory 变量的类型为 AdaptiveExtensionFactory，AdaptiveExtensionFactory 内部维护了一个 ExtensionFactory 列表，用于存储其余类型的 ExtensionFactory。Dubbo 目前提供了两种 ExtensionFactory，分别是 SpiExtensionFactory 和 SpringExtensionFactory。前者用于建立自适应的拓展，后者是用于从 Spring 的 IOC 容器中获取所需的拓展。这两个类的类的代码不是很复杂，这里就不一一分析了。
Dubbo IOC 目前仅支持 setter 方式注入，总的来讲，逻辑比较简单易懂。
5. 总结
本篇文章简单分别介绍了 Java SPI 与 Dubbo SPI 用法，并对 Dubbo SPI 的加载拓展类的过程进行了分析。另外，在 Dubbo SPI 中还有一块重要的逻辑这里没有进行分析，即 Dubbo SPI 的扩展点自适应机制。该机制的逻辑较为复杂，咱们将会在下一篇文章中进行详细的分析。
欢迎你们加入Java高级架构群 378461078
- 1. Dubbo源码解析之SPI
- 2. dubbo源码分析系列——dubbo的SPI机制源码分析
- 3. Dubbo源码通~SPI机制
- 4. dubbo源码分析01：SPI机制
- 5. Dubbo 源码分析 - SPI 机制
- 6. Dubbo 源码分析 —— 拓展机制 SPI
- 7. dubbo源码分析-spi机制
- 8. 【java】从java SPI机制到dubbo SPI机制(源码浅析)
- 9. 【Dubbo 源码解析】02_Dubbo SPI
- 10. 2.2 dubbo-spi源码解析
- 更多相关文章...
- • ARP协议的工作机制详解 - TCP/IP教程
- • XML DOM 解析器 - XML DOM 教程
- • 漫谈MySQL的锁机制
- • 互联网组织的未来：剖析GitHub员工的任性之源
-
每一个你不满意的现在，都有一个你没有努力的曾经。