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

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

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

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

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

    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 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.                            } else if (activate instanceof com.alibaba.dubbo.common.extension.Activate) {
    37.                                activateGroup = ((com.alibaba.dubbo.common.extension.Activate) activate).group();
    39.                            } else {
    40.                                continue;
    41.                            }
    42.                            //缓存分组值
    43.                            cachedActivateGroups.put(name, new HashSet<>(Arrays.asList(activateGroup)));
    44.                            String[][] keyPairs = new String[activateValue.length][];
    45.                            //遍历指定的激活扩展的扩展名字列表
    46.                            for (int i = 0; i < activateValue.length; i++) {
    47.                                if (activateValue[i].contains(":")) {
    48.                                    keyPairs[i] = new String[2];
    49.                                    String[] arr = activateValue[i].split(":");
    50.                                    keyPairs[i][0] = arr[0];
    51.                                    keyPairs[i][1] = arr[1];
    52.                                } else {
    53.                                    keyPairs[i] = new String[1];
    54.                                    keyPairs[i][0] = activateValue[i];
    55.                                }
    56.                            }
    57.                            //缓存指定扩展信息
    58.                            cachedActivateValues.put(name, keyPairs);
    59.                        }
    60.                    }
    61.                }
    62.            }
    64.            // traverse all cached extensions
    65.            //遍历所有激活的扩展名字和扩展分组集合
    66.            cachedActivateGroups.forEach((name, activateGroup) -> {
    67.                //筛选当前扩展的扩展分组与激活扩展的扩展分组是否可以匹配
    68.                if (isMatchGroup(group, activateGroup)
    69.                    //不能是指定的扩展名字
    70.                    && !namesSet.contains(name)
    71.                    //也不能是带有 -指定扩展名字
    72.                    && !namesSet.contains(REMOVE_VALUE_PREFIX + name)
    73.                    //如果在Active注解中配置了value则当指定的键出现在URL的参数中时，激活当前扩展名。 
    74.                    //如果未配置value属性则默认都是匹配的(cachedActivateValues中不存在对应扩展名字的缓存的时候默认为true)
    75.                    && isActive(cachedActivateValues.get(name), url)) {
    76.                 //缓存激活的扩展类型映射的扩展名字
    77.                    activateExtensionsMap.put(getExtensionClass(name), getExtension(name));
    78.                }
    79.            });
    80.        }
    83.            // `ext1,default,ext2` means ext1 will happens before all of the default extensions while ext2 will after them
    84.            ArrayList<T> extensionsResult = new ArrayList<>(activateExtensionsMap.size() + names.size());
    85.            for (int i = 0; i < names.size(); i++) {
    86.                String name = names.get(i);
    87.                if (!name.startsWith(REMOVE_VALUE_PREFIX)
    88.                    && !namesSet.contains(REMOVE_VALUE_PREFIX + name)) {
    89.                    if (!DEFAULT_KEY.equals(name)) {
    90.                        if (containsExtension(name)) {
    91.                            extensionsResult.add(getExtension(name));
    92.                        }
    93.                    } else {
    94.                        extensionsResult.addAll(activateExtensionsMap.values());
    95.                    }
    96.                }
    97.            }
    98.            return extensionsResult;
    99.        } else {
    100.            // add extensions, will be sorted by its order
    101.            for (int i = 0; i < names.size(); i++) {
    102.                String name = names.get(i);
    103.                if (!name.startsWith(REMOVE_VALUE_PREFIX)
    104.                    && !namesSet.contains(REMOVE_VALUE_PREFIX + name)) {
    105.                    if (!DEFAULT_KEY.equals(name)) {
    106.                        if (containsExtension(name)) {
    107.                            activateExtensionsMap.put(getExtensionClass(name), getExtension(name));
    108.                        }
    109.                    }
    110.                }
    111.            }
    112.            return new ArrayList<>(activateExtensionsMap.values());
    113.        }
    114.    }
    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.         }

    技术咨询与支持,可以扫描微信公众号进行回复咨询