Dubbo SPI机制学习总结(持续更新...)

参考文章：Dubbo的SPI机制分析

首先来看看 Java SPI 的机制

Java SPI 起初是提供给厂商做插件开发用的，例如数据库驱动java.sql.Driver，市面上各种各样的数据库，不同的数据库底层协议都不一样，为了方便开发者调用数据库而不用关心它们之间的差异，因此必须提供一个统一的接口来规范和约束这些数据库。有了统一的接口，数据库厂商就可以按照规范去开发自己的数据库驱动了。

厂商开发好数据库驱动了，应用如何使用呢？该使用哪个驱动呢？以 MySQL 为例，早期手写 JDBC 时，开发者需要手动注册驱动，现在已经不需要了，就是利用了 SPI 机制。

Java SPI 使用了策略模式，一个接口多种实现，开发者面向接口编程，具体的实现并不在程序中直接硬编码，而是通过外部文件进行配置。

Java SPI 约定了一个规范，使用步骤如下：

• 编写一个接口。
• 编写具体实现类。
• 在 ClassPath 下的META-INF/services，目录创建以接口全限定名命名的文件，文件内容为实现类的全限定名，多个实现用换行符分割。
• 通过 ServiceLoader 类获取具体实现。

接口：

实现类：

public class Driver extends NonRegisteringDriver implements java.sql.Driver {
    public Driver() throws SQLException {
    }

    static {
        try {
            DriverManager.registerDriver(new Driver());
        } catch (SQLException var1) {
            throw new RuntimeException("Can't register driver!");
        }
    }
}

简单实例

package org.sun.spi.services;

/**
 * 这是java 的 spi, 没有@SPI注解, 类似 mySQL
 */
public interface Say {
    void say();
}

实现类1

package org.sun.spi.impl;

import org.sun.spi.services.Say;

public class SayImpl implements Say {
    @Override
    public void say() {
        System.out.println("nihao .....");
    }
}

实现类2

package org.sun.spi.impl;

import org.sun.spi.services.Say;

public class SayWrapper implements Say {
    @Override
    public void say() {
        System.out.println("hello SayWrapper。。。。");
    }
}

META-INF/services 文件

测试：

public class Main {

