Dubbo之SPI源码分析
Dubbo的扩展点加载机制，用于在程序运行时，通过参数的不同，加载同一接口的不同实现。 同时也提供了类似aop与ioc的功能。
2.使用方式
2.1 直接获取扩展点
ExtensionLoader.getExtensionLoader(WrappedExt.class).getExtension("XXX");
复制代码
直接获取具体的扩展点实现，会进行扩展点 自动包装(aop) 以及 扩展点自动装配(ioc)
2.2 获取扩展点适配类
private Protocol protocol = ExtensionLoader.getExtensionLoader(Protocol.class).getAdaptiveExtension(); 复制代码
获取扩展点的适配类。如果是框架创建的适配类，接口方法在运行时根据url中key对应的value调用不同SPI实现。而自定义适配类，可以自行编写逻辑决定调用那个SPI实现。也会触发 扩展点自动装配(ioc) 。
2.3 获取自动激活扩展点
ExtensionLoader.getExtensionLoader(Filter.class).getActivateExtension(invoker.getUrl(), key, group) 复制代码
这个特性主要使用在ProtocolFilterWrapper中，用于获取invoker的Filter拦截器链，group分为consumer和provider，两者的拦截器链不同。
3.特性介绍
1.扩展点自动注入 如果当前扩展点内有其他扩展点，会自动注入这些扩展点的适配对象 2.扩展点自动包装 如果扩展点实现中有构造函数的参数为当前扩展点接口的，会被识别为包装类，获取其他扩展点时，会通过这个包装类包装，如果有多个包装类，包装多次 3.扩展点自动适配 每次扩展点有且仅有一个适配类(通过@Adaptive注解)，如果不存在，框架会在获取适配对象的时候自动创建。适配对象用于在运行时根据url的参数或者其他自行实现逻辑选择调用具体某个SPI实现 4.扩展点自动激活 通过调用ExtensionLoader#getActivateExtension(URL, String, String)筛选出满足条件的SPI实现。
4.源码分析
SPI的逻辑主要实现在ExtensionLoader，我们从实际使用方式的角度进行源码分析，每个特性都会涉及。
获取ExtensionLoader
我们通过getExtensionLoader获取SPI接口对应的ExtensionLoader，获取之后会把这个ExtensionLoader缓存下来
public static <T> ExtensionLoader<T> getExtensionLoader(Class<T> type) {
if (type == null)
throw new IllegalArgumentException("Extension type == null");
//必须是接口
if (!type.isInterface()) {
throw new IllegalArgumentException("Extension type(" + type + ") is not interface!");
}
//接口类 必须要有SPI注解
if (!withExtensionAnnotation(type)) {
throw new IllegalArgumentException("Extension type(" + type +
") is not extension, because WITHOUT @" + SPI.class.getSimpleName() + " Annotation!");
}
//缓存ExtensionLoader到EXTENSION_LOADERS
ExtensionLoader<T> loader = (ExtensionLoader<T>) EXTENSION_LOADERS.get(type);
if (loader == null) {
EXTENSION_LOADERS.putIfAbsent(type, new ExtensionLoader<T>(type));
loader = (ExtensionLoader<T>) EXTENSION_LOADERS.get(type);
}
return loader;
}
复制代码
获取ExtensionLoader这个过程只是新建了ExtensionLoader， 不会触发配置加载
private ExtensionLoader(Class<?> type) {
this.type = type;
objectFactory = (type == ExtensionFactory.class ? null : ExtensionLoader.getExtensionLoader(ExtensionFactory.class).getAdaptiveExtension());
}
复制代码
ExtensionLoader缓存在下面的容器中
private static final ConcurrentMap<Class<?>, ExtensionLoader<?>> EXTENSION_LOADERS = new ConcurrentHashMap<Class<?>, ExtensionLoader<?>>(); 复制代码
也就是我们的每个SPI接口都会对应一个ExtensionLoader实例
配置加载
ExtensionLoader通过getExtensionClasses来加载配置，触发配置文件件加载并不是在ExtensionLoader实例化的时候，而是在实际获取扩展点的时候。
private Map<String, Class<?>> getExtensionClasses() {
Map<String, Class<?>> classes = cachedClasses.get();
//通过cachedClasses是否被设置，来判断是否进行过配置加载
if (classes == null) {
synchronized (cachedClasses) {
classes = cachedClasses.get();
if (classes == null) {
//从文件加载扩展点配置
classes = loadExtensionClasses();
cachedClasses.set(classes);
}
}
}
return classes;
}
复制代码
如果配置没有加载过，通过loadExtensionClasses加载配置
private Map<String, Class<?>> loadExtensionClasses() {
//从SPI注解提取默认SPI实现
//只能有一个默认实现
final SPI defaultAnnotation = type.getAnnotation(SPI.class);
if (defaultAnnotation != null) {
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];
}
}
Map<String, Class<?>> extensionClasses = new HashMap<String, Class<?>>();
//从三个默认目录下面加载配置文件
loadDirectory(extensionClasses, DUBBO_INTERNAL_DIRECTORY);
loadDirectory(extensionClasses, DUBBO_DIRECTORY);
loadDirectory(extensionClasses, SERVICES_DIRECTORY);
return extensionClasses;
}
复制代码
可以看到，会通过loadDirectory方法从三个默认目录加载配置
private void loadDirectory(Map<String, Class<?>> extensionClasses, String dir) {
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);
}
//urls可能为多个，同一个名字的file分布在多个jar包的情况
if (urls != null) {
while (urls.hasMoreElements()) {
java.net.URL resourceURL = urls.nextElement();
//加载配置文件
loadResource(extensionClasses, classLoader, resourceURL);
}
}
} catch (Throwable t) {
logger.error("Exception when load extension class(interface: " +
type + ", description file: " + fileName + ").", t);
}
}
复制代码
一个SPI接口的配置文件可能会存在于在多个jar包内，所以通过classLoader加载的时候会拿到多个URL路径。通过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;
//spi名 和 spi实现类 用=分隔
int i = line.indexOf('=');
//name可以省略
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);
}
}
}
} finally {
reader.close();
}
} catch (Throwable t) {
logger.error("Exception when load extension class(interface: " +
type + ", class file: " + resourceURL + ") in " + resourceURL, t);
}
}
复制代码
loadClass用来实际解析配置，注意它的入参会对SPI实现类进行类加载。
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 when load extension class(interface: " +
type + ", class line: " + clazz.getName() + "), class "
+ clazz.getName() + "is not subtype of interface.");
}
if (clazz.isAnnotationPresent(Adaptive.class)) {
//clazz有Adaptive注解的话
//代表这个clazz是适配类
if (cachedAdaptiveClass == null) {
cachedAdaptiveClass = clazz;
} else if (!cachedAdaptiveClass.equals(clazz)) {
throw new IllegalStateException("More than 1 adaptive class found: "
+ cachedAdaptiveClass.getClass().getName()
+ ", " + clazz.getClass().getName());
}
} else if (isWrapperClass(clazz)) {
//如果这个clazz有以这个扩展点接口为参数的构造函数，代表这个实现类是包装类
Set<Class<?>> wrappers = cachedWrapperClasses;
if (wrappers == null) {
cachedWrapperClasses = new ConcurrentHashSet<Class<?>>();
wrappers = cachedWrapperClasses;
}
//包装类能有多个
wrappers.add(clazz);
} else {
//进入这里代表是普通的扩展点
clazz.getConstructor();
if (name == null || name.length() == 0) {
//如果没有spi名，从Extenion注解或者classname中解析出来
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 (names != null && names.length > 0) {
Activate activate = clazz.getAnnotation(Activate.class);
if (activate != null) {
//缓存Activate注解 只缓存第一个
cachedActivates.put(names[0], activate);
}
for (String n : names) {
//缓存 clazz 和 spiname 关系，只缓存第一个
if (!cachedNames.containsKey(clazz)) {
cachedNames.put(clazz, n);
}
Class<?> c = extensionClasses.get(n);
if (c == null) {//保存 spiname 和 clazz的关系
extensionClasses.put(n, clazz);
} else if (c != clazz) {//存在重复配置
throw new IllegalStateException("Duplicate extension " + type.getName() + " name " + n + " on " + c.getName() + " and " + clazz.getName());
}
}
}
}
}
复制代码
loadClass会将各种配置保存下来，之后的使用中都会用到这些配置。
获取扩展点实例
获取到ExtensionLoader实例之后，我们可以通过getExtension("spiName")来直接获取我们的扩展点实现。
public T getExtension(String name) {
if (name == null || name.length() == 0)
throw new IllegalArgumentException("Extension name == null");
if ("true".equals(name)) {
return getDefaultExtension();
}
//cachedInstances用于缓存扩展点实例
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.set(instance);
}
}
}
return (T) instance;
}
复制代码
通过cachedInstances对已经实例化的扩展点实现进行缓存，如果该扩展点从未被实例化，使用createExtension进行实例化
private T createExtension(String name) {
//这里触发扫描扩展点配置文件
Class<?> clazz = getExtensionClasses().get(name);
if (clazz == null) {
//找不到spi实现，抛出特定异常
throw findException(name);
}
try {
//对spi name对应clazz进行实例化
//EXTENSION_INSTANCES里面保存的只是原始的实例
//cachedInstances内保存的是经过依赖注入以及包装的实例
T instance = (T) EXTENSION_INSTANCES.get(clazz);
if (instance == null) {
EXTENSION_INSTANCES.putIfAbsent(clazz, clazz.newInstance());
instance = (T) EXTENSION_INSTANCES.get(clazz);
}
//如果这个扩展点依赖其他扩展点，注入扩展点（ioc）
injectExtension(instance);
//如果有包装类的话，进行包装
Set<Class<?>> wrapperClasses = cachedWrapperClasses;
if (wrapperClasses != null && !wrapperClasses.isEmpty()) {
for (Class<?> wrapperClass : wrapperClasses) {
instance = injectExtension((T) wrapperClass.getConstructor(type).newInstance(instance));
}
}
return instance;
} catch (Throwable t) {
throw new IllegalStateException("Extension instance(name: " + name + ", class: " +
type + ") could not be instantiated: " + t.getMessage(), t);
}
}
复制代码
在实例化扩展点之前，会通过getExtensionClasses加载配置，如果已经加载过，跳过。加载完配置文件之后，就可以通过spi名获取对应spi实现类，然后对这个类进行实例化。注意到时候话之后，还会通过injectExtension方法进行 扩展点自动注入以及通过 wrapperClasses进行 扩展点自动包装。
获取扩展点适配实例
通过getAdaptiveExtension方法来获取扩展点适配实例。在扩展点自动注入的时候，注入的实例也是适配实例。
public T getAdaptiveExtension() {
//cachedAdaptiveInstance用于缓存扩展点自动适配实例
Object instance = cachedAdaptiveInstance.get();
if (instance == null) {
if (createAdaptiveInstanceError == null) {//缓存的创建错误如果不为null，直接报错
synchronized (cachedAdaptiveInstance) {
instance = cachedAdaptiveInstance.get();
if (instance == null) {
try {
//如果cachedAdaptiveInstance不存在，进行创建
instance = createAdaptiveExtension();
cachedAdaptiveInstance.set(instance);
} catch (Throwable t) {
//创建失败也缓存，下次直接报错
createAdaptiveInstanceError = t;
throw new IllegalStateException("fail to create adaptive instance: " + t.toString(), t);
}
}
}
} else {
throw new IllegalStateException("fail to create adaptive instance: " + createAdaptiveInstanceError.toString(), createAdaptiveInstanceError);
}
}
return (T) instance;
}
复制代码
首先会判断是否存在适配实例的缓存，如果之前已经获取过，直接返回缓存的实例。不存在，通过createAdaptiveExtension创建。
private T createAdaptiveExtension() {
try {
//对适配实例也进行依赖注入
return injectExtension((T) getAdaptiveExtensionClass().newInstance());
} catch (Exception e) {
throw new IllegalStateException("Can not create adaptive extension " + type + ", cause: " + e.getMessage(), e);
}
}
复制代码
在getAdaptiveExtensionClass中会判断配置中是否解析出适配类，如果不存在适配类，会通过代码拼接的方式动态生成适配类。
private Class<?> getAdaptiveExtensionClass() {
//如果没有初始化，触发初始化
getExtensionClasses();
//如果spi实现中含有适配类直接返回
if (cachedAdaptiveClass != null) {
return cachedAdaptiveClass;
}
//如果spi实现没有提供适配类，那么通过字节码生成
return cachedAdaptiveClass = createAdaptiveExtensionClass();
}
复制代码
在createAdaptiveExtensionClass方法中会动态生成适配类，适配类的大致逻辑是，每个适配类的方法会在运行时从URL中通过@Adaptive配置的key提取value来选择特定扩展点实现。
获取扩展点自动激活实例
通过getActivateExtension来获取自动激活的实例。
public List<T> getActivateExtension(URL url, String[] values, String group) {
List<T> exts = new ArrayList<T>();
List<String> names = values == null ? new ArrayList<String>(0) : Arrays.asList(values);
if (!names.contains(Constants.REMOVE_VALUE_PREFIX + Constants.DEFAULT_KEY)) {
getExtensionClasses();
for (Map.Entry<String, Activate> entry : cachedActivates.entrySet()) {
String name = entry.getKey();
Activate activate = entry.getValue();
//group需要匹配
//group==null true
//group!=null activate.group()==null false
//group in activate.group() true
//group not in activate.group() false
if (isMatchGroup(group, activate.group())) {
T ext = getExtension(name);
if (!names.contains(name)//排查名字匹配的，下面逻辑会添加这些
&& !names.contains(Constants.REMOVE_VALUE_PREFIX + name)
&& isActive(activate, url)//url里面需要匹配activate.value中至少一个key
) {
exts.add(ext);
}
}
}
Collections.sort(exts, ActivateComparator.COMPARATOR);
}
//下面的只要name匹配即可
List<T> usrs = new ArrayList<T>();
for (int i = 0; i < names.size(); i++) {
String name = names.get(i);
if (!name.startsWith(Constants.REMOVE_VALUE_PREFIX)
&& !names.contains(Constants.REMOVE_VALUE_PREFIX + name)) {
if (Constants.DEFAULT_KEY.equals(name)) {
if (!usrs.isEmpty()) {
exts.addAll(0, usrs);
usrs.clear();
}
} else {
T ext = getExtension(name);
usrs.add(ext);
}
}
}
if (!usrs.isEmpty()) {
exts.addAll(usrs);
}
return exts;
}
复制代码
大致逻辑是，这个方法的value参数，直接通过扩展点名获取扩展点实现（不需要有@Activate注解）。而group参数，针对的是有@Activate注解的扩展点实现，首先扩展点实现的@Activate注解的group属性需要匹配，其次@Activate的value属性需要匹配传入的url，也就时@Activate的value需要在url中至少找到一个匹配的key。group和value的匹配相互独立，取并集。
5.与Java SPI的区别
总体来讲，Dubbo SPI 和 JAVA SPI的思想是相同的，都是为了在框架中提供扩展点，让用户或者其他框架扩展这个接口的逻辑。 Dubbo SPI 基于 JAVA SPI的思想扩展了上面讲的4个特性，这是JAVA SPI所没有的。 单从使用方式上来讲，Dubbo SPI可以通过API直接获取某个扩展点实现，而JAVA SPI需要使用迭代器，依次获取。换句话说，如果要在JAVA SPI获取某个扩展点实现，需要把所有扩展点都实例化了。而Dubbo SPI获取那个扩展点只会实例化那个扩展点。 JAVA SPI使用方式如下
ServiceLoader<Animal> serviceLoader =ServiceLoader.load(Animal.class);
Iterator<Animal> animals =serviceLoader.iterator();
while (animals.hasNext())
{
Animal animal =animals.next();
animal.walk();
}
复制代码
最后
这篇SPI是我第二次写了，对于自己也有点新的收获吧。我还是希望我的文章大家都能看懂，而不是光讲源码。 下面是我公众号，大家可以关注下。
正文到此结束
- 本文标签： Collection 字节码 ip map App 参数 文章 equals 源码 cat CTO list ACE IO ArrayList ssl description 注释 value http NIO ConcurrentHashMap java find 代码 key src cache HashMap HashSet 目录 tar API Collections consumer ioc id stream IDE 实例 provider constant 希望 缓存 https UI URLs dubbo Service AOP synchronized struct 配置 解析 final message
- 版权声明： 本文为互联网转载文章，出处已在文章中说明(部分除外)。如果侵权，请联系本站长删除，谢谢。
- 本文海报： 生成海报一 生成海报二
热门推荐
相关文章
近期评论
-
666
-
文章和留言都翻到11页了 没有OOM
-
-
朋友，翻页到11页，及以后，会出现OOM，无法访问
-
-
-
-
版本号是多少，你可以下载哪个代码仓库，jdk选1.8 直接跑就行
-
-
Loading...
![[HBLOG]公众号](https://www.liuhaihua.cn/img/qrcode_gzh.jpg)
