作者：京东物流 孔祥东

1.SPI 是什么？

SPI 的全称是Service Provider Interface,即供给服务接口；是一种服务发现机制，SPI 的实质是将接口完成类的全限定名配置在文件中，并由服务加载器读取配置文件，加载完成类。这样能够在运行时，动态为接口替换完成类。正因而特性，咱们能够很简单的经过 SPI 机制为咱们的程序供给拓展功能。

如下图：

可插拔组件设计机制—SPI

系统规划的各个笼统，往往有很多不同的完成计划，在面目标规划里，一般推荐模块之间基于接口编程，模块之间不对完成硬编码，一旦代码触及详细的完成类，就违反了可插拔的准则。Java SPI 便是供给这样的一个机制，为某一个接口寻觅服务的完成，有点相似IOC 的思想，把安装的操控权移到程序之外，在模块化触及里面这个各尤为重要。与其说SPI 是java 供给的一种服务发现机制，倒不如说是一种解耦思想。

2.运用场景？

  • 数据库驱动加载接口完成类的加载；如：JDBC 加载Mysql,Oracle…
  • 日志门面接口完成类加载,如：SLF4J 对log4j、logback 的支撑
  • Spring中很多运用了SPI，特别是spring-boot 中自动化配置的完成
  • Dubbo 也是很多运用SPI 的方法完成结构的扩展，它是对原生的SPI 做了封装，答应用户扩展完成Filter 接口。

3.运用介绍

要运用 Java SPI，需求遵从以下约好：

  • 当服务供给者供给了接口的一种详细完成后，需求在JAR 包的META-INF/services 目录下创立一个以“接口全限制定名”为命名的文件，内容为完成类的全限定名；
  • 接口完成类所在的JAR放在主程序的classpath 下，也便是引进依赖。
  • 主程序经过java.util.ServiceLoder 动态加载完成模块，它会经过扫描META-INF/services 目录下的文件找到完成类的全限定名，把类加载值JVM,并实例化它；
  • SPI 的完成类必须带着一个不带参数的结构办法。

示例：

可插拔组件设计机制—SPI

spi-interface 模块界说

界说一组接口：public interface MyDriver

spi-jd-driver

spi-ali-driver

完成为：public class JdDriver implements MyDriver
  public class AliDriver implements MyDriver

在 src/main/resources/ 下树立 /META-INF/services 目录， 新增一个以接口命名的文件 (org.MyDriver 文件)

内容是要应用的完成类别离 com.jd.JdDriver和com.ali.AliDriver

可插拔组件设计机制—SPI

spi-core

一般都是渠道供给的核心包，包括加载运用完成类的战略等等，咱们这边就简单完成一下逻辑：a.没有找到详细完成抛出反常 b.假如发现多个完成，别离打印

public void invoker(){
    ServiceLoader<MyDriver>  serviceLoader = ServiceLoader.load(MyDriver.class);
    Iterator<MyDriver> drivers = serviceLoader.iterator();
    boolean isNotFound = true;
    while (drivers.hasNext()){
        isNotFound = false;
        drivers.next().load();
    }
    if(isNotFound){
        throw new RuntimeException("一个驱动完成类都不存在");
    }
}

spi-test

public class App
{
    public static void main( String[] args )
    {
        DriverFactory factory = new DriverFactory();
        factory.invoker();
    }
}

1.引进spi-core 包，履行成果

可插拔组件设计机制—SPI

2.引进spi-core,spi-jd-driver 包

可插拔组件设计机制—SPI

3.引进spi-core,spi-jd-driver,spi-ali-driver

可插拔组件设计机制—SPI

4.原理解析

看看咱们刚刚是怎么拿到详细的完成类的？

就两行代码：

ServiceLoader<MyDriver>  serviceLoader = ServiceLoader.load(MyDriver.class);
Iterator<MyDriver> drivers = serviceLoader.iterator();

所以，首要咱们看ServiceLoader 类：

