ExtensionLoader类分析
ExtensionLoader类分析
成员变量分析
静态成员变量
// 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/";
// 分割value属性值 比如A,B,C分割之后的结果为三个元素A B C
private static final Pattern NAME_SEPARATOR = Pattern.compile("\\s*[,]+\\s*");
// 扩展点(扩展接口)及对应的扩展类加载器缓存
private static final ConcurrentMap<Class<?>, ExtensionLoader<?>> EXTENSION_LOADERS = new ConcurrentHashMap<Class<?>, ExtensionLoader<?>>();
// 扩展类与类初始化之后的实例
private static final ConcurrentMap<Class<?>, Object> EXTENSION_INSTANCES = new ConcurrentHashMap<Class<?>, Object>();
实例成员
// 扩展点(其实是扩展接口)
private final Class<?> type;
// 扩展工厂类, 当对实例进行依赖注入时，需要利用objectFactory来实现查找相应的扩展类，或者spring中的对应bean。
private final ExtensionFactory objectFactory;
// 普通扩展类及扩展名存储 ， 不包含自适应扩展类和包装类Wrapper
private final ConcurrentMap<Class<?>, String> cachedNames = new ConcurrentHashMap<Class<?>, String>();
// 扩展名称及普通扩展类存储 ，不包含自适应扩展类和包装类Wrapper
private final Holder<Map<String, Class<?>>> cachedClasses = new Holder<Map<String, Class<?>>>();
// 扩展名及@Activate存储
private final Map<String, Activate> cachedActivates = new ConcurrentHashMap<String, Activate>();
// 扩展名及扩展类实例存储， 只包含普通扩展类
private final ConcurrentMap<String, Holder<Object>> cachedInstances = new ConcurrentHashMap<String, Holder<Object>>();
// 扩展类的自适应实例
private final Holder<Object> cachedAdaptiveInstance = new Holder<Object>();
// 自适应扩展类
private volatile Class<?> cachedAdaptiveClass = null;
// 扩展类默认扩展名
private String cachedDefaultName;
// 创建自适应扩展类时抛出的异常
private volatile Throwable createAdaptiveInstanceError;
// 扩展类的包装类
private Set<Class<?>> cachedWrapperClasses;
// 类加载的时候异常存储, key表示对用加载类的全名称
private Map<String, IllegalStateException> exceptions = new ConcurrentHashMap<String, IllegalStateException>();
分析下面代码过程实现
ExtensionLoader<PrintService> extensionLoader = ExtensionLoader.getExtensionLoader(PrintService.class);
第一步： 首先调用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!");
}
if (!withExtensionAnnotation(type)) { // spi标注
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) { // 创建一个扩展类加载器缓存对象, 进入第二步
EXTENSION_LOADERS.putIfAbsent(type, new ExtensionLoader<T>(type));
loader = (ExtensionLoader<T>) EXTENSION_LOADERS.get(type);
}
return loader;
}
第二步:创建一个扩展类加载器缓存对象 new ExtensionLoader
private ExtensionLoader(Class<?> type) { // 显然此时type==PrintService.class, 因此进入第三步
this.type = type;
objectFactory = (type == ExtensionFactory.class ? null : ExtensionLoader.getExtensionLoader(ExtensionFactory.class).getAdaptiveExtension());
}
第三步：进入方法getExtensionLoader(type=ExtensionFactory.class), 分析上面第一步方法，可以知道此时
EXTENSION_LOADERS添加元素key为ExtensionFactory.class, value为ExtensionLoader对象，我们假设它为ploader=new ExtensionLoader(){type=ExtensionFactory.class, objectFactory=null}。进入第四步 ploader.getAdaptiveExtension()方法调用过程。
第四步 ExtensionFactory扩展类的加载器缓存对象调用getAdaptiveExtension方法
// 获取自适应扩展对象, 先从缓存中查找, 不存在再从配置文件中查找
public T getAdaptiveExtension() {
//从缓存中读取自适应扩展对象实例
Object instance = cachedAdaptiveInstance.get();
if (instance == null) {
// 创建过程没有报错
if (createAdaptiveInstanceError == null) {
// 锁定缓存适应性实例 类似于双锁检测， 不过此处对数据进行封装
synchronized (cachedAdaptiveInstance) {
instance = cachedAdaptiveInstance.get();
if (instance == null) {// 此处再次判断
try { // 第五步 进入createAdaptiveExtension方法创建自适应扩展类对象
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;
}
第五步: 创建适应性扩展类, 其中包含获取扩展类，实例化，依赖注入
private T createAdaptiveExtension() {
try {
// 第六步进入 getAdaptiveExtensionClass方法
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() {
// 加载配置文件中的所有扩展类， 进入第七步方法getExtensonClasses();
getExtensionClasses();
// 自适应扩展类是否存在， 存在直接返回。
if (cachedAdaptiveClass != null) {
return cachedAdaptiveClass;
}
// 利用代码创建自适应扩展类
return cachedAdaptiveClass = createAdaptiveExtensionClass();
}
第七步: 进入getExtensionClasses方法, 如果对应的普通扩展类缓存不为空，直接返回。否则进入loadExtensionClass加载普通扩展类缓存。
private Map<String, Class<?>> getExtensionClasses() {
Map<String, Class<?>> classes = cachedClasses.get();
if (classes == null) { // 普通扩展类为空
synchronized (cachedClasses) {
classes = cachedClasses.get();
if (classes == null) {
// 加载扩展类, 第八步 调用loadExtensionClasses加载配置文件中的扩展类数据
classes = loadExtensionClasses();
// 设置普通扩展类缓存
cachedClasses.set(classes);
}
}
}
return classes;
}
第八步: loadExtensionClasses加载三个配置文件中的扩展类信息
// synchronized in getExtensionClasses
private Map<String, Class<?>> loadExtensionClasses() {
// 获取对应扩展类的标注spi中的value值，其实就是默认的扩展类实现对应的key
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获取文件信息
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) {
/* 按照我们的样例 此时type为ExtensionFactory.class,
如果dir此时为DUBBO_INTERNAL_DIRECTORY, 那么fileName=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
*/
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();
// 第十步： 对于fileName下的每一个文件
loadResource(extensionClasses, classLoader, resourceURL);
}
}
} catch (Throwable t) {
logger.error("Exception when load extension class(interface: " +
type + ", description file: " + fileName + ").", t);
}
}
第十步： 读取每一个文件, 文件中每一行以key=value形式
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) {
// 第十一步 加载对应的扩展类(初始化true)，并调用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);
}
}
}
} finally {
reader.close();
}
} catch (Throwable t) {
logger.error("Exception when load extension class(interface: " +
type + ", class file: " + resourceURL + ") in " + resourceURL, t);
}
}
第十一步: loadClass方法
/**
* extensionClasses 扩展类缓存数据
* clazz 文件中对应的扩展类 value
* name 扩展类对应的名字 key
*/
private void loadClass(Map<String, Class<?>> extensionClasses, java.net.URL resourceURL, Class<?> clazz, String name) throws NoSuchMethodException {
// clazz对象是否可以直接赋给type类型变量。此处clazz是否实现type接口
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)) {
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) {
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) {
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());
}
}
}
}
}
第十二步: 回退到第七步，并设置普通扩展类缓存cachedClass, 接着回退到第六步返回AdaptiveExtensionFactory类, 接着返回到第五步 .newInstance(), 调用如下构造函数。最后依赖注入injectExtension（AdaptiveExtensionFactory对象）
/*
* 按照样例 loader.getSupportedExtensions() 包含 spring=SpringExtensionFactory和
* spi=SpiExtensionFactory的key spi, spring
*/
public AdaptiveExtensionFactory() {
ExtensionLoader<ExtensionFactory> loader = ExtensionLoader.getExtensionLoader(ExtensionFactory.class);
List<ExtensionFactory> list = new ArrayList<ExtensionFactory>();
for (String name : loader.getSupportedExtensions()) {
list.add(loader.getExtension(name));
}
// [SpiExtensionFactory, SpringExtensionFactory]
factories = Collections.unmodifiableList(list);
}
injectExtension（instance）依赖注入
private T injectExtension(T instance) {
try {
if (objectFactory != null) {
for (Method method : instance.getClass().getMethods()) {
if (method.getName().startsWith("set")
&& method.getParameterTypes().length == 1
&& Modifier.isPublic(method.getModifiers())) {
/**
* 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];
try {
String property = method.getName().length() > 3 ? method.getName().substring(3, 4).toLowerCase() + method.getName().substring(4) : "";
Object object = objectFactory.getExtension(pt, property);
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;
}
最终结果 EXTENSION_LOADERS.put(PrintService.class, AdaptiveExtensionFactory实例 )
getExtension过程分析
- 如果name为true表示取默认扩展名对应的扩展类；否则， 从扩展类实例缓存中查找。
- 如果扩展名及扩展类实例缓存不存在相应的记录 , 调用createExtension方法; 否则直接返回。
- 加载配置文件中扩展类信息，接着再次从实例缓存中查找，如果缓存不存在，实例化扩展类并添加在实力缓存中，否则直接取出
- 依赖注入方法injectExtension实现自动加载。 查找匹配的包装类，并注入扩展类实例。
// 下面是getExtension方法， 首先当前的this.typePrintService.class, this.objectFactorynew AdaptiveExtensionFactory(); this就是ExtensionLoader。
public T getExtension(String name) {
if (name == null || name.length() == 0)
throw new IllegalArgumentException("Extension name == null");
if ("true".equals(name)) { // true表示获取默认值
return getDefaultExtension();
}
// 扩展类实例缓存中查找
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) {
// 创建扩展名为name的扩展类
instance = createExtension(name);
holder.set(instance);
}
}
}
return (T) instance;
}
createExtension创建扩展名为name的扩展类
private T createExtension(String name) {
// getExtensionClass获取配置文件中普通扩展类存储， 然后查找出相应的扩展类信息
Class<?> clazz = getExtensionClasses().get(name);
if (clazz == null) { // 找不到， 抛出异常
throw findException(name);
}
try { // 利用扩展类信息从扩展实例存储中取出扩展实例
T instance = (T) EXTENSION_INSTANCES.get(clazz);
if (instance == null) {// EXTENSION_INSTANCES中不存在扩展实例, 添加.
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) {
// 对于每个扩展点类型为type的包装类进行构造函数元素填充，一直重复填充下去。
// 类似于Aop,装饰器+反射
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);
}
}
injectExtension依赖注入, 基本原理就是找到set方法，然后从缓存记录中查找和set方法参数一致的扩展类。
查找策略由objectFactory决定，bjectFactory的类型为AdaptiveExtensionFactory, 包含两种查找策略, 首先查找SpiExtensionFactory.getExtension查找对应的自适应扩展类实例。 返回null, 则调用SpringExtensionFactory.getExtension查找满足条件的bean
private T injectExtension(T instance) {
try {
if (objectFactory != null) {
for (Method method : instance.getClass().getMethods()) {
if (method.getName().startsWith("set")
&& method.getParameterTypes().length == 1
&& Modifier.isPublic(method.getModifiers())) {
/**
* 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];
try { // 变量名称
String property = method.getName().length() > 3 ? method.getName().substring(3, 4).toLowerCase() + method.getName().substring(4) : "";
/*调用AdaptiveExtensionFactory对象的getExtension方法
*本质上就是先调用 SpiExtensionFactory的getExtension方法
*如果没找到，接着调用SpringExtensionFactory的getExtension方法查找
*Spring中满足条件的bean
*/
Object object = objectFactory.getExtension(pt, property);
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;
}
getAdaptiveExtension分析
- 缓存中是否存在自适应扩展类, 如果存在直接返回； 否则进入步骤2
- 加载扩展类配置信息,即getAdaptiveExtensionClass中调用的getExtensionClasses方法. 再次查看缓存是够存在，存在直接返回，不存在转入步骤3
- 调用createAdaptiveExtensionClass创建自适应类, 这其中包含三步操作：生成自适应代码，获取类加载器、编译器，编译自适应类 。 缓存数据，然后返回。
public T getAdaptiveExtension() {
// 查找缓存中是否存在自适应扩展类
Object instance = cachedAdaptiveInstance.get();
if (instance == null) {
if (createAdaptiveInstanceError == null) {
synchronized (cachedAdaptiveInstance) {
instance = cachedAdaptiveInstance.get();
if (instance == null) {
try { // 创建自适应扩展类
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;
}
@SuppressWarnings("unchecked")
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);
}
}
private Class<?> getAdaptiveExtensionClass() {
// 加载配置文件中扩展类
getExtensionClasses();
if (cachedAdaptiveClass != null) {
return cachedAdaptiveClass;
}
// 利用代码创建自适应扩展类
return cachedAdaptiveClass = createAdaptiveExtensionClass();
}
private Class<?> createAdaptiveExtensionClass() {
//自适应类代码
String code = createAdaptiveExtensionClassCode();
// 类加载器
ClassLoader classLoader = findClassLoader();
// 编译器
com.alibaba.dubbo.common.compiler.Compiler compiler = ExtensionLoader.getExtensionLoader(com.alibaba.dubbo.common.compiler.Compiler.class).getAdaptiveExtension();
// 编译
return compiler.compile(code, classLoader);
}
getActivateExtension过程分析
查找满足条件的自激活扩展类， 需要两步： 第一步从标注为@Activate的默认扩展类查找满足条件的自激活扩展类；第二步依据key和url获取url中对应的扩展名类别，然后查找列表中满足条件的扩展类。具体流程如源码注释
/*
* url 表示访问路径 包含激活扩展点信息,例如 dubbo://loclhost:8089?ext=bmpl,default
* key 表示需要从url中获取扩展名对应的键值信息
*group 分组信息 可以是consumer, provider组 消费者或者生产者组
*/
public List<T> getActivateExtension(URL url, String key, String group) {
String value = url.getParameter(key);
return getActivateExtension(url, value == null || value.length() == 0 ? null : Constants.COMMA_SPLIT_PATTERN.split(value), group);
}
/*
* url 还是表示访问路径url dubbo://127.0.0.1:8089?ext=bmpl, default
* values 表示获取完相应key对应的值的扩展名数组
* group 还是分组信息
* 先介绍一下激活规则，
* 1. -default表示所有默认的@Activate都不会被激活（就是添加过标注@Activate对应的扩展点不会被激活）。
* 2. default代表所有@Activate注解的扩展点的位置。比如上例bmpl扩展类激活顺序优于所有defalut表示的扩展点。
* 3. 如果传入"-"符号开头的扩展点名，则该扩展点也不会被自动激活。比如-xxxx,那么名字为xxx的扩展点不会被激活
*
*/
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);
// 对应规则1， 出现-default表示所有含注解@Activate的扩展点都不会被自动激活
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组
if (isMatchGroup(group, activate.group())) {
// 获取对应的扩展类实例
T ext = getExtension(name);
/* 三个条件需要同时满足
* 1. names中不存在相同的扩展名
* 2. names中没有禁用-name的扩展名. 也就是出现-name扩展名
* 3. isActive(activate, url) 满足激活条件 也就是activate对应的value数组元素， * 至少存在一个元素满足等于url中的key或者url中key和.value[i]相等，
* 且key对应的value不为空。
*/
if (!names.contains(name)
&& !names.contains(Constants.REMOVE_VALUE_PREFIX + name)
&& isActive(activate, url)) {
exts.add(ext);
}
}
//排序， 这也是为什么需要先检索表组@Activate的扩展类， 因为这些类激活的时候有顺序性
Collections.sort(exts, ActivateComparator.COMPARATOR);
}
//接着来看names里面满足激活条件的扩展名
List<T> usrs = new ArrayList<T>();
for (int i = 0; i < names.size(); i++) {
String name = names.get(i);
// 排除-开头， 或者names中包含-name的扩展名
if (!name.startsWith(Constants.REMOVE_VALUE_PREFIX)
&& !names.contains(Constants.REMOVE_VALUE_PREFIX + name)) {
// 如果name为default, 表示之前的那些扩展类激活顺序优于所有标注@Activate的扩展类
// 因此， addAll(0, usrs) index=0, 优先激活
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()) { // 其余扩展类激活顺序低于标注@Activate的扩展类
exts.addAll(usrs);
}
return exts;
}
/*
* 判断是否满足激活条件
* 也就是activate对应的value数组元素，至少存在一个元素满足等于url中的key或者url中key以.value[i]结尾 * 且key对应的value不为空。k.equals(key) || k.endsWith("." + key）
*/
private boolean isActive(Activate activate, URL url) {
String[] keys = activate.value();
if (keys.length == 0) {
return true;
}
for (String key : keys) {
for (Map.Entry<String, String> entry : url.getParameters().entrySet()) {
String k = entry.getKey();
String v = entry.getValue();
if ((k.equals(key) || k.endsWith("." + key))
&& ConfigUtils.isNotEmpty(v)) {
return true;
}
}
}
return false;
}
public @interface Activate {
/**
* 自激活对应的组信息
*/
String[] group() default {};
/**
* 对应的扩展名, 如果需要激活，则需要和url中key关联 即 至少一个value[i]满足等于key或者key.endwith("."+value[i]), 且url中key对应的value不为空
*/
String[] value() default {};
/**
* 在此扩展类之后调用
*/
String[] before() default {};
/**
* 在此扩展类之前调用
*/
String[] after() default {};
/**
* 绝对的自激活顺序规则
*/
int order() default 0;
}
自激活相应案例
首先定义扩展点
import com.alibaba.dubbo.common.extension.SPI;
@SPI
public interface PrintService {
void printInfo();
}
接着定义三个扩展类及配置文件
文件路径resources\META-INF\dubbo\com.test.spi.PrintService
impl=com.test.spi.PrintServiceImpl
ampl=com.test.spi.PrintServiceAImpl
bmpl=com.test.spi.PrintServiceBImpl
cmpl=com.test.spi.PrintServiceCImpl
扩展类A
@Activate(value = "A")
public class PrintServiceAImpl implements PrintService {
@Override
public void printInfo() {
System.out.println("hello " + this.getClass().getName());
System.out.println("end " + this.getClass().getName());
}
}
扩展类B
@Activate(value = "B")
public class PrintServiceBImpl implements PrintService {
@Override
public void printInfo() {
System.out.println("hello " + this.getClass().getName());
System.out.println("end " + this.getClass().getName());
}
}
扩展类C
@Activate(value = "ext")
public class PrintServiceCImpl implements PrintService {
@Override
public void printInfo() {
System.out.println("hello " + this.getClass().getName());
System.out.println("end " + this.getClass().getName());
}
}
测试方法 url dubbo://127.0.0.1:8089?sn.ext=bmpl, default
public static void main(String... args) {
ExtensionLoader<PrintService> extensionLoader = ExtensionLoader.getExtensionLoader(PrintService.class);
Map<String, String> param = new HashMap<>();
param.put("sn.ext", "bmpl, default");
URL url = new URL("dubbo", "127.0.0.1", 8089, param);
System.out.println(url.toFullString());
List<PrintService> ext =
extensionLoader.getActivateExtension(url, "sn.ext");
for (PrintService printService : ext) {
printService.printInfo();
}
}
首先查找标注为@Activate的所有类， 只有类C满足条件，然后查找扩展名为bmpl, default的扩展类，只有类B满足条件并且default表示类B的位置优于类C。因此，最终只有两个扩展类满足自激活条件， 扩展类B和扩展类C。且先激活扩展B, 再激活扩展C
结果如下
hello com.test.spi.PrintServiceBImpl
end com.test.spi.PrintServiceBImpl
hello com.test.spi.PrintServiceCImpl
end com.test.spi.PrintServiceCImpl
