一篇文章彻底弄懂dubbo的SPI机制的原理

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
    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 an interface!");
        }
        if (!withExtensionAnnotation(type)) {
            throw new IllegalArgumentException("Extension type (" + type +
                ") is not an extension, because it is NOT annotated with @" + SPI.class.getSimpleName() + "!");
        }

        //首先从缓存中获取ExtensionLoader
        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;
    }
复制代码

1
2
3
4
5
6
7
8
public T getExtension(String name) {
        T extension = getExtension(name, true);
        if (extension == null) {
            throw new IllegalArgumentException("Not find extension: " + name);
        }
        return extension;
    }
复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public T getExtension(String name, boolean wrap) {
        if (StringUtils.isEmpty(name)) {
            throw new IllegalArgumentException("Extension name == null");
        }
        //如果传的是true字符串 调用getDefaultExtension()获取默认的扩展点实例
        if ("true".equals(name)) {
            return getDefaultExtension();
        }
        //获取对应的holder对象 holder是用来缓存实例的
        final Holder<Object> holder = getOrCreateHolder(name);
        //如果holder缓存中的实例是null 那么就双重检查锁 调用createExtension创建对应的扩展点实例 然后放到holder对象中缓存起来
        Object instance = holder.get();
        if (instance == null) {
            synchronized (holder) {
                instance = holder.get();
                if (instance == null) {
                    instance = createExtension(name, wrap);
                    holder.set(instance);
                }
            }
        }
        return (T) instance;
    }
复制代码

1
2
3
4
5
6
7
8
9
10
11
    public T getDefaultExtension() {
        //这个方法是用来读取spi配置并且初始化默认值的，其中就包括了cachedDefaultName，
        //所以初始化之后通过cachedDefaultName调用getExtension获取默认的扩展点实例
        getExtensionClasses();
        //如果默认的name是空的或者还是true字符串 那么返回null 否则根据默认的name去获取扩展点实例
        if (StringUtils.isBlank(cachedDefaultName) || "true".equals(cachedDefaultName)) {
            return null;
        }
        return getExtension(cachedDefaultName);
    }
复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
    private Map<String, Class<?>> getExtensionClasses() {
        //双重检查锁 先从缓存中取，取不到的话读取配置进行初始化
        Map<String, Class<?>> classes = cachedClasses.get();
        if (classes == null) {
            synchronized (cachedClasses) {
                classes = cachedClasses.get();
                if (classes == null) {
                    classes = loadExtensionClasses();
                    cachedClasses.set(classes);
                }
            }
        }
        return classes;
    }
复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
private Map<String, Class<?>> loadExtensionClasses() {
        //这个方法就是初始化cachedDefaultName的
        cacheDefaultExtensionName();

        Map<String, Class<?>> extensionClasses = new HashMap<>();

        //根据不同的策略读取不同的配置文件，包括MTEA-INF/dubbo
        // META-INF/services  META-INF/dubbo/internal 三个目录
        for (LoadingStrategy strategy : strategies) {
            loadDirectory(extensionClasses, strategy.directory(), type.getName(), strategy.preferExtensionClassLoader(), strategy.overridden(), strategy.excludedPackages());
            //为了适配之前旧的版本（没有捐给apache之前的包名是com.alibaba）
            loadDirectory(extensionClasses, strategy.directory(), type.getName().replace("org.apache", "com.alibaba"), strategy.preferExtensionClassLoader(), strategy.overridden(), strategy.excludedPackages());
        }

        return extensionClasses;
    }
复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
    private void cacheDefaultExtensionName() {
        // 获取到接口的@SPI注解
        final SPI defaultAnnotation = type.getAnnotation(SPI.class);
        if (defaultAnnotation == null) {
            return;
        }
        //获取注解中的value
        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进行初始化
                cachedDefaultName = names[0];
            }
        }
    }
复制代码

1
2
    private static volatile LoadingStrategy[] strategies = loadLoadingStrategies();
复制代码

1
2
3
4
5
6
private static LoadingStrategy[] loadLoadingStrategies() {
        return stream(load(LoadingStrategy.class).spliterator(), false)
            .sorted()
            .toArray(LoadingStrategy[]::new);
    }
