可插拔组件设计机制—SPI

水深无声 2023-10-04 23:43 37阅读 0赞

## 1.SPI 是什么？ ##

SPI 的全称是Service Provider Interface,即提供服务接口；是一种服务发现机制，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 的实现类必须携带一个不带参数的构造方法。

示例：

![format_png][]

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

![format_png 1][]

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 包，执行结果

![format_png 2][]

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

![format_png 3][]

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

![format_png 4][]

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

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

![format_png 5][]

*  应用程序调用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.对比 ##

<table> 
 <thead> 
  <tr> 
   <th></th> 
   <th>JDK SPI</th> 
   <th>DUBBO SPI</th> 
   <th>Spring SPI</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>文件方式</td> 
   <td>每个扩展点单独一个文件</td> 
   <td>每个扩展点单独一个文件</td> 
   <td>所有的扩展点在一个文件</td> 
  </tr> 
  <tr> 
   <td>获取某个固定的实现</td> 
   <td>不支持，只能按顺序获取所有实现</td> 
   <td>有“别名”的概念，可以通过名称获取扩展点的某个固定实现，配合Dubbo SPI的注解很方便</td> 
   <td>不支持，只能按顺序获取所有实现。但由于Spring Boot ClassLoader会优先加载用户代码中的文件，所以可以保证用户自定义的spring.factoires文件在第一个，通过获取第一个factory的方式就可以固定获取自定义的扩展</td> 
  </tr> 
  <tr> 
   <td>其他</td> 
   <td>无</td> 
   <td>支持Dubbo内部的依赖注入，通过目录来区分Dubbo 内置SPI和外部SPI，优先加载内部，保证内部的优先级最高</td> 
   <td>无</td> 
  </tr> 
  <tr> 
   <td>文档完整度</td> 
   <td>文章 &amp; 三方资料足够丰富</td> 
   <td>文档 &amp; 三方资料足够丰富</td> 
   <td>文档不够丰富，但由于功能少，使用非常简单</td> 
  </tr> 
  <tr> 
   <td>IDE支持</td> 
   <td>无</td> 
   <td>无</td> 
   <td>IDEA 完美支持，有语法提示</td> 
  </tr> 
 </tbody> 
</table>

[format_png]: https://img-blog.csdnimg.cn/img_convert/afe2d51572c2d6d8b65b8ccc89b26582.webp?x-oss-process=image/format,png
[format_png 1]: https://img-blog.csdnimg.cn/img_convert/80a46fee74afdccf7475b4a8fec7e7ad.webp?x-oss-process=image/format,png
[format_png 2]: https://img-blog.csdnimg.cn/img_convert/8ce42a8c747023aa88c3a8a289381f96.webp?x-oss-process=image/format,png
[format_png 3]: https://img-blog.csdnimg.cn/img_convert/7ccd6d8ba0d64ab5799611dc7c59500a.webp?x-oss-process=image/format,png
[format_png 4]: https://img-blog.csdnimg.cn/img_convert/e702412d8722d0cf47e1576f3516e8b0.webp?x-oss-process=image/format,png
[format_png 5]: https://img-blog.csdnimg.cn/img_convert/a39e81f21af99098ea4e07fbe081fe41.webp?x-oss-process=image/format,png