在dubbo中几乎所有的功能组件都是基于SPI来实现的,dubbo良好的扩展性也与SPI加载机制密不可分,所以要想更进一步理解使用dubbo或者阅读dubbo的源码,SPI是一定要懂的。本文主要通过源码分析的方式来理解dubbo SPI的实现原理。

1.ExtensionLoader

ExtensionLoader是整个dubbo SPI最主要的类,在这个类中实现了SPI配置的加载,扩展类缓存,自适应对象生成,DI等核心逻辑。首先我们看ExtensionLoader是怎么创建的。

通过ExtensionLoader的静态方法getExtensionLoader我们可以获取一个ExtensionLoader。逻辑很简单,先从缓存里面取,如果缓存中没有,那么new一个ExtensionLoader放进去,每一个type对应一个ExtensionLoader

    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;
    }
复制代码

接下来我们通过getExtension(),getAdaptiveExtension(),getActivateExtensions()三个方法为入口对ExtensionLoader的核心代码进行分析。

1.getExtension()

getExtension()方法的作用是通过名字获取具体的实现类的实例。它会调用另外一个重载的方法,我们重点看重载方法。

public T getExtension(String name) {
        T extension = getExtension(name, true);
        if (extension == null) {
            throw new IllegalArgumentException("Not find extension: " + name);
        }
        return extension;
    }
复制代码

流程图

如果name是字符串true,那么会调用getDefaultExtension()方法获取默认的扩展点实例。否则会先从缓存holder中获取对应名称的扩展点实例,获取不到的话调用createExtension()方法创建扩展点实例并且放入到holder对象中缓存起来。这里我们重点对getDefaultExtension(),createExtension()两个方法进行分析。

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;
    }
复制代码

getDefaultExtension()

首先调用getExtensionClasses()方法,这个方法非常重要,要重点进行分析,它的作用是用来读取SPI配置并且初始化SPI一些默认值的,其中就包括cachedDefaultName的初始化,cachedDefaultName用来缓存默认的扩展点的name。然后调用通过cachedDefaultName再次调用getExtension()方法获取扩展点实例。

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

getExtensionClasses()

这个方法是重点,用来加载SPI配置,并且初始化默认值的,首先获取cachedClasses中缓存的map,这个map保存的key是SPI配置中的key,value则是配置中的value对应的class对象。 如果缓存中没有那么调用loadExtensionClasses()方法读取配置并且缓存到cachedClasses中。

    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;
    }
复制代码

loadExtensionClasses()

调用cacheDefaultExtensionName()方法初始化cachedDefaultName,然后调用根据不同的策略读取配置文件,有三个策略调用loadDirectory()方法分别读取MTEA-INF/dubbo,META-INF/services,META-INF/dubbo/internal三个目录下的spi配置。

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;
    }
复制代码

cacheDefaultExtensionName()

这个方法主要是用来初始化cachedDefaultName的,读取@SPI注解中的value,这个value就是默认的扩展点实例的name。

    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];
            }
        }
    }
复制代码

strategies是哪些策略呢?我们可以看它的初始化

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

通过loadLoadingStrategies()方法进行初始化

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

我们可以看到这里是调用了java.util.ServiceLoader的load方法获取的,也就是通过了java的SPI获取到了加载配置文件的所有的策略类。

我们可以在META-INFO/services中找到名称为
org.apache.dubbo.common.extension.LoadingStrategy的文件,里面存着加载SPI的策略类,三个类的directory()方法分别返回三个不同的目录。

注:这里我们也就知道了为什么要把SPI的配置文件放在MTEA-INF/dubbo,META-INF/services,META-INF/dubbo/internal这三个目录下面。

org.apache.dubbo.common.extension.DubboInternalLoadingStrategy
org.apache.dubbo.common.extension.DubboLoadingStrategy
org.apache.dubbo.common.extension.ServicesLoadingStrategy
复制代码

获取到加载的策略之后我们就可以继续向下分析了,接下来就是loadDirectory()方法读取SPI配置文件。

loadDirectory()

这个方法看起来很长,其实主要就是获取三个目录下所有的配置文件然后调用loadResource()方法加载解析配置文件。

注:从这里我们也就知道为什么SPI的配置文件名称必须是接口的全类名

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);
        }
    }
复制代码

loadResource()

这个方法就是用来解析SPI文件的,解析完之后调用loadClass()方法对所有的实现类进行实例化。

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);
        }
    }
复制代码

loadClass()

作用是解析每一个扩展点实现类,初始化cachedAdaptiveClass(用于缓存加了@Adaptive注解的实现类,下面简称adaptive类),cachedWrapperClasses(扩展点下所有的包装类),cachedActivates(扩展点下所有的activates类),cachedNames(用于缓存扩展点实现类的name)等,并且将name和实现类的关系放到extensionClasses中,extensionClasses会在getExtensionClasses()方法中赋值给cachedClasses缓存起来。

