首先从获取拓展加载器说起
@Override
@SuppressWarnings("unchecked")
public <T> ExtensionLoader<T> getExtensionLoader(Class<T> type) {
checkDestroyed();
if (type == null) {
throw new IllegalArgumentException("Extension type == null");
}
if (!type.isInterface()) {
throw new IllegalArgumentException("Extension type (" + type + ") is not an interface!");
}
if (!withExtensionAnnotation(type)) {
throw new IllegalArgumentException("Extension type (" + type +
") is not an extension, because it is NOT annotated with @" + SPI.class.getSimpleName() + "!");
}
// 1. find in local cache
ExtensionLoader<T> loader = (ExtensionLoader<T>) extensionLoadersMap.get(type);
ExtensionScope scope = extensionScopeMap.get(type);
if (scope == null) {
SPI annotation = type.getAnnotation(SPI.class);
scope = annotation.scope();
extensionScopeMap.put(type, scope);
}
if (loader == null && scope == ExtensionScope.SELF) {
// create an instance in self scope
loader = createExtensionLoader0(type);
}
// 2. find in parent
if (loader == null) {
if (this.parent != null) {
loader = this.parent.getExtensionLoader(type);
}
}
// 3. create it
if (loader == null) {
loader = createExtensionLoader(type);
}
return loader;
}①首先去当前对象的extensionLoadersMap(ConcurrentHashMap)属性成员中获取是否有对应type Class类的加载器
②再到当前对象的extensionScopeMap(ConcurrentHashMap)属性成员中获取对应type Class的Spi注解scope属性范围
③如果没有,就去获取type Class上面的SPI注解
④拿到SPI注解中Scope的值(默认是ExtensionScope.APPLICATION)
⑤存入当前对象的extensionScopeMap(ConcurrentHashMap)属性成员中
⑥如果第①步拿到的成员是空,且第②步拿到的scope是self,则创建一个self的loader
⑦如果scope属性值不是self且属性成员parent不为空,那么到parent中取获取加载器
⑧如果还获取不到，那么开始创建loader
这里我们重点跟踪下第⑧部的默认创建loader步骤
private <T> ExtensionLoader<T> createExtensionLoader(Class<T> type) {
ExtensionLoader<T> loader = null;
if (isScopeMatched(type)) {
// if scope is matched, just create it
loader = createExtensionLoader0(type);
}
return loader;
}①检查下type Class上面的SPI注解里面的scope默认值是否和传进来的一致
②如果scope匹配,则开始创建
private <T> ExtensionLoader<T> createExtensionLoader0(Class<T> type) {
checkDestroyed();
ExtensionLoader<T> loader;
// ①直接通过new 一个ExtensionLoader对象(这里就会进行这个对象的一些初始化操作了,后续一些用到的属性都是在这个初始化操作完成的,我们后面遇到再重点提起)
// ②存入当前对象成员属性extensionLoadersMap
extensionLoadersMap.putIfAbsent(type, new ExtensionLoader<T>(type, this, scopeModel));
// ③直接从当前对象成员属性extensionLoadersMap根据type获取对应的loader返回
loader = (ExtensionLoader<T>) extensionLoadersMap.get(type);
return loader;
}①直接通过new 一个ExtensionLoader对象(这里就会进行这个对象的一些初始化操作了,后续一些用到的属性都是在这个初始化操作完成的,我们后面遇到再重点提起)
②存入当前对象成员属性extensionLoadersMap
③直接从当前对象成员属性extensionLoadersMap根据type获取对应的loader返回
好，此时我们已经拿到ExtensionLoader对象了，可以调用getExtension来获取对应实例
public T getExtension(String name) {
// ①根据名字及允许包装来获取实例
T extension = getExtension(name, true);
// ②如果没有获取到,则抛异常
if (extension == null) {
throw new IllegalArgumentException("Not find extension: " + name);
}
return extension;
}①根据名字及允许包装来获取实例
②如果没有获取到,则抛异常
public T getExtension(String name, boolean wrap) {
checkDestroyed();
if (StringUtils.isEmpty(name)) {
throw new IllegalArgumentException("Extension name == null");
}
// ①如果name是"true"则获取默认的spi对象
if ("true".equals(name)) {
return getDefaultExtension();
}
// ②获取cacheKey，如果不允许包装,则通过拼接_origin来控制返回原对象
String cacheKey = name;
if (!wrap) {
cacheKey += "_origin";
}
// ③获取生成的cacheKey对应的holder
final Holder<Object> holder = getOrCreateHolder(cacheKey);
// ④从holder中获取是否有对应对象
Object instance = holder.get();
// ⑤如果没有,对holder加锁双重检查后进行创建
if (instance == null) {
synchronized (holder) {
instance = holder.get();
if (instance == null) {
instance = createExtension(name, wrap);
// ⑥再将创建好的对象放进holder中
holder.set(instance);
}
}
}
return (T) instance;
}①如果name是"true"则获取默认的spi对象
②获取cacheKey，如果不允许包装,则通过拼接_origin来控制返回原对象
③获取生成的cacheKey对应的holder
④从holder中获取是否有对应对象
⑤如果没有,对holder加锁双重检查后进行创建
⑥再将创建好的对象放进holder中
private T createExtension(String name, boolean wrap) {
// ①获取ExtensionClassMap(也就是每个name对应的class全路径名),再从map中获取name对应的class全类名
Class<?> clazz = getExtensionClasses().get(name);
if (clazz == null || unacceptableExceptions.contains(name)) {
throw findException(name);
}
try {
// ②先根据当前loader对象属性成员extensionInstances(ConcurrentHashMap)中根据类型去获取对象
T instance = (T) extensionInstances.get(clazz);
if (instance == null) {
//③如果没获取到,则根据class全类名创建实例,并放进当前loader对象属性成员extensionInstances(ConcurrentHashMap)中
extensionInstances.putIfAbsent(clazz, createExtensionInstance(clazz));
//④从当前loader对象属性成员extensionInstances(ConcurrentHashMap)中根据type对应的Class对象取出对应的实例
instance = (T) extensionInstances.get(clazz);
//⑤获取前置处理器，循环遍历调用
instance = postProcessBeforeInitialization(instance, name);
//⑥反射调用set方法将实例注入取出的实例属性
injectExtension(instance);
//⑦获取后置处理器，循环遍历调用
instance = postProcessAfterInitialization(instance, name);
}
//⑧如果需要包装,将cachedWrapperClasses的包装Class集合放进wrapperClassesList并排序
if (wrap) {
List<Class<?>> wrapperClassesList = new ArrayList<>();
if (cachedWrapperClasses != null) {
wrapperClassesList.addAll(cachedWrapperClasses);
wrapperClassesList.sort(WrapperComparator.COMPARATOR);
Collections.reverse(wrapperClassesList);
}
if (CollectionUtils.isNotEmpty(wrapperClassesList)) {
//⑨循环遍历所有的包装Class，判断是否有Wrapper注解，如果有则根据注解上面的配置匹配过滤下当前包装Class
// 是否适用当前name对应的对象
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);
}
}
}
}
// 11.如果name对应的对象实现了Lifecycle接口，则调用器初始化方法,返回
// 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);
}
}①获取ExtensionClassMap(也就是每个name对应的class全路径名),再从map中获取name对应的class全类名
②先根据当前loader对象属性成员extensionInstances(ConcurrentHashMap)中根据类型去获取对象
③如果没获取到,则根据class全类名创建实例,并放进当前loader对象属性成员extensionInstances(ConcurrentHashMap)中
④从当前loader对象属性成员extensionInstances(ConcurrentHashMap)中根据type对应的Class对象取出对应的实例
⑤获取前置处理器，循环遍历调用
⑥反射调用set方法将实例注入取出的实例属性
⑦获取后置处理器，循环遍历调用
⑧如果需要包装,将cachedWrapperClasses的包装Class集合放进wrapperClassesList并排序
⑨循环遍历所有的包装Class，判断是否有Wrapper注解，如果有则根据注解上面的配置匹配过滤下当前包装Class是否适用当前name对应的对象
⑩如果匹配,拿到包装类 获取构造器 将被包装的类传入构造器反射 反射 创建实例，并注入其他属性返回
11.如果name对应的对象实现了Lifecycle接口，则调用器初始化方法,创建完成
接下来，我们深入一些重点方法来细化一些流程
首先看下第①步中如何获取ExtensionClassMap
private Map<String, Class<?>> getExtensionClasses() {
// ①先从当前loader对象的cachedClasses(Holder<Map<String, Class<?>>>)属性变量中获取
Map<String, Class<?>> classes = cachedClasses.get();
// ②如果没有,锁住holder对象双重检查锁之后进行加载
if (classes == null) {
synchronized (cachedClasses) {
classes = cachedClasses.get();
if (classes == null) {
classes = loadExtensionClasses();
// ③再把加载到的Map<String, Class<?>>设置进holder即cachedClasses中
cachedClasses.set(classes);
}
}
}
return classes;
}①先从当前loader对象的cachedClasses(Holder<Map<String, Class<?>>>)属性变量中获取
②如果没有,锁住holder对象双重检查锁之后进行加载
③再把加载到的Map<String, Class<?>>设置进holder即cachedClasses中
private Map<String, Class<?>> loadExtensionClasses() {
checkDestroyed();
// ①设置当前loader对象默认的spi name,即给cachedDefaultName成员属性赋值
cacheDefaultExtensionName();
Map<String, Class<?>> extensionClasses = new HashMap<>();
// ②循环遍历所有的加载策略,将各个类加载器加载路径下以接口命名的文件中
// key(name),value(全类名)键值对加载进extensionClasses(Map<String, Class<?>>)中
for (LoadingStrategy strategy : strategies) {
loadDirectory(extensionClasses, strategy, type.getName());
// compatible with old ExtensionFactory
if (this.type == ExtensionInjector.class) {
loadDirectory(extensionClasses, strategy, ExtensionFactory.class.getName());
}
}
return extensionClasses;
}①设置当前loader对象默认的spi name,即给cachedDefaultName成员属性赋值
②循环遍历所有的加载策略,将各个类加载器加载路径下以接口命名的文件中key(name),value(全类名)键值对加载进extensionClasses(Map<String, Class<?>>)中
private void loadDirectory(Map<String, Class<?>> extensionClasses, LoadingStrategy strategy, String type) {
// ①根据加载策略类加载type对应文件下的key，value
loadDirectoryInternal(extensionClasses, strategy, type);
try {
// ②兼容行为,把type全类名的org.apache改为com.alibaba再去加载一遍对应文件中的key,value
String oldType = type.replace("org.apache", "com.alibaba");
if (oldType.equals(type)) {
return;
}
//if class not found,skip try to load resources
ClassUtils.forName(oldType);
loadDirectoryInternal(extensionClasses, strategy, oldType);
} catch (ClassNotFoundException classNotFoundException) {
}
}①根据加载策略类加载type对应文件下的key，value
②兼容行为,把type全类名的org.apache改为com.alibaba再去加载一遍对应文件中的key,value
private void loadDirectoryInternal(Map<String, Class<?>> extensionClasses, LoadingStrategy loadingStrategy, String type) {
// ①根据策略类拼接好文件名
String fileName = loadingStrategy.directory() + type;
try {
List<ClassLoader> classLoadersToLoad = new LinkedList<>();
// try to load from ExtensionLoader's ClassLoader first
if (loadingStrategy.preferExtensionClassLoader()) {
ClassLoader extensionLoaderClassLoader = ExtensionLoader.class.getClassLoader();
if (ClassLoader.getSystemClassLoader() != extensionLoaderClassLoader) {
classLoadersToLoad.add(extensionLoaderClassLoader);
}
}
if (specialSPILoadingStrategyMap.containsKey(type)){
String internalDirectoryType = specialSPILoadingStrategyMap.get(type);
//skip to load spi when name don't match
if (!LoadingStrategy.ALL.equals(internalDirectoryType)
&& !internalDirectoryType.equals(loadingStrategy.getName())){
return;
}
classLoadersToLoad.clear();
classLoadersToLoad.add(ExtensionLoader.class.getClassLoader());
}else {
// load from scope model
Set<ClassLoader> classLoaders = scopeModel.getClassLoaders();
if (CollectionUtils.isEmpty(classLoaders)) {
Enumeration<java.net.URL> resources = ClassLoader.getSystemResources(fileName);
if (resources != null) {
while (resources.hasMoreElements()) {
//② 根据文件名对应到类加载器上的文件路径加载文件中的内容,name作为key,value对应的Class作为value设置进extensionClasses
loadResource(extensionClasses, null, resources.nextElement(), loadingStrategy.overridden(),
loadingStrategy.includedPackages(),
loadingStrategy.excludedPackages(),
loadingStrategy.onlyExtensionClassLoaderPackages());
}
}
} else {
classLoadersToLoad.addAll(classLoaders);
}
}
Map<ClassLoader, Set<java.net.URL>> resources = ClassLoaderResourceLoader.loadResources(fileName, classLoadersToLoad);
resources.forEach(((classLoader, urls) -> {
loadFromClass(extensionClasses, loadingStrategy.overridden(), urls, classLoader,
loadingStrategy.includedPackages(),
loadingStrategy.excludedPackages(),
loadingStrategy.onlyExtensionClassLoaderPackages());
}));
} catch (Throwable t) {
logger.error("Exception occurred when loading extension class (interface: " +
type + ", description file: " + fileName + ").", t);
}
}①根据策略类拼接好文件名
② 根据文件名对应到类加载器上的文件路径加载文件中的内容,name作为key,value对应的Class作为value设置进extensionClasses
private void loadResource(Map<String, Class<?>> extensionClasses, ClassLoader classLoader,
java.net.URL resourceURL, boolean overridden, String[] includedPackages, String[] excludedPackages, String[] onlyExtensionClassLoaderPackages) {
try {
// ①获取url对应文件中的内容,将每行数据作为一个元素塞进list中
List<String> newContentList = getResourceContent(resourceURL);
String clazz;
// ②遍历每行数据,将等号左边的值作为name，右边的值Class.forName获取clazz作为value放进extensionClasses
for (String line : newContentList) {
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();
clazz = line.substring(i + 1).trim();
} else {
clazz = line;
}
if (StringUtils.isNotEmpty(clazz) && !isExcluded(clazz, excludedPackages) && isIncluded(clazz, includedPackages)
&& !isExcludedByClassLoader(clazz, classLoader, onlyExtensionClassLoaderPackages)) {
loadClass(extensionClasses, resourceURL, Class.forName(clazz, true, classLoader), name, overridden);
}
} 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);
}
}①获取url对应文件中的内容,将每行数据作为一个元素塞进list中
②遍历每行数据,将等号左边的值作为name，右边的值Class.forName获取clazz作为value放进extensionClasses
private void loadClass(Map<String, Class<?>> extensionClasses, java.net.URL resourceURL, Class<?> clazz, String name,
boolean overridden) {
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.");
}
// ①判断是否有Adaptive注解,如果有就将clazz赋值给当前loader对象的cachedAdaptiveClass属性
// ②如果是包装类，则将clazz塞进当前loader对象的cachedWrapperClasses(set)中
// ③如果都不是,则进行加载进extensionClasses
if (clazz.isAnnotationPresent(Adaptive.class)) {
cacheAdaptiveClass(clazz, overridden);
} else if (isWrapperClass(clazz)) {
cacheWrapperClass(clazz);
} else {
if (StringUtils.isEmpty(name)) {
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)) {
cacheActivateClass(clazz, names[0]);
for (String n : names) {
cacheName(clazz, n);
saveInExtensionClass(extensionClasses, clazz, n, overridden);
}
}
}
}①判断是否有Adaptive注解,如果有就将clazz赋值给当前loader对象的cachedAdaptiveClass属性
②如果是包装类，则将clazz塞进当前loader对象的cachedWrapperClasses(set)中
③如果都不是,则进行加载extensionClasses
private void saveInExtensionClass(Map<String, Class<?>> extensionClasses, Class<?> clazz, String name, boolean overridden) {
Class<?> c = extensionClasses.get(name);
if (c == null || overridden) {
extensionClasses.put(name, clazz);
} else if (c != clazz) {
// duplicate implementation is unacceptable
unacceptableExceptions.add(name);
String duplicateMsg = "Duplicate extension " + type.getName() + " name " + name + " on " + c.getName() + " and " + clazz.getName();
logger.error(duplicateMsg);
throw new IllegalStateException(duplicateMsg);
}
}剥了这么多层洋葱，终于看到了put操作
此时我们就已经拿到了name对应的 clazz
931
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