复制代码

1
2
3
4
org.apache.dubbo.common.extension.DubboInternalLoadingStrategy
org.apache.dubbo.common.extension.DubboLoadingStrategy
org.apache.dubbo.common.extension.ServicesLoadingStrategy
复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
private void loadDirectory(Map<String, Class<?>> extensionClasses, String dir, String type,
                               boolean extensionLoaderClassLoaderFirst, boolean overridden, String... excludedPackages) {
        //通过目录和接口全类名获取到SPI配置文件名称                      
        String fileName = dir + type;
        try {
            Enumeration<java.net.URL> urls = null;
            ClassLoader classLoader = findClassLoader();

            // try to load from ExtensionLoader's ClassLoader first
            if (extensionLoaderClassLoaderFirst) {
                ClassLoader extensionLoaderClassLoader = ExtensionLoader.class.getClassLoader();
                if (ClassLoader.getSystemClassLoader() != extensionLoaderClassLoader) {
                    urls = extensionLoaderClassLoader.getResources(fileName);
                }
            }

            if (urls == null || !urls.hasMoreElements()) {
                if (classLoader != null) {
                    urls = classLoader.getResources(fileName);
                } else {
                    urls = ClassLoader.getSystemResources(fileName);
                }
            }

            if (urls != null) {
                while (urls.hasMoreElements()) {
                    java.net.URL resourceURL = urls.nextElement();
                    //加载配置解析SPI配置文件
                    loadResource(extensionClasses, classLoader, resourceURL, overridden, excludedPackages);
                }
            }
        } catch (Throwable t) {
            logger.error("Exception occurred when loading extension class (interface: " +
                type + ", description file: " + fileName + ").", t);
        }
    }
复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
private void loadResource(Map<String, Class<?>> extensionClasses, ClassLoader classLoader,
                              java.net.URL resourceURL, boolean overridden, String... excludedPackages) {
        try {
            try (BufferedReader reader = new BufferedReader(new InputStreamReader(resourceURL.openStream(), StandardCharsets.UTF_8))) {
                String line;
                String clazz = null;
                //一行一行的读取
                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 {
                            //根据“=”号进行分隔 等号前的是name，后面的是对应的类名
                            String name = null;
                            int i = line.indexOf('=');
                            if (i > 0) {
                                name = line.substring(0, i).trim();
                                clazz = line.substring(i + 1).trim();
                            } else {
                                clazz = line;
                            }
                            if (StringUtils.isNotEmpty(clazz) && !isExcluded(clazz, excludedPackages)) {
                                //如果类名不为空 而且没有被排除加载 那么调用loadClass()方法
                                loadClass(extensionClasses, resourceURL, Class.forName(clazz, true, classLoader), name, overridden);
                            }
                        } 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);
                        }
                    }
                }
            }
        } catch (Throwable t) {
            logger.error("Exception occurred when loading extension class (interface: " +
                type + ", class file: " + resourceURL + ") in " + resourceURL, t);
        }
    }
复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
private void loadClass(Map<String, Class<?>> extensionClasses, java.net.URL resourceURL, Class<?> clazz, String name,
                           boolean overridden) throws NoSuchMethodException {
        // 如果class不是type的实现类 抛出异常                   
        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)) {
            //缓存默认的adaptive类
            cacheAdaptiveClass(clazz, overridden);
        } else if (isWrapperClass(clazz)) {
            //判断是不是包装类就是看他有没有扩展点类型的构造器 其实就是装饰器模式
            //如果是包装类 那么缓存包装类
            cacheWrapperClass(clazz);
        } else {
            //这里要求扩展点的实现类必须有无参构造函数，不然会抛出NoSuchMethodException
            clazz.getConstructor();
            if (StringUtils.isEmpty(name)) {
                //获取配置的name为空的话（配置文件支持不配key），如果实现类上有@Extension注解，优先拿@Extension注解的value作为name，否则name就为实现类的简单类名的小写
                name = findAnnotationName(clazz);
                if (name.length() == 0) {
                    throw new IllegalStateException("No such extension name for the class " + clazz.getName() + " in the config " + resourceURL);
                }
            }
            //如果name中有',',那么相当于是多个name用','分开
            String[] names = NAME_SEPARATOR.split(name);
            if (ArrayUtils.isNotEmpty(names)) {
                //如果实现类上有@Activate注解，那么初始化cachedActivates
                cacheActivateClass(clazz, names[0]);
                for (String n : names) {
                    //缓存实现类与name的关系
                    cacheName(clazz, n);
                    //保存name与实现类的关系到extensionClasses中，注意adaptive类是不会保存在extensionClasses里面的 在第一个if对adaptive类进行了处理
                    saveInExtensionClass(extensionClasses, clazz, n, overridden);
                }
            }
        }
    }
