看到ExtensionLoader主要方法和属性
//静态属性
//用于存放接口类型和ExtensionLoader的映射关系
private static final ConcurrentMap<Class<?>, ExtensionLoader<?>> EXTENSION_LOADERS = new ConcurrentHashMap<Class<?>, ExtensionLoader<?>>();
//每个接口的扩展类加载器的成员属性
//扩展接口类型
private final Class<?> type;
//用来对扩展类的set方法属性进行赋值
private final ExtensionFactory objectFactory;
//存放接口对应的ExtensionLoader的有@Adaptive注解的实现类
private final Holder<Object> cachedAdaptiveInstance = new Holder<Object>();
//加载不到@Adaptive注解修饰的实现类时,使得其他线程快速感知抛出异常的标识
private volatile Throwable createAdaptiveInstanceError;
//缓存扩展文件中key(扩展名称) value(接口实现类) 的映射关系 , 不包括@Adaptive注解的扩展类和包装扩展类
private final Holder<Map<String, Class<?>>> cachedClasses = new Holder<Map<String, Class<?>>>();
//默认的接口实现类的 spi注解的value值 对应扩展文件中的扩展名称
private String cachedDefaultName;
//含有@Adaptive注解的扩展类
private volatile Class<?> cachedAdaptiveClass = null;
//记录包装扩展类(可以持有其他的扩展类实例)
private Set<Class<?>> cachedWrapperClasses;
//记录扩展名称 和 扩展类上@Activate注解的映射关系
private final Map<String, Activate> cachedActivates = new ConcurrentHashMap<String, Activate>();
//记录扩展类 和 扩展名名称 的 映射关系
private final ConcurrentMap<Class<?>, String> cachedNames = new ConcurrentHashMap<Class<?>, String>();
//记录扩展名称和Holder的映射关系,Holder持有扩展类的实例
private final ConcurrentMap<String, Holder<Object>> cachedInstances = new ConcurrentHashMap<String, Holder<Object>>();
//记录扩展类和扩展类实例的映射关系
private static final ConcurrentMap<Class<?>, Object> EXTENSION_INSTANCES = new ConcurrentHashMap<Class<?>, Object>();
//spi加载的扩展文件路径
private static final String SERVICES_DIRECTORY = "META-INF/services/";
private static final String DUBBO_DIRECTORY = "META-INF/dubbo/";
private static final String DUBBO_INTERNAL_DIRECTORY = DUBBO_DIRECTORY + "internal/";
getExtensionLoader
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<T> loader = (ExtensionLoader<T>) EXTENSION_LOADERS.get(type);
if (loader == null) {
//实例化ExtensionLoader(扩展类加载器),放入EXTENSION_LOADERS中
EXTENSION_LOADERS.putIfAbsent(type, new ExtensionLoader<T>(type));
loader = (ExtensionLoader<T>) EXTENSION_LOADERS.get(type);
}
//返回ExtensionLoader
return loader;
}
private static <T> boolean withExtensionAnnotation(Class<T> type) {
return type.isAnnotationPresent(SPI.class);
}
private ExtensionLoader(Class<?> type) {
//记录扩展接口
this.type = type;
//如果接口类型不是ExtensionFactory
//对应的被加载的文件为META-INF/dubbo/internal/com.alibaba.dubbo.common.extension.ExtensionFactory
//则objectFactory为实现了ExtensionFactory接口且有@Adaptive注解的实现类(AdaptiveExtensionFactory)。
objectFactory = (type == ExtensionFactory.class ? null : ExtensionLoader.getExtensionLoader(ExtensionFactory.class).getAdaptiveExtension());
}
getAdaptiveExtension,获取扩展接口的有@Adaptive注解的实现类
public T getAdaptiveExtension() {
//首次进来肯定没有
Object instance = cachedAdaptiveInstance.get();
if (instance == null) {
//加载不到对应的实现类时,createAdaptiveInstanceError会被设置为对应的Throwable
if (createAdaptiveInstanceError == null) {
synchronized (cachedAdaptiveInstance) {
//再拿一次,之前没抢到锁等待的线程,此时可以获取到
instance = cachedAdaptiveInstance.get();
//第一个进来设置值的线程
if (instance == null) {
try {
//创建对应的实现类
instance = createAdaptiveExtension();
//设置到cachedAdaptiveInstance中
cachedAdaptiveInstance.set(instance);
} catch (Throwable t) {
//获取不到,则设置createAdaptiveInstanceError 变量
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;
}
private T createAdaptiveExtension() {
try {
//getAdaptiveExtensionClass获取Adaptive的扩展类
//injectExtension调用扩展类set方法进行属性赋值
return injectExtension((T) getAdaptiveExtensionClass().newInstance());
} catch (Exception e) {
throw new IllegalStateException("Can not create adaptive extension " + type + ", cause: " + e.getMessage(), e);
}
}
//获取有@Adaptive注解的实现类
private Class<?> getAdaptiveExtensionClass() {
//加载扩展文件
getExtensionClasses();
//如果有,直接返回
if (cachedAdaptiveClass != null) {
return cachedAdaptiveClass;
}
//没有@Adaptive注解的实现类,自动生成一个,返回
return cachedAdaptiveClass = createAdaptiveExtensionClass();
}
private Map<String, Class<?>> getExtensionClasses() {
Map<String, Class<?>> classes = cachedClasses.get();
if (classes == null) {
//classes 没值说明没有加载过扩展文件
synchronized (cachedClasses) {
classes = cachedClasses.get();
if (classes == null) {
//加载扩展文件 返回扩展名称和扩展类的map
classes = loadExtensionClasses();
//将classes 放入cachedClasses中
cachedClasses.set(classes);
}
}
}
return classes;
}
private Map<String, Class<?>> loadExtensionClasses() {
//获取扩展接口上的spi注解
final SPI defaultAnnotation = type.getAnnotation(SPI.class);
if (defaultAnnotation != null) {
//获取注解的value值 (默认的扩展实现类 该注解的value值对应扩展文件中的扩展名称)
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));
}
//将注解的value值赋值给cachedDefaultName
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;
}
private void loadDirectory(Map<String, Class<?>> extensionClasses, String dir) {
//文件名称为 路径 加上 扩展接口名
String fileName = dir + type.getName();
try {
Enumeration<java.net.URL> urls;
//获取ExtensionLoader.class对应的类加载器
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("Exception when load extension class(interface: " +
type + ", description file: " + fileName + ").", t);
}
}
private static ClassLoader findClassLoader() {
return ExtensionLoader.class.getClassLoader();
}
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(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); //解析失败的行内容,记录下来,可以调用findException来获取exceptions的内容
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);
}
}
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.");
}
//如果扩展类有@Adaptive注解
if (clazz.isAnnotationPresent(Adaptive.class)) {
if (cachedAdaptiveClass == null) {
//将该扩展类赋值给cachedAdaptiveClass
cachedAdaptiveClass = clazz;
}
//只能有一个扩展类有@Adaptive注解
else if (!cachedAdaptiveClass.equals(clazz)) {
throw new IllegalStateException("More than 1 adaptive class found: "
+ cachedAdaptiveClass.getClass().getName()
+ ", " + clazz.getClass().getName());
}
}
//是否为包装类
else if (isWrapperClass(clazz)) {
//cachedWrapperClasses记录所有的WrapperClass
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) {
//根据类名生成一个扩展名称
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 activate = clazz.getAnnotation(Activate.class);
if (activate != null) {
//建立扩展名称 和 扩展类上Activate注解的映射关系
cachedActivates.put(names[0], activate);
}
for (String n : names) {
//如果有多个名称,只记录了第一个名称的
if (!cachedNames.containsKey(clazz)) {
//记录扩展类 和 扩展名名称 的 映射关系
cachedNames.put(clazz, n);
}
Class<?> c = extensionClasses.get(n);
if (c == null) {
//记录扩展名称和扩展类的映射关系
extensionClasses.put(n, clazz);
} else if (c != clazz) {
throw new IllegalStateException("Duplicate extension " + type.getName() + " name " + n + " on " + c.getName() + " and " + clazz.getName());
}
}
}
}
}
//是否为WrapperClass(可以持有其他的扩展类实例)
private boolean isWrapperClass(Class<?> clazz) {
try {
//拥有 一个入参,且入参为扩展接口类型的 构造函数
clazz.getConstructor(type);
return true;
} catch (NoSuchMethodException e) {
return false;
}
}
private String findAnnotationName(Class<?> clazz) {
//获取类上的Extension注解
com.alibaba.dubbo.common.Extension extension = clazz.getAnnotation(com.alibaba.dubbo.common.Extension.class);
//如果没有Extension注解值
if (extension == null) {
//获取类的SimpleName
String name = clazz.getSimpleName();
//如果名称结尾 和 扩展接口类型一致
//则截取 比如(HttpProtocol 实现 Protocol接口) 则此时name为Http
if (name.endsWith(type.getSimpleName())) {
name = name.substring(0, name.length() - type.getSimpleName().length());
}
//返回小写形式
return name.toLowerCase();
}
//返回注解的value值
return extension.value();
}
private Class<?> createAdaptiveExtensionClass() {
//可以没有@Adaptive注解的实现类,这里动态生成一个。
String code = createAdaptiveExtensionClassCode();
//获取类加载器
ClassLoader classLoader = findClassLoader();
//spi获取编译器
com.alibaba.dubbo.common.compiler.Compiler compiler = ExtensionLoader.getExtensionLoader(com.alibaba.dubbo.common.compiler.Compiler.class).getAdaptiveExtension();
//返回编译后的class对象
return compiler.compile(code, classLoader);
}
private T injectExtension(T instance) {
try {
//objectFactory不为空
if (objectFactory != null) {
for (Method method : instance.getClass().getMethods()) {
//方法名称set开头,只有一个入参,访问权限为public
if (method.getName().startsWith("set")
&& method.getParameterTypes().length == 1
&& Modifier.isPublic(method.getModifiers())) {
//方法上有DisableInject注解,则不处理
if (method.getAnnotation(DisableInject.class) != null) {
continue;
}
//获取入参的类型
Class<?> pt = method.getParameterTypes()[0];
try {
//截取掉set方法的set字母,并把第4个字母小写
String property = method.getName().length() > 3 ? method.getName().substring(3, 4).toLowerCase() + method.getName().substring(4) : "";
//获取对象
Object object = objectFactory.getExtension(pt, property);
//调用set方法
if (object != null) {
method.invoke(instance, object);
}
} catch (Exception e) {
logger.error("fail to inject via method " + method.getName()
+ " of interface " + type.getName() + ": " + e.getMessage(), e);
}
}
}
}
} catch (Exception e) {
logger.error(e.getMessage(), e);
}
return instance;
}
public Set<String> getSupportedExtensions() {
//获取扩展名称和扩展类的映射关系
Map<String, Class<?>> clazzes = getExtensionClasses();
//返回所有的扩展名称
return Collections.unmodifiableSet(new TreeSet<String>(clazzes.keySet()));
}
public T getDefaultExtension() {
getExtensionClasses();
if (null == cachedDefaultName || cachedDefaultName.length() == 0
|| "true".equals(cachedDefaultName)) {
return null;
}
//根据cachedDefaultName获取扩展类返回
return getExtension(cachedDefaultName);
}
public T getExtension(String name) {
if (name == null || name.length() == 0)
throw new IllegalArgumentException("Extension name == null");
if ("true".equals(name)) {
//name等于"true",返回默认扩展类
return getDefaultExtension();
}
//根据名称获取扩展类的Holder
Holder<Object> holder = cachedInstances.get(name);
if (holder == null) {
//建立扩展名称和Holder的映射关系
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;
}
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()) {
//循环所有的包装扩展类
for (Class<?> wrapperClass : wrapperClasses) {
//实例化包装扩展类,并持有instance实例
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);
}
}
public List<T> getActivateExtension(URL url, String[] values, String group) {
List<T> exts = new ArrayList<T>();
//values数组赋值给names集合
List<String> names = values == null ? new ArrayList<String>(0) : Arrays.asList(values);
//名称不包含 "-default" Constants.REMOVE_VALUE_PREFIX为"-" 表示排除 。
//如果包含则这里排除了group和url可以匹配到扩展类
if (!names.contains(Constants.REMOVE_VALUE_PREFIX + Constants.DEFAULT_KEY)) {
getExtensionClasses();
//(cachedActivates 记录扩展名称 和 扩展类上@Activate注解的映射关系)
for (Map.Entry<String, Activate> entry : cachedActivates.entrySet()) {
String name = entry.getKey();
Activate activate = entry.getValue();
//匹配注解的group值 和 入参的group值
if (isMatchGroup(group, activate.group())) {
//判断names 是否有和 扩展类的扩展名一致的,一致的在下面的循环加入exts
//判断names 不排除该name
//匹配url参数和 @Activate注解的value值
if (!names.contains(name)
&& !names.contains(Constants.REMOVE_VALUE_PREFIX + name)
&& isActive(activate, url)) {
//使用扩展名获取扩展类加入到exts
T ext = getExtension(name);
exts.add(ext);
}
}
}
//排序,限于篇幅这里就不再写了了,比较简单。Activate注解的before after order属性值
Collections.sort(exts, ActivateComparator.COMPARATOR);
}
List<T> usrs = new ArrayList<T>();
//循换names
for (int i = 0; i < names.size(); i++) {
String name = names.get(i);
//name不以"-"开头 且 names不排除该name
if (!name.startsWith(Constants.REMOVE_VALUE_PREFIX)
&& !names.contains(Constants.REMOVE_VALUE_PREFIX + name)) {
//如果name是"default" , 将usrs放到exts的前面,然后将usrs清空
if (Constants.DEFAULT_KEY.equals(name)) {
if (!usrs.isEmpty()) {
exts.addAll(0, usrs);
usrs.clear();
}
} else {
//使用扩展名获取到扩展类加入到usrs中
T ext = getExtension(name);
usrs.add(ext);
}
}
}
if (!usrs.isEmpty()) {
//usrs不空加入到exts
exts.addAll(usrs);
}
//返回符合条件的扩展类
return exts;
}
private boolean isMatchGroup(String group, String[] groups) {
//group为空,则不用和注解上的group匹配。直接返回true
if (group == null || group.length() == 0) {
return true;
}
if (groups != null && groups.length > 0) {
//判断group 和 注解上的group值是否一致
for (String g : groups) {
if (group.equals(g)) {
return true;
}
}
}
//不匹配 返回false
return false;
}
private boolean isActive(Activate activate, URL url) {
//获取注解配置的value值
String[] keys = activate.value();
//没有配置返回true
if (keys.length == 0) {
return true;
}
//循环注解配置的所有的value值
for (String key : keys) {
//循环当前url携带的参数
for (Map.Entry<String, String> entry : url.getParameters().entrySet()) {
String k = entry.getKey();
String v = entry.getValue();
//url参数key和注解的value值一致 或者 参数key结尾为.加上注解的value值
//url参数key对应的值不能为空
if ((k.equals(key) || k.endsWith("." + key))
&& ConfigUtils.isNotEmpty(v)) {
return true;
}
}
}
//不匹配返回false
return false;
}
createAdaptiveExtensionClassCode方法
private String createAdaptiveExtensionClassCode() {
StringBuilder codeBuilder = new StringBuilder();
Method[] methods = type.getMethods();
boolean hasAdaptiveAnnotation = false;
//遍历扩展接口的所有方法
for (Method m : methods) {
//方法上需要有Adaptive注解修饰
if (m.isAnnotationPresent(Adaptive.class)) {
hasAdaptiveAnnotation = true;
break;
}
}
// no need to generate adaptive class since there's no adaptive method found.
//没有一个方法有Adaptive注解修饰,直接抛出异常,无法自动生成
if (!hasAdaptiveAnnotation)
throw new IllegalStateException("No adaptive method on extension " + type.getName() + ", refuse to create the adaptive class!");
codeBuilder.append("package ").append(type.getPackage().getName()).append(";");
//限于篇幅省略大段的代码字符串拼接逻辑,具体逻辑可以看官方文档https://dubbo.apache.org/zh/docsv2.7/dev/source/adaptive-extension/
//日志debug级别下,控制台会打印这里的字符串
//或者直接打断点到这里来看,生成的类比较简单,完全可以看懂
//这里自动生成的类实现的 扩展接口中有@Adaptive注解修饰的方法 主要逻辑为交给其他扩展实现类去完成方法调用。 没有注解的方法,则实现的逻辑为直接抛出UnsupportedOperationException
return codeBuilder.toString();
}
objectFactory的getExtension方法
@Adaptive
public class AdaptiveExtensionFactory implements ExtensionFactory {
private final List<ExtensionFactory> factories;
public AdaptiveExtensionFactory() {
ExtensionLoader<ExtensionFactory> loader = ExtensionLoader.getExtensionLoader(ExtensionFactory.class);
List<ExtensionFactory> list = new ArrayList<ExtensionFactory>();
//循环所有的扩展名称(不包括@Adaptive注解的扩展类和包装扩展类), 这里能找到两个
for (String name : loader.getSupportedExtensions()) {
//获取到扩展类
list.add(loader.getExtension(name));
}
//赋值给factories
factories = Collections.unmodifiableList(list);
}
@Override
public <T> T getExtension(Class<T> type, String name) {
for (ExtensionFactory factory : factories) {
//从dubbo的spi容器 和 spring容器找
T extension = factory.getExtension(type, name);
if (extension != null) {
return extension;
}
}
return null;
}
}
META-INF\dubbo\internal\com.alibaba.dubbo.common.extension.ExtensionFactory
adaptive=com.alibaba.dubbo.common.extension.factory.AdaptiveExtensionFactory
spi=com.alibaba.dubbo.common.extension.factory.SpiExtensionFactory
spring=com.alibaba.dubbo.config.spring.extension.SpringExtensionFactory
SpiExtensionFactory
public class SpiExtensionFactory implements ExtensionFactory {
@Override
public <T> T getExtension(Class<T> type, String name) {
//接口类型 且有 @SPI注解修饰
if (type.isInterface() && type.isAnnotationPresent(SPI.class)) {
ExtensionLoader<T> loader = ExtensionLoader.getExtensionLoader(type);
if (!loader.getSupportedExtensions().isEmpty()) {
//获取@Adaptive修饰的扩展类
return loader.getAdaptiveExtension();
}
}
return null;
}
}
SpringExtensionFactory
public class SpringExtensionFactory implements ExtensionFactory {
private static final Logger logger = LoggerFactory.getLogger(SpringExtensionFactory.class);
private static final Set<ApplicationContext> contexts = new ConcurrentHashSet<ApplicationContext>();
private static final ApplicationListener shutdownHookListener = new ShutdownHookListener();
//暂时还没讲到ServiceBean 和 ReferenceBean 不过没关系只需要spring的基础知识
// ServiceBean 和 ReferenceBean实现了ApplicationContextAware接口 ,实现了setApplicationContext方法来调用该方法
// 实例化时会调用该方法 将当前spring容器加入到contexts
public static void addApplicationContext(ApplicationContext context) {
contexts.add(context);
//这里还添加了一个监听事件
BeanFactoryUtils.addApplicationListener(context, shutdownHookListener);
}
public static void removeApplicationContext(ApplicationContext context) {
contexts.remove(context);
}
public static Set<ApplicationContext> getContexts() {
return contexts;
}
// currently for test purpose
public static void clearContexts() {
contexts.clear();
}
@Override
@SuppressWarnings("unchecked")
public <T> T getExtension(Class<T> type, String name) {
//根据name从spring容器中获取bean
for (ApplicationContext context : contexts) {
if (context.containsBean(name)) {
Object bean = context.getBean(name);
if (type.isInstance(bean)) {
return (T) bean;
}
}
}
logger.warn("No spring extension (bean) named:" + name + ", try to find an extension (bean) of type " + type.getName());
if (Object.class == type) {
return null;
}
//根据type从spring容器中获取bean
for (ApplicationContext context : contexts) {
try {
return context.getBean(type);
} catch (NoUniqueBeanDefinitionException multiBeanExe) {
logger.warn("Find more than 1 spring extensions (beans) of type " + type.getName() + ", will stop auto injection. Please make sure you have specified the concrete parameter type and there's only one extension of that type.");
} catch (NoSuchBeanDefinitionException noBeanExe) {
if (logger.isDebugEnabled()) {
logger.debug("Error when get spring extension(bean) for type:" + type.getName(), noBeanExe);
}
}
}
logger.warn("No spring extension (bean) named:" + name + ", type:" + type.getName() + " found, stop get bean.");
return null;
}
//这里监听ContextClosedEvent
private static class ShutdownHookListener implements ApplicationListener {
@Override
public void onApplicationEvent(ApplicationEvent event) {
if (event instanceof ContextClosedEvent) {
// we call it anyway since dubbo shutdown hook make sure its destroyAll() is re-entrant.
// pls. note we should not remove dubbo shutdown hook when spring framework is present, this is because
// its shutdown hook may not be installed.
DubboShutdownHook shutdownHook = DubboShutdownHook.getDubboShutdownHook();
//这里会清理registries和protocols (也还没讲到注册配置类和协议配置类)
shutdownHook.destroyAll();
}
}
}
}