ExtensionLoader类分析

Posted 09120912zhang

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了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(PrintService.class), 进入创建代码分析

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-INFdubbointernalcom.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过程分析

  1. 如果name为true表示取默认扩展名对应的扩展类;否则, 从扩展类实例缓存中查找。
  2. 如果扩展名及扩展类实例缓存不存在相应的记录 , 调用createExtension方法; 否则直接返回。
  3. 加载配置文件中扩展类信息,接着再次从实例缓存中查找,如果缓存不存在,实例化扩展类并添加在实力缓存中,否则直接取出
  4. 依赖注入方法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分析

  1. 缓存中是否存在自适应扩展类, 如果存在直接返回; 否则进入步骤2
  2. 加载扩展类配置信息,即getAdaptiveExtensionClass中调用的getExtensionClasses方法. 再次查看缓存是够存在,存在直接返回,不存在转入步骤3
  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();
}

接着定义三个扩展类及配置文件

文件路径resourcesMETA-INFdubbocom.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

以上是关于ExtensionLoader类分析的主要内容,如果未能解决你的问题,请参考以下文章

Dubbo SPI 源码深入分析

ExtensionLoader

Dubbo ExtensionLoader 详解

dubbo源码梳理之ExtensionLoader

05_dubbo_aop

Dubbo#编译动态扩展类