复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
private T createExtension(String name, boolean wrap) {
        //从cachedClasses中通过名字获取到扩展点实现类的class对象 因为前面已经分析过了getExtensionClasses()会将cachedClasses初始化 
        Class<?> clazz = getExtensionClasses().get(name);
        //没有对应实现类的class 抛出异常
        if (clazz == null || unacceptableExceptions.contains(name)) {
            throw findException(name);
        }
        try {
            //获取对应实现类的实例 还是线程缓存中取 没有的话就反射创建一个对象
            T instance = (T) EXTENSION_INSTANCES.get(clazz);
            if (instance == null) {
                EXTENSION_INSTANCES.putIfAbsent(clazz, clazz.getDeclaredConstructor().newInstance());
                instance = (T) EXTENSION_INSTANCES.get(clazz);
            }
            //依赖注入spi属性 这个方法很关键 涉及到dubbo SPI的DI 需要重点分析
            injectExtension(instance);
            
            //这里wrap默认是true 也就是支持包装 所以需要将对象包装返回包装对象出去
            if (wrap) {

                List<Class<?>> wrapperClassesList = new ArrayList<>();
                if (cachedWrapperClasses != null) {
                    //获取缓存的包装类 
                    //前面已经分析过cachedWrapperClasses会在getExtensionClasses()中初始化
                    wrapperClassesList.addAll(cachedWrapperClasses);
                    //排个序
                    wrapperClassesList.sort(WrapperComparator.COMPARATOR);
                    Collections.reverse(wrapperClassesList);
                }

                if (CollectionUtils.isNotEmpty(wrapperClassesList)) {
                    for (Class<?> wrapperClass : wrapperClassesList) {
                        Wrapper wrapper = wrapperClass.getAnnotation(Wrapper.class);
                        if (wrapper == null
                            || (ArrayUtils.contains(wrapper.matches(), name) && !ArrayUtils.contains(wrapper.mismatches(), name))) {
                            //对原生对象进行包装 并且对包装类进行DI
                            instance = injectExtension((T) wrapperClass.getConstructor(type).newInstance(instance));
                        }
                    }
                }
            }
            //调用一下生命周期的方法
            initExtension(instance);
            //将实例返回出去
            return instance;
        } catch (Throwable t) {
            throw new IllegalStateException("Extension instance (name: " + name + ", class: " +
                type + ") couldn't be instantiated: " + t.getMessage(), t);
        }
    }
复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
private T injectExtension(T instance) {

        if (objectFactory == null) {
            //objectFactory为null 直接返回
            return instance;
        }

        try {
            //遍历类中所有的方法
            for (Method method : instance.getClass().getMethods()) {
                if (!isSetter(method)) {
                    //不是set方法 直接跳过
                    continue;
                }
                /**
                 * Check {@link DisableInject} to see if we need auto injection for this property
                 */
                 //方法上如果有@DisableInject注解 那么直接跳过
                if (method.getAnnotation(DisableInject.class) != null) {
                    continue;
                }
                Class<?> pt = method.getParameterTypes()[0];
                //如果是8大基本类型 直接跳过
                if (ReflectUtils.isPrimitives(pt)) {
                    continue;
                }

                try {
                    //通过解析set方法方法名获取到属性的名称
                    String property = getSetterProperty(method);
                    //从objectFactory中获取实例
                    Object object = objectFactory.getExtension(pt, property);
                    if (object != null) {
                        //获取到的实例不为null 那么反射调用set方法赋值 完成DI
                        method.invoke(instance, object);
                    }
                } catch (Exception e) {
                    logger.error("Failed to inject via method " + method.getName()
                        + " of interface " + type.getName() + ": " + e.getMessage(), e);
                }

            }
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
        }
        return instance;
    }
