一切福田，不離方寸，從心而覓，感無不通。

1b40f41b3cea64b8991f8aa0eaf5c1fec_noop

可插拔组件设计机制 —SPI

作者：京东物流 孔祥东

1.SPI 是什么？

SPI 的全称是 Service Provider Interface, 即提供服务接口；是一种服务发现机制，SPI 的本质是将接口实现类的全限定名配置在文件中，并由服务加载器读取配置文件，加载实现类。这样可以在运行时，动态为接口替换实现类。正因此特性，我们可以很容易的通过 SPI 机制为我们的程序提供拓展功能。

如下图：

1b40f41b3cea64b8991f8aa0eaf5c1fec_noop

系统设计的各个抽象，往往有很多不同的实现方案，在面对象设计里，一般推荐模块之间基于接口编程，模块之间不对实现硬编码，一旦代码涉及具体的实现类，就违反了可插拔的原则。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 的实现类必须携带一个不带参数的构造方法。

示例：

2057845e2e1d547399b6f407802709379_noop

spi-interface 模块定义

1
定义一组接口：public interface MyDriver

 

spi-jd-driver

spi-ali-driver

1
2
实现为：public class JdDriver implements MyDriver
  public class AliDriver implements MyDriver

 

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

内容是要应用的实现类分别 com.jd.JdDriver 和 com.ali.AliDriver

3270e140c587340bfb7edc16ef8a15136_noop

spi-core

一般都是平台提供的核心包，包含加载使用实现类的策略等等，我们这边就简单实现一下逻辑：a. 没有找到具体实现抛出异常 b. 如果发现多个实现，分别打印

1
2
3
4
5
6
7
8
9
10
11
12
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

1
2
3
4
5
6
7
8
public class App
{
    public static void main( String[] args )
    {
        DriverFactory factory = new DriverFactory();
        factory.invoker();
    }
}

 

1. 引入 spi-core 包，执行结果

475ae9cff743a4c4fbdb4fbce0724ee1f_noop

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

5dec115841fff4bd59176d7b73b16d720_noop

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

6ed2cf6c9a36e49108be368aa5a9315a9_noop

4. 原理解析

看看我们刚刚是怎么拿到具体的实现类的？

就两行代码：

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

 

所以，首先我们看 ServiceLoader 类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
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;
            }
        }
........

 

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

7ba3d845377c44b60b2401982de26b443_noop

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

8up-4e64d5e96655358f5f32b86a84e2ab5da9a
from:https://my.oschina.net/u/4090830/blog/8564660

Copyright © 2024 Longsheng All rights reserved