7-Dubbo的SPI扩展机制之自动激活扩展Activate源码解析

7.1 Activate扩展的说明

此注解对于使用给定条件自动激活某些扩展非常有用，例如：@Activate可用于在有多个实现时加载某些筛选器扩展。

  • group() 指定组条件。框架SPI定义了有效的组值。
  • value() 指定URL条件中的参数键。

SPI提供程序可以调用ExtensionLoader。getActivateExtension(URL、String、String)方法以查找具有给定条件的所有已激活扩展。

比如后面我们会说到的过滤器扩展对象的获取,如下通过调用getActivateExtension方法的代码:

  1. List<Filter> filters;
  2. filters = ScopeModelUtil.getExtensionLoader(Filter.class, moduleModels.get(0)).getActivateExtension(url, key, group);

7.2 获取自动激活扩展的源码

前面我们看了激活扩展是通过调用getActivateExtension方法来获取对象的,那接下来就来看下这个方法做了什么操作:

  1. /**
  2. * @param url 服务的url
  3. * @param key  用于获取扩展点名称的url参数键 比如监听器:exporter.listener,过滤器:params-filter,telnet处理器:telnet
  4. */
  5.  public List<T> getActivateExtension(URL url, String key) {
  6.         return getActivateExtension(url, key, null);
  7.     }

继续调用重载的方法

  1. /**
  2.      *  
  3.      *
  4.      * @param url   服务的url
  5.      * @param key   用于获取扩展点名称的url参数键 比如监听器:exporter.listener,过滤器:params-filter,telnet处理器:telnet
  6.      * @param group group 用于筛选的分组,比如过滤器中使用此参数来区分消费者使用这个过滤器还是提供者使用这个过滤器他们的group参数分表为consumer,provider
  7.      * @return 已激活的扩展列表。
  8.      */
  9.  public List<T> getActivateExtension(URL url, String key, String group) {
  10.          //从参数中获取url指定的值
  11.         String value = url.getParameter(key);
  12.         //调用下个重载的方法
  13.         return getActivateExtension(url, StringUtils.isEmpty(value) ? null : COMMA_SPLIT_PATTERN.split(value), group);
  14.     }

上面的重载方法都是用来转换参数的,下面这个方法才是真正的逻辑

  1. /**
  2.     * 获取激活扩展.
  3.     *
  4.     * @param url    服务的url
  5.     * @param values 这个value是扩展点的名字 当指定了时候会使用指定的名字的扩展
  6.     * @param group  group 用于筛选的分组,比如过滤器中使用此参数来区分消费者使用这个过滤器还是提供者使用这个过滤器他们的group参数分表为consumer,provider
  7.     * @return 获取激活扩展.
  8.     */
  9.    public List<T> getActivateExtension(URL url, String[] values, String group) {
  10.        //检查扩展加载器是否被销毁了
  11.        checkDestroyed();
  12.        // solve the bug of using @SPI's wrapper method to report a null pointer exception.
  13.        //创建个有序的Map集合,用来对扩展进行排序
  14.        Map<Class<?>, T> activateExtensionsMap = new TreeMap<>(activateComparator);
  15.        //初始化扩展名字,指定了扩展名字values不为空
  16.        List<String> names = values == null ? new ArrayList<>(0) : asList(values);
  17.        //扩展名字使用Set集合进行去重
  18.        Set<String> namesSet = new HashSet<>(names);
  19.        //参数常量是 -default  扩展名字是否不包含默认的
  20.        if (!namesSet.contains(REMOVE_VALUE_PREFIX + DEFAULT_KEY)) {
  21.            //第一次进来肯定是没有缓存对象双重校验锁检查下
  22.            if (cachedActivateGroups.size() == 0) {
  23.                synchronized (cachedActivateGroups) {
  24.                    // cache all extensions
  25.                    if (cachedActivateGroups.size() == 0) {
  26.                        //加载扩展类型对应的扩展类,这个具体细节参考源码或者《[Dubbo3.0.7源码解析系列]-5-Dubbo的SPI扩展机制与自适应扩展对象的创建与扩展文件的扫描源码解析》章节
  27.                        getExtensionClasses();
  28.                        for (Map.Entry<String, Object> entry : cachedActivates.entrySet()) {
  29.                            String name = entry.getKey();
  30.                            Object activate = entry.getValue();
  32.                            String[] activateGroup, activateValue;
  33.                         //遍历所有的activates列表获取group()和value()值
  34.                            if (activate instanceof Activate) {
  35.                                activateGroup = ((Activate) activate).group();
  36.                                activateValue = ((Activate) activate).value();
  37.                            } else if (activate instanceof com.alibaba.dubbo.common.extension.Activate) {
  38.                                activateGroup = ((com.alibaba.dubbo.common.extension.Activate) activate).group();
  39.                                activateValue = ((com.alibaba.dubbo.common.extension.Activate) activate).value();
  40.                            } else {
  41.                                continue;
  42.                            }
  43.                            //缓存分组值
  44.                            cachedActivateGroups.put(name, new HashSet<>(Arrays.asList(activateGroup)));
  45.                            String[][] keyPairs = new String[activateValue.length][];
  46.                            //遍历指定的激活扩展的扩展名字列表
  47.                            for (int i = 0; i < activateValue.length; i++) {
  48.                                if (activateValue[i].contains(":")) {
  49.                                    keyPairs[i] = new String[2];
  50.                                    String[] arr = activateValue[i].split(":");
  51.                                    keyPairs[i][0] = arr[0];
  52.                                    keyPairs[i][1] = arr[1];
  53.                                } else {
  54.                                    keyPairs[i] = new String[1];
  55.                                    keyPairs[i][0] = activateValue[i];
  56.                                }
  57.                            }
  58.                            //缓存指定扩展信息
  59.                            cachedActivateValues.put(name, keyPairs);
  60.                        }
  61.                    }
  62.                }
  63.            }
  65.            // traverse all cached extensions
  66.            //遍历所有激活的扩展名字和扩展分组集合
  67.            cachedActivateGroups.forEach((name, activateGroup) -> {
  68.                //筛选当前扩展的扩展分组与激活扩展的扩展分组是否可以匹配
  69.                if (isMatchGroup(group, activateGroup)
  70.                    //不能是指定的扩展名字
  71.                    && !namesSet.contains(name)
  72.                    //也不能是带有 -指定扩展名字
  73.                    && !namesSet.contains(REMOVE_VALUE_PREFIX + name)
  74.                    //如果在Active注解中配置了value则当指定的键出现在URL的参数中时，激活当前扩展名。 
  75.                    //如果未配置value属性则默认都是匹配的(cachedActivateValues中不存在对应扩展名字的缓存的时候默认为true)
  76.                    && isActive(cachedActivateValues.get(name), url)) {
  77.                 //缓存激活的扩展类型映射的扩展名字
  78.                    activateExtensionsMap.put(getExtensionClass(name), getExtension(name));
  79.                }
  80.            });
  81.        }
  83.        if (namesSet.contains(DEFAULT_KEY)) {
  84.            // will affect order
  85.            // `ext1,default,ext2` means ext1 will happens before all of the default extensions while ext2 will after them
  86.            ArrayList<T> extensionsResult = new ArrayList<>(activateExtensionsMap.size() + names.size());
  87.            for (int i = 0; i < names.size(); i++) {
  88.                String name = names.get(i);
  89.                if (!name.startsWith(REMOVE_VALUE_PREFIX)
  90.                    && !namesSet.contains(REMOVE_VALUE_PREFIX + name)) {
  91.                    if (!DEFAULT_KEY.equals(name)) {
  92.                        if (containsExtension(name)) {
  93.                            extensionsResult.add(getExtension(name));
  94.                        }
  95.                    } else {
  96.                        extensionsResult.addAll(activateExtensionsMap.values());
  97.                    }
  98.                }
  99.            }
  100.            return extensionsResult;
  101.        } else {
  102.            // add extensions, will be sorted by its order
  103.            for (int i = 0; i < names.size(); i++) {
  104.                String name = names.get(i);
  105.                if (!name.startsWith(REMOVE_VALUE_PREFIX)
  106.                    && !namesSet.contains(REMOVE_VALUE_PREFIX + name)) {
  107.                    if (!DEFAULT_KEY.equals(name)) {
  108.                        if (containsExtension(name)) {
  109.                            activateExtensionsMap.put(getExtensionClass(name), getExtension(name));
  110.                        }
  111.                    }
  112.                }
  113.            }
  114.            return new ArrayList<>(activateExtensionsMap.values());
  115.        }
  116.    }