注意:adaptive类(即加了@Adaptive注解的实现类)是不会保存在extensionClasses中的,所以通过getExtension(String name)这个api是获取不到adaptive类的。

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);
                }
            }
        }
    }
复制代码

到这里loadExtensionClasses()方法执行完成,初始化完SPI配置文件后回到getExtensionClasses()方法,将cachedClasses初始化并返回之后,回到了createExtension()方法中,就可以通过name获取对应的扩展点实现类的Class对象了。

接下来就可以继续分析createExtension()方法了

createExtension()

这个方法是用于创建对应的扩展点实现类的,getExtensionClasses()方法我们前面分析了,它进行了一系列的初始化操作。首先获取到实现类的Class对象,然后从缓存中获取实例,如果缓存中没有,那么就反射调用无参构造函数创建实例,然后将创建好的实例放入到缓存中(这有没有一点熟悉,跟Spring的IoC好像啊),然后调用injectExtension()方法对实现类中的SPI属性初始化(也就是DI,依赖注入),最后如果需要包装,那么就将扩展点的所有包装类循环,将实现类一层层的包装起来,最后返回实例。

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);
        }
    }
复制代码

injectExtension()

这个方法很重要,dubbo SPI的DI就是通过这个方法实现的。首先判断objectFactory这个成员变量是否为null,为null的话直接返回了。否则获取需要注入的类中所有的方法,然后过滤出set方法,再用objectFactory的getExtension()方法获取实例,最后反射调用set方法进行赋值。

injectExtension()

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;
    }
复制代码

可以看到整个DI的逻辑并不复杂,关键是objectFactory到底是什么,它在哪里初始化。objectFactory的getExtension()方法获取到的对象是哪来的?所以我们进一步分析objectFactory的初始化。

其实我们不难发现objectFactory正是在ExtensionLoader的构造函数中初始化。

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

不难看出ExtensionFactory本身也是一个扩展点,我们可以看到它有三个实现类

1.AdaptiveExtensionFactory

这个类加了@Adaptive注解的实现类,那么ExtensionLoader构造函数中赋值的正是这个类的实例。而AdaptiveExtensionFactory在构造函数的时候获取到ExtensionFactory扩展点的非adaptived的其他所有实现类保存到成员变量factories中,而它的getExtension()正是从循环其他工厂调用getExtension()方法获取实例。

    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);
    }
复制代码
    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;
    }
复制代码

2.SpiExtensionFactory

这个工厂获取实例是从dubbo中的SPI容器中获取实例

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;
    }
复制代码

3.SpringExtensionFactory

这个顾名思义正是从Spring容器中获取实例。

    @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;
    }
复制代码

那么到这里getExtension()方法的逻辑就全部分析完了,接下来分析getAdaptiveExtension()方法。

getAdaptiveExtension()

首先从缓存中获取adaptive的实例,如果实例为空,那么双重检查锁调用createAdaptiveExtension()方法创建实例,并且初始化cachedAdaptiveInstance缓存起来。

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;
    }
复制代码

createAdaptiveExtension()

这个方法作用是创建adaptive扩展点实现类,首先调用getAdaptiveExtensionClass()获取class对象,然后反射获取实例之后,调用injectExtension()方法完成DI.

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);
        }
    }
复制代码

**getAdaptiveExtensionClass() **

这个方法的作用是获取Adaptive扩展点实现类的Class对象。首先调用getExtensionClasses()方法,这个方法我们在前面分析过了,就是解析SPI配置,并且做一些初始化,其中就包括了cachedAdaptiveClass。如果初始化之后cachedAdaptiveClass还是为null,那么就会调用
createAdaptiveExtensionClass()创建Adaptive扩展点实现类的Class。

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

createAdaptiveExtensionClass()

走到这个方法说明该扩展点没有存在@Adaptive注解的实现类,dubbo就会帮助我们生成一个代理类来作为Adaptive类。根据扩展点的type和默认的扩展点实现类的name调用generate()方法获得相关的代码,然后通过编译器编译代码。

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);
    }
复制代码

generate()

这个方法的作用正是用来生成相关的代理类的代码的。

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();
}
复制代码

举个例子,看一下生成的代码长什么样

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);
}
}
复制代码

到这里getAdaptiveExtension()方法也就解析完了,最后分析一下getActivateExtensions()方法,

getActivateExtensions()

这个方法是用来获取扩展类中所有的加了@Activate注解的实现类实例。首先调用getExtensionClasses()方法解析SPI配置,初始化一些缓存变量。其中就包括cachedActivates。首先通过getExtensionClass()方法和getExtension()方法建立class与实例之间的关系,存入一个map中,最后发返回所有的Activate实例。

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;
}
复制代码

总结

本文以getExtension(),getAdaptiveExtension(),getActivateExtensions()三个常用的api为入口对dubbo SPI的核心类ExtensionLoader的核心代码进行了分析。虽然本篇文章的篇幅可能过长,但是也是为了讲的更细一点,如果大家有什么疑问或者建议,欢迎在下方评论区留言,另外,如果本文对你有所帮助,那么就点个赞再走吧。