    public static void main(String[] args) {
        ServiceLoader<Say> serviceLoader = ServiceLoader.load(Say.class);
        serviceLoader.forEach(say -> say.say());
        }

结果：

nihao .....
hello SayWrapper。。。。

Dubbo SPI机制

Dubbo SPI 定义了一套自己的规范，同时对 Java SPI 存在的问题进行了改进，优点如下：

• 扩展类按需加载，节约资源。
• SPI 文件采用 Key=Value 形式，可以根据扩展名灵活获取实现类。
• 扩展类对象做了缓存，避免重复创建。
• 扩展类加载失败有详细日志，方便排查。 支持 AOP 和 IOC。

Dubbo SPI 使用规范：

• 编写接口，接口必须加@SPI 注解，代表它是一个可扩展的接口。
• 编写实现类。
• 在 ClassPath 下的META-INF/dubbo，目录创建以接口全限定名命名的文件，文件内容为 Key=Value 格式，Key 是扩展点的名称，Value 是扩展点实现类的全限定名。
• 通过 ExtensionLoader 类获取扩展点实现。

Dubbo 默认会扫描META-INF/services
、META-INF/dubbo
、META-INF/dubbo/internal
三个目录下的配置，第一个是为了兼容 Java SPI，第三个是 Dubbo 内部使用的扩展点。

测试用例

// TODO

源码分析：

ExtensionLoader.getExtensionLoader

getExtension()

public T getExtension(String name, boolean wrap) {
        checkDestroyed();
        if (StringUtils.isEmpty(name)) {
            throw new IllegalArgumentException("Extension name == null");
        }
        // 如果 name 为true，则返回一个默认的扩展点
        if ("true".equals(name)) {
            return getDefaultExtension();
        }
        String cacheKey = name;
        if (!wrap) {
            cacheKey += "_origin";
        }
        // 创建或者返回一个holder对象， 用于缓存扩展类的实例
        final Holder<Object> holder = getOrCreateHolder(cacheKey);
        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;

PS : 有意思的类，学习

/**
 * 持有一个泛型
 * Helper Class for hold a value.
 */
public class Holder<T> {

    // 保证线程可见性
    private volatile T value;

    public void set(T value) {
        this.value = value;
    }

    public T get() {
        return value;
    }

}

上述代码就是先查缓存，如果未命中，则创建一个扩展对象，createExtension() 应该就是去指定的路径下查找name 对应的扩展点实现，并且实例化之后返回。

@SuppressWarnings("unchecked")
    private T createExtension(String name, boolean wrap) {
        // 根据 name 返回扩展类
        Class<?> clazz = getExtensionClasses().get(name);
        if (clazz == null || unacceptableExceptions.contains(name)) {
            throw findException(name);
        }
        try {
            // 从缓存中查找该类是否已经初始化
            // ConcurrentMap<Class<?>, Object> extensionInstances = new ConcurrentHashMap<>(64);
            T instance = (T) extensionInstances.get(clazz);
            if (instance == null) {
                // 如果没有，则重新创建一个实例并加入缓存， 反射机制
                extensionInstances.putIfAbsent(clazz, createExtensionInstance(clazz));
                instance = (T) extensionInstances.get(clazz);
                // 初始化前的相关操作
                instance = postProcessBeforeInitialization(instance, name);
                // 依赖注入
                injectExtension(instance);
                instance = postProcessAfterInitialization(instance, name);
            }

            if (wrap) {
                // 通过 Wrapper 进行包装
                List<Class<?>> wrapperClassesList = new ArrayList<>();
                if (cachedWrapperClasses != null) {
                    wrapperClassesList.addAll(cachedWrapperClasses);
                    wrapperClassesList.sort(WrapperComparator.COMPARATOR);
                    Collections.reverse(wrapperClassesList);
                }

                if (CollectionUtils.isNotEmpty(wrapperClassesList)) {
                    for (Class<?> wrapperClass : wrapperClassesList) {
                        Wrapper wrapper = wrapperClass.getAnnotation(Wrapper.class);
                        boolean match = (wrapper == null) ||
                            ((ArrayUtils.isEmpty(wrapper.matches()) || ArrayUtils.contains(wrapper.matches(), name)) &&
                                !ArrayUtils.contains(wrapper.mismatches(), name));
                        if (match) {
                            instance = injectExtension((T) wrapperClass.getConstructor(type).newInstance(instance));
                            instance = postProcessAfterInitialization(instance, name);
                        }
                    }
                }
            }

            // Warning: After an instance of Lifecycle is wrapped by cachedWrapperClasses, it may not still be Lifecycle instance, this application may not invoke the lifecycle.initialize hook.
            initExtension(instance);
            return instance;
        } catch (Throwable t) {
            throw new IllegalStateException("Extension instance (name: " + name + ", class: " +
                type + ") couldn't be instantiated: " + t.getMessage(), t);
        }
    }

继续跟踪getExtensionClasses

• 从缓存中获取已经被加载的扩展类
• 如果未命中缓存， 则调用loadExtensionClasses 加载扩展类

 private Map<String, Class<?>> getExtensionClasses() {
        // Holder<Map<String, Class<?>>> cachedClasses = new Holder<>();
        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()

/**
     * synchronized in getExtensionClasses
     */
    private Map<String, Class<?>> loadExtensionClasses() {
        checkDestroyed();
        // 获得当前type扩展接口的默认扩展对象， 并且缓存
        cacheDefaultExtensionName();

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

        for (LoadingStrategy strategy : strategies) {
        // 加载指定文件目录下的配置文件
            loadDirectory(extensionClasses, strategy, type.getName());

            // compatible with old ExtensionFactory
            if (this.type == ExtensionInjector.class) {
                loadDirectory(extensionClasses, strategy, ExtensionFactory.class.getName());
            }
        }

        return extensionClasses;
    }

(精彩后续，请看下回分解)