再来回顾下扫描扩展类型的时候,与激活扩展的相关扫描代码:
与激活注解关键的代码位置在这里ExtensionLoader的loadClass方法中
我来贴下loadClass方法核心的代码:

  1. if (clazz.isAnnotationPresent(Adaptive.class)) {
  2.             cacheAdaptiveClass(clazz, overridden);
  3.         } else if (isWrapperClass(clazz)) {
  4.             cacheWrapperClass(clazz);
  5.         } else {
  6.             if (StringUtils.isEmpty(name)) {
  7.                 name = findAnnotationName(clazz);
  8.                 if (name.length() == 0) {
  9.                     throw new IllegalStateException("No such extension name for the class " + clazz.getName() + " in the config " + resourceURL);
  10.                 }
  11.             }
  13.             String[] names = NAME_SEPARATOR.split(name);
  14.             if (ArrayUtils.isNotEmpty(names)) {
  15.             //位置在这里其他地方就不标记注释了,前面判断了如果不是Adaptive也不是Wrapper类型则我们可以来判断是否为Activate 类型如果是的话调用cacheActivateClass方法将扩展缓存进cachedActivates缓存中
  16.                 cacheActivateClass(clazz, names[0]);
  17.                 for (String n : names) {
  18.                     cacheName(clazz, n);
  19.                     saveInExtensionClass(extensionClasses, clazz, n, overridden);
  20.                 }
  21.             }
  22.         }
  1. private void cacheActivateClass(Class<?> clazz, String name) {
  2.         Activate activate = clazz.getAnnotation(Activate.class);
  3.         if (activate != null) {
  4.             //注解存在则加入激活注解缓存
  5.             cachedActivates.put(name, activate);
  6.         } else {
  7.             // support com.alibaba.dubbo.common.extension.Activate
  8.             com.alibaba.dubbo.common.extension.Activate oldActivate = clazz.getAnnotation(com.alibaba.dubbo.common.extension.Activate.class);
  9.             if (oldActivate != null) {
  10.                 cachedActivates.put(name, oldActivate);
  11.             }
  12.         }
  13.     }

技术咨询与支持,可以扫描微信公众号进行回复咨询
在这里插入图片描述