yangyanping20108

Dubbo-SPI扩展点加载机制

SPI

SPI 全称为 Service Provider Interface，是一种服务发现机制。当程序运行调用接口时，会根据配置文件或默认规则信息加载对应的实现类。所以在程序中并没有直接指定使用接口的哪个实现，而是在外部进行装配。
要想了解 Dubbo 的设计与实现，其中 Dubbo SPI 加载机制是必须了解的，在 Dubbo 中有大量功能的实现都是基于 Dubbo SPI 实现解耦，同时也使得 Dubbo 获得如此好的可扩展性。

Java SPI

通过完成一个 Java SPI 的操作来了解它的机制。

创建一个 PersonService 接口及 hello 方法
创建一个实现类 ChinesePerson
创建 META-INF/services 目录，并在该目录下创建一个文件，文件名为 PersonService 的全限定名作为文件名
在文件中添加实现类ChinesePerson的全限定名

单元测试

在pom文件中引入junit

PersonService接口定义

public interface PersonService {
    void hello();
}

ChinesePerson实现类定义

public class ChinesePerson implements PersonService {
    @Override
    public void hello() {
        System.out.println("我是中国人");
    }
}

加载 SPI 的实现测试类

public class JavaSPITest {
    @Test
    public static void main(String[] args) {
        ServiceLoader serviceLoader = ServiceLoader.load(PersonService.class);

        // 遍历在配置文件中已配置的 AnimalService 的所有实现类
        for (PersonService person : serviceLoader) {
            person.hello();
        }
    }
}

执行结果：

我是中国人

Process finished with exit code 0

Dubbo SPI

Dubbo SPI 相较于 Java SPI 更为强大，并且都是由自己实现的一套 SPI 机制。其中主要的改进和优化：

相对于 Java SPI 一次性加载所有实现，Dubbo SPI 是按需加载，只加载需要使用的实现类。同时带有缓存支持。
更为详细的扩展加载失败信息。
增加了对扩展 IOC 和 AOP的支持。

Dubbo SPI 示例

Dubbo SPI 的配置文件放在 META-INF/dubbo 下面，并且实现类的配置方式采用 K-V 的方式，key 为实例化对象传入的参数，value 为扩展点实现类全限定名。例如 ChinesePerson 的配置文件内容：

需要在接口上增加 @SPI 注解，@SPI 中可以指定 key 值

PersonService接口定义如下

@SPI("chinesePerson")
public interface PersonService {
    void hello();
}

实现类ChinesePerson定义

public class ChinesePerson implements PersonService {
    @Override
    public void hello() {
        System.out.println("我是中国人");
    }
}

DubboSPITest 单元测试类定义

public class DubboSPITest {
    @Test
    public void spi() {
        ExtensionLoader extensionLoader = ExtensionLoader.getExtensionLoader(PersonService.class);
        // 获取扩展类实现
        PersonService personService = extensionLoader.getExtension("chinesePerson");
        personService.hello();
    }
}

执行结果如下：

我是中国人

Process finished with exit code 0

SPI 源码分析

获取 ExtensionLoader 实例

ExtensionLoader 类在dubbo的dubbo-common模块中定义，获取 ExtensionLoader 实例是通过上面 getExtensionLoader 方法，具体实现代码：

@SuppressWarnings("unchecked")
    public static  ExtensionLoader getExtensionLoader(Class type) {
        if (type == null) {
            throw new IllegalArgumentException("Extension type == null");
        }

        // 检查type 必须为接口类型
        if (!type.isInterface()) {
            throw new IllegalArgumentException("Extension type (" + type + ") is not an interface!");
        }
        // 检查type 类型上是否有注解 SPI
        if (!withExtensionAnnotation(type)) {
            throw new IllegalArgumentException("Extension type (" + type +
                    ") is not an extension, because it is NOT annotated with @" + SPI.class.getSimpleName() + "!");
        }

        // 从ConcurrentHashMap 中获取实例
        ExtensionLoader loader = (ExtensionLoader) EXTENSION_LOADERS.get(type);

        if (loader == null) {
            // 创建ExtensionLoader实例，并放入缓存
            EXTENSION_LOADERS.putIfAbsent(type, new ExtensionLoader(type));
            loader = (ExtensionLoader) EXTENSION_LOADERS.get(type);
        }
        return loader;
    }

上面获取扩展类加载器过程主要是检查传入的 type 是否合法，以及从扩展类加载器缓存中是否存在当前类型的接口，如果不存在则添加当前接口至缓存中。
ConcurrentMap, ExtensionLoader> EXTENSION_LOADERS 是扩展类加载器的缓存，它是以接口作为 key，扩展类加载器作为 value 进行缓存。

获取扩展类对象

获取扩展类对象的方法ExtensionLoader#getExtension，在这里完成扩展对象的缓存及创建工作：

public T getExtension(String name, boolean wrap) {
        if (StringUtils.isEmpty(name)) {
            throw new IllegalArgumentException("Extension name == null");
        }

        //如果传入的参数为 true ，则获取默认扩展类对象操作
        if ("true".equals(name)) {
            return getDefaultExtension();
        }

        //获取扩展对象，Holder 里的 value 属性保存着扩展对象实例
        final Holder