复制代码

1
2
3
4
5
6
private ExtensionLoader(Class<?> type) {
        this.type = type;
        //如果正好是ExtensionFactory自己的扩展点，那么就返回null 否则赋值为ExtensionFactory扩展点的adaptive类
        objectFactory = (type == ExtensionFactory.class ? null : ExtensionLoader.getExtensionLoader(ExtensionFactory.class).getAdaptiveExtension());
    }
复制代码

1
2
3
4
5
6
7
8
9
10
11
    public AdaptiveExtensionFactory() {
        ExtensionLoader<ExtensionFactory> loader = ExtensionLoader.getExtensionLoader(ExtensionFactory.class);
        List<ExtensionFactory> list = new ArrayList<ExtensionFactory>();
        //获取到ExtensionFactory扩展点的非adaptived的其他所有实现类
        for (String name : loader.getSupportedExtensions()) {
            //加入到list中赋值给成员变量factories
            list.add(loader.getExtension(name));
        }
        factories = Collections.unmodifiableList(list);
    }
复制代码

1
2
3
4
5
6
7
8
9
10
11
12
    public <T> T getExtension(Class<T> type, String name) {
        //循环保存的对象工厂获取实例
        for (ExtensionFactory factory : factories) {
            T extension = factory.getExtension(type, name);
            if (extension != null) {
                //获取到了就返回
                return extension;
            }
        }
        return null;
    }
复制代码

1
2
3
4
5
6
7
8
9
10
public <T> T getExtension(Class<T> type, String name) {
        if (type.isInterface() && type.isAnnotationPresent(SPI.class)) {
            ExtensionLoader<T> loader = ExtensionLoader.getExtensionLoader(type);
            if (!loader.getSupportedExtensions().isEmpty()) {
                return loader.getAdaptiveExtension();
            }
        }
        return null;
    }
复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
    @Override
    @SuppressWarnings("unchecked")
    public <T> T getExtension(Class<T> type, String name) {

        //SPI should be get from SpiExtensionFactory
        if (type.isInterface() && type.isAnnotationPresent(SPI.class)) {
            return null;
        }

        for (ApplicationContext context : CONTEXTS) {
            T bean = BeanFactoryUtils.getOptionalBean(context, name, type);
            if (bean != null) {
                return bean;
            }
        }

        //logger.warn("No spring extension (bean) named:" + name + ", try to find an extension (bean) of type " + type.getName());

        return null;
    }
复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
public T getAdaptiveExtension() {
        //先从缓存中取
        Object instance = cachedAdaptiveInstance.get();
        if (instance == null) {
            if (createAdaptiveInstanceError != null) {
                throw new IllegalStateException("Failed to create adaptive instance: " +
                    createAdaptiveInstanceError.toString(),
                    createAdaptiveInstanceError);
            }
            //双重检查锁
            synchronized (cachedAdaptiveInstance) {
                instance = cachedAdaptiveInstance.get();
                if (instance == null) {
                    try {
                        //实例为null 调用createAdaptiveExtension()方法获取实例
                        instance = createAdaptiveExtension();
                        //将实例放入缓存中
                        cachedAdaptiveInstance.set(instance);
                    } catch (Throwable t) {
                        createAdaptiveInstanceError = t;
                        throw new IllegalStateException("Failed to create adaptive instance: " + t.toString(), t);
                    }
                }
            }
        }
        //返回实例
        return (T) instance;
    }
复制代码

1
2
3
4
5
6
7
8
private T createAdaptiveExtension() {
        try {
            return injectExtension((T) getAdaptiveExtensionClass().newInstance());
        } catch (Exception e) {
            throw new IllegalStateException("Can't create adaptive extension " + type + ", cause: " + e.getMessage(), e);
        }
    }
复制代码

