作者:京东物流 孔祥东

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 完美支撑,有语法提示

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