public final class ServiceLoader<S> implements Iterable<S>{
//配置文件的路径
 private static final String PREFIX = "META-INF/services/";
    // 代表被加载的类或者接口
    private final Class<S> service;
    // 用于定位，加载和实例化providers的类加载器
    private final ClassLoader loader;
    // 创立ServiceLoader时采用的访问操控上下文
    private final AccessControlContext acc;
    // 缓存providers，按实例化的次序排列
    private LinkedHashMap<String,S> providers = new LinkedHashMap<>();
    // 懒查找迭代器，真正加载服务的类
    private LazyIterator lookupIterator;
 //服务供给者查找的迭代器
    private class LazyIterator
        implements Iterator<S>
    {
 .....
private boolean hasNextService() {
            if (nextName != null) {
                return true;
            }
            if (configs == null) {
                try {
//全限定名：com.xxxx.xxx
                    String fullName = PREFIX + service.getName();
                    if (loader == null)
                        configs = ClassLoader.getSystemResources(fullName);
                    else
                        configs = loader.getResources(fullName);
                }
            }
            while ((pending == null) || !pending.hasNext()) {
                if (!configs.hasMoreElements()) {
                    return false;
                }
                pending = parse(service, configs.nextElement());
            }
            nextName = pending.next();
            return true;
        }
        private S nextService() {
            if (!hasNextService())
                throw new NoSuchElementException();
            String cn = nextName;
            nextName = null;
            Class<?> c = null;
            try {
//经过反射获取
                c = Class.forName(cn, false, loader);
            }
            if (!service.isAssignableFrom(c)) {
                fail(service, "Provider " + cn  + " not a subtype");
            }
            try {
                S p = service.cast(c.newInstance());
                providers.put(cn, p);
                return p;
            }
        }
........

大概的流程便是下面这张图：

可插拔组件设计机制—SPI

  • 应用程序调用ServiceLoader.load 办法
  • 应用程序经过迭代器获取目标实例，会先判别providers目标中是否已经有缓存的示例目标，假如存在直接回来
  • 假如没有存在，履行类转载读取META-INF/services 下的配置文件，获取一切能被实例化的类的称号，能够跨越JAR 获取配置文件经过反射办法Class.forName()加载目标并用Instance() 办法示例化类将实例化类缓存至providers目标中，同步回来。

5.总结

长处：解耦

SPI 的运用，使得第三方服务模块的安装操控逻辑与调用者的事务代码分离，不会耦合在一起，应用程序能够依据实践事务情况来启用结构扩展和替换结构组件。

SPI 的运用，使得无须经过下面几种方法获取完成类

  • 代码硬编码import 导入
  • 指定类全限定名反射获取，例如JDBC4.0 之前；Class.forName(“com.mysql.jdbc.Driver”)

缺点：

虽然ServiceLoader也算是运用的推迟加载，但是根本只能经过遍历悉数获取，也便是接口的完成类悉数加载并实例化一遍。假如你并不想用某些完成类，它也被加载并实例化了，这就造成了浪费。获取某个完成类的方法不行灵敏，只能经过Iterator方法获取，不能依据某个参数来获取对应的完成类。

6.比照

JDK SPI DUBBO SPI Spring SPI
文件方法 每个扩展点独自一个文件 每个扩展点独自一个文件 一切的扩展点在一个文件
获取某个固定的完成 不支撑，只能按次序获取一切完成 有“别名”的概念，能够经过称号获取扩展点的某个固定完成，合作Dubbo SPI的注解很方便 不支撑，只能按次序获取一切完成。但由于Spring Boot ClassLoader会优先加载用户代码中的文件，所以能够确保用户自界说的spring.factoires文件在第一个，经过获取第一个factory的方法就能够固定获取自界说的扩展
其他 无 支撑Dubbo内部的依赖注入，经过目录来区分Dubbo 内置SPI和外部SPI，优先加载内部，确保内部的优先级最高 无
文档完好度 文章 & 三方材料满足丰厚 文档 & 三方材料满足丰厚 文档不行丰厚，但由于功能少，运用十分简单
IDE支撑 无 无 IDEA 完美支撑，有语法提示

本文正在参与「金石计划」