1
2
3
4
5
6
7
8
9
10
private Class<?> getAdaptiveExtensionClass() {
        //解析配置 初始化一些缓存成员变量 其中包括cachedAdaptiveClass
        getExtensionClasses();
        if (cachedAdaptiveClass != null) {
            return cachedAdaptiveClass;
        }
        //如果cachedAdaptiveClass还是为null 说明该扩展点没有存在@Adaptive注解的实现类
        return cachedAdaptiveClass = createAdaptiveExtensionClass();
    }
复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
private Class<?> createAdaptiveExtensionClass() {
        ClassLoader classLoader = findClassLoader();
        try {
            if (ApplicationModel.getEnvironment().getConfiguration().getBoolean(NATIVE, false)) {
                return classLoader.loadClass(type.getName() + "$Adaptive");
            }
        } catch (Throwable ignore) {

        }
        //通过扩展点的type和默认的扩展点实现类的name拼接成一个类的字符串
        String code = new AdaptiveClassCodeGenerator(type, cachedDefaultName).generate();
        //获取编译器
        org.apache.dubbo.common.compiler.Compiler compiler = ExtensionLoader.getExtensionLoader(org.apache.dubbo.common.compiler.Compiler.class).getAdaptiveExtension();
        //编译代码
        return compiler.compile(code, classLoader);
    }
复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
public String generate() {
    // no need to generate adaptive class since there's no adaptive method found.
    //如果扩展点接口没有加了@Adaptive注解的方法 那么抛出异常
    if (!hasAdaptiveMethod()) {
        throw new IllegalStateException("No adaptive method exist on extension " + type.getName() + ", refuse to create the adaptive class!");
    }
    //开始拼接字符串
    StringBuilder code = new StringBuilder();
    //首先拼接包名
    code.append(generatePackageInfo());
    //拼接导入的类
    code.append(generateImports());
    //拼接类名
    code.append(generateClassDeclaration());

    //获取到扩展点接口的所有方法 进行循环
    Method[] methods = type.getMethods();
    for (Method method : methods) {
        //生成接口方法实现
        code.append(generateMethod(method));
    }
    code.append('}');

    if (logger.isDebugEnabled()) {
        logger.debug(code.toString());
    }
    return code.toString();
}
复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
package org.apache.dubbo.metadata.report;
import org.apache.dubbo.common.extension.ExtensionLoader;
public class MetadataReportFactory$Adaptive implements org.apache.dubbo.metadata.report.MetadataReportFactory {
public org.apache.dubbo.metadata.report.MetadataReport getMetadataReport(org.apache.dubbo.common.URL arg0)  {
if (arg0 == null) throw new IllegalArgumentException("url == null");
org.apache.dubbo.common.URL url = arg0;
String extName = ( url.getProtocol() == null ? "redis" : url.getProtocol() );
if(extName == null) throw new IllegalStateException("Failed to get extension (org.apache.dubbo.metadata.report.MetadataReportFactory) name from url (" + url.toString() + ") use keys([protocol])");
org.apache.dubbo.metadata.report.MetadataReportFactory extension = (org.apache.dubbo.metadata.report.MetadataReportFactory)ExtensionLoader.getExtensionLoader(org.apache.dubbo.metadata.report.MetadataReportFactory.class).getExtension(extName);
return extension.getMetadataReport(arg0);
}
}
复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public List<T> getActivateExtensions() {
    List<T> activateExtensions = new ArrayList<>();
    TreeMap<Class<?>, T> activateExtensionsMap = new TreeMap<>(ActivateComparator.COMPARATOR);
    //初始化
    getExtensionClasses();
    for (Map.Entry<String, Object> entry : cachedActivates.entrySet()) {
        String name = entry.getKey();
        Object activate = entry.getValue();
        if (!(activate instanceof Activate)) {
            continue;
        }
        //建立class与实例之间的关系
        activateExtensionsMap.put(getExtensionClass(name), getExtension(name));
    }
    if (!activateExtensionsMap.isEmpty()) {
        activateExtensions.addAll(activateExtensionsMap.values());
    }

    return activateExtensions;
}
复制代码