Dubbo-Activate实现原理
前言
在Dubbo中有Filter使用，对于Filter来说我们会遇到这样的问题，Filter自身有很多的实现，我们希望某种条件下使用A实现，另外情况下使用B实现，这个时候我们前面介绍@SPI和@Adaptive就不能满足我们要求了，这个时候我们就需要使用@Activate。 Activate注解表示一个扩展是否被激活(使用),可以放在类定义和方法上，Dubbo中用它在扩展类定义上，表示这个扩展实现激活条件和时机。
如何使用
自定义接口；
@SPI
public interface ActivateDemo {
/**
* 测试
* @param msg
* @return
*/
String test(String msg);
}
实现接口，分别进行默认实现、多个组、排序、从URL获取值，多种方式的案例；
@Activate(group = {"default"})
public class DefaultActivateDemoImpl implements ActivateDemo {
@Override
public String test(String msg) {
return msg;
}
}
@Activate(group = {"groupA","groupB"})
public class ComposeGroupActivateDemoImpl implements ActivateDemo {
@Override
public String test(String msg) {
return msg;
}
}
@Activate(order = 1, group = {"order"})
public class Order1ActivateDemoImpl implements ActivateDemo{
@Override
public String test(String msg) {
return msg;
}
}
@Activate(order = 2, group = {"order"})
public class Order2ActivateDemoImpl implements ActivateDemo{
@Override
public String test(String msg) {
return msg;
}
}
@Activate(value = {"value"}, group = {"group"})
public class ValueAndGroupActivateDemoImpl implements ActivateDemo{
@Override
public String test(String msg) {
return msg;
}
}
在resources下新建META-INF/dubbo/internal文件夹，新建自己定义接口的全限定名文件名，名称以及内容可参考以下内容；
测试案例；
public static void main(String[] args) {
ExtensionLoader<ActivateDemo> loader = ExtensionLoader.getExtensionLoader(ActivateDemo.class);
URL url = URL.valueOf("test://localhost/test");
List<ActivateDemo> list = loader.getActivateExtension(url, new String[]{}, "order");
System.out.println(list.size());
list.forEach(item -> System.out.println(item.getClass()));
}
public static void main(String[] args) {
ExtensionLoader<ActivateDemo> loader = ExtensionLoader.getExtensionLoader(ActivateDemo.class);
URL url = URL.valueOf("test://localhost/test");
//注意这里要使用url接收,不能直接url.addParameter()
url = url.addParameter("value", "test");
List<ActivateDemo> list = loader.getActivateExtension(url, new String[]{"order1", "default"}, "group");
System.out.println(list.size());
list.forEach(item -> System.out.println(item.getClass()));
}
源码分析
@Activate注解标注在扩展实现类上，有 group、value 以及 order 三个属性，三个属性作用如下:
group 修饰的实现类可以列举为一种标签，标签用来区分是在 Provider 端被激活还是在 Consumer 端被激活； value 修饰的实现类只在 URL 参数中出现指定的 key 时才会被激活； order 用来确定扩展实现类的排序；
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE, ElementType.METHOD})
public @interface Activate {
String[] group() default {};
String[] value() default {};
@Deprecated
String[] before() default {};
@Deprecated
String[] after() default {};
int order() default 0;
}
SPI在扩展类加载时候， loadClass() 方法会对 @Activate的注解类进行扫描，其中会将包含 @Activate 注解的实现类缓存到 cachedActivates 一个Map集合中，Key为扩展名，Value为@Activate注解；
private void loadClass(Map<String, Class<?>> extensionClasses, java.net.URL resourceURL, Class<?> clazz, String name,
boolean overridden) throws NoSuchMethodException {
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注解
if (clazz.isAnnotationPresent(Adaptive.class)) {
cacheAdaptiveClass(clazz, overridden);
//是否是扩展类，是的话就加入 cachedWrapperClasses 属性
} else if (isWrapperClass(clazz)) {
cacheWrapperClass(clazz);
} else {
//检测是否有默认构造起
clazz.getConstructor();
if (StringUtils.isEmpty(name)) {
//未配置扩展名，自动生成，主要用于兼容java SPI的配置。
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) {
//存储Class到名字的映射关系
cacheName(clazz, n);
//存储名字到Class的映射关系
saveInExtensionClass(extensionClasses, clazz, n, overridden);
}
}
}
}
使用cachedActivates这个集合的地方是 getActivateExtension() ，关于此方法有4个重载函数，核心方法包含三个重要参数，URL中包含了配置信息，Values是配置中指定的扩展名，Group标签，下面是getActivateExtension的核心逻辑，首先就是获取默认的扩展集合，其次将扩获取到扩展类放到一个有序的集合中，按照顺序添加自定义扩展类的实现。
public List<T> getActivateExtension(URL url, String key) {
return getActivateExtension(url, key, null);
}
public List<T> getActivateExtension(URL url, String[] values) {
return getActivateExtension(url, values, null);
}
public List<T> getActivateExtension(URL url, String key, String group) {
String value = url.getParameter(key);
return getActivateExtension(url, StringUtils.isEmpty(value) ? null : COMMA_SPLIT_PATTERN.split(value), group);
}
public List<T> getActivateExtension(URL url, String[] values, String group) {
List<T> activateExtensions = new ArrayList<>();
// solve the bug of using @SPI's wrapper method to report a null pointer exception.
// TreeMap进行排序
TreeMap<Class, T> activateExtensionsMap = new TreeMap<>(ActivateComparator.COMPARATOR);
Set<String> loadedNames = new HashSet<>();
//传入的数组包装成为set
Set<String> names = CollectionUtils.ofSet(values);
//包装好的数据中判断不含"-default""
if (!names.contains(REMOVE_VALUE_PREFIX + DEFAULT_KEY)) {
//获取所有的加载类型
getExtensionClasses();
//cachedActivate 存储被@Activate修饰类型
for (Map.Entry<String, Object> entry : cachedActivates.entrySet()) {
String name = entry.getKey();
Object activate = entry.getValue();
String[] activateGroup, activateValue;
//兼容老的逻辑
if (activate instanceof Activate) {
activateGroup = ((Activate) activate).group();
activateValue = ((Activate) activate).value();
} else if (activate instanceof com.alibaba.dubbo.common.extension.Activate) {
activateGroup = ((com.alibaba.dubbo.common.extension.Activate) activate).group();
activateValue = ((com.alibaba.dubbo.common.extension.Activate) activate).value();
} else {
continue;
}
//判断group是否匹配
if (isMatchGroup(group, activateGroup)
//没有出现在values配置中的，即为默认激活的扩展实现
&& !names.contains(name)
//通过"-"明确指定不激活该扩展实现
&& !names.contains(REMOVE_VALUE_PREFIX + name)
//检测URL中是否出现了指定的Key
&& isActive(activateValue, url)
//去重判断
&& !loadedNames.contains(name)) {
//筛入treeMap中
activateExtensionsMap.put(getExtensionClass(name), getExtension(name));
loadedNames.add(name);
}
}
if (!activateExtensionsMap.isEmpty()) {
activateExtensions.addAll(activateExtensionsMap.values());
}
}
List<T> loadedExtensions = new ArrayList<>();
for (String name : names) {
//排除对应扩展名 不包含以-开始 以及 一+name
if (!name.startsWith(REMOVE_VALUE_PREFIX)
&& !names.contains(REMOVE_VALUE_PREFIX + name)) {
if (!loadedNames.contains(name)) {
if (DEFAULT_KEY.equals(name)) {
if (!loadedExtensions.isEmpty()) {
activateExtensions.addAll(0, loadedExtensions);
loadedExtensions.clear();
}
} else {
//获取对应名字扩展
loadedExtensions.add(getExtension(name));
}
loadedNames.add(name);
} else {
// If getExtension(name) exists, getExtensionClass(name) must exist, so there is no null pointer processing here.
String simpleName = getExtensionClass(name).getSimpleName();
logger.warn("Catch duplicated filter, ExtensionLoader will ignore one of them. Please check. Filter Name: " + name +
". Ignored Class Name: " + simpleName);
}
}
}
if (!loadedExtensions.isEmpty()) {
activateExtensions.addAll(loadedExtensions);
}
return activateExtensions;
}
结束
欢迎大家点点关注，点点赞!
