聊一聊SPI

前言

SPI全称是Service Provider Interface,是一种服务发现机制(哎,服务发现机制?和Zookeeper什么关系?)。SPI 的本质是将接口实现类的全限定名配置在文件META-INFO/services目录下以接口全限定名命名的文件中,并由服务加载器(ServiceLoader)读取配置文件,加载实现类。这样可以在运行时,动态为接口替换实现类。正因此特性,我们可以很容易的通过 SPI 机制为我们的程序提供拓展功能。

image-20200405012001538

使用方式

  • 场景

    如果在使用过程中需要动态替换接口类的实现逻辑,那么比较适合使用SPI。比如java.sql.Driver

  • 方式

    1. 在服务提供者提供了接口的一种具体实现后,在jar包的META-INF/services目录下创建一个以接口全限定名为命名的文件,内容为实现类的全限定名
    2. 通过maven引入接口实现类所在的jar包,或者将jar包放到应用的classpath中
    3. 通过java.util.ServiceLoder动态装载接口实现模块,它通过扫描META-INF/services目录下的配置文件找到实现类的全限定名,把类加载到JVM
    4. SPI的实现类必须有一个无参的public构造器
  • 疑问

    • 为什么要把定义放在META-INF/services目录下?

      这个目录位置是在ServiceLoader中定义的,并且还是final不能修改的,所以还是乖乖遵守吧,因为ServiceLoader也是final的,所以也不能从这个类进行扩展。

      1
      2
      3
      4
      public final class ServiceLoader<S> implements Iterable<S>
      {
      private static final String PREFIX = "META-INF/services/";
      }
    • 为什么需要一个无参的public构造器?

      ServiceLoader内部实例化扫描到的类是通过LazyIterator迭代器在迭代的时候使用Class的newInstance()方法,所以这里必须要有一个无参的public构造器,否则实例化的时候会报错。

    • 如果引入的多个jar包中均有目标接口的实现类及SPI定义,咋整?

      全部都会被加载,只要是在项目中被引入了,就会全部被加载。

    • 运行过程是什么样子的?

      spi

案例

  1. 服务方

    • 接口

      1
      2
      3
      4
      5
      6
      7
      package cc.kevinlu.spidemo.spi;

      public interface SPIUserService {

      void name();

      }
    • 实现类

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      // 领导实现类
      public class LeaderServiceImpl implements SPIUserService {
      @Override
      public void name() {
      System.out.println("领导发话了");
      }
      }

      // 员工实现类
      public class EmployeeServiceImpl implements SPIUserService {
      @Override
      public void name() {
      System.out.println("员工暴怒了");
      }
      }
    • spi文件

      在实现类所在的项目中的resources目录下创建文件夹META-INF/services文件夹,然后创建文件cc.kevinlu.spidemo.spi.SPIUserService

      1
      2
      cc.kevinlu.spidemoimpl.spi.LeaderServiceImpl
      cc.kevinlu.spidemoimpl.spi.EmployeeServiceImpl
    • 项目结构

      image-20200405175109421
  2. 调用方

    • pom.xml引入依赖

      1
      2
      3
      4
      5
      <dependency>
      <groupId>cc.kevinlu</groupId>
      <artifactId>spi-demo-impl</artifactId>
      <version>0.0.1-SNAPSHOT</version>
      </dependency>
    • 调用

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      ServiceLoader<SPIUserService> services = ServiceLoader.load(SPIUserService.class);
      // 隐式迭代器方式
      for (SPIUserService service : services) {
      service.name();
      }
      System.out.println("---------------");
      // 显式迭代器方式
      Iterator<SPIUserService> iterator = services.iterator();
      while (iterator.hasNext()) {
      SPIUserService service = iterator.next();
      service.name();
      }

MySQL

在mysql-connector-java包中的META-INFO/services目录下可以找到以接口java.sql.Driver为名的文件,文件内容是com.mysql.jdbc.Driver或者com.mysql.cj.jdbc.Driver。再来我们就需要找到是在哪里对这个类进行加载的,我们从com.mysql.jdbc.Driver可以进入到java.sql.DriverManager,哦哟~原来是在DriverManager类中的静态代码块实现的对目标类的加载

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
/**
* Load the initial JDBC drivers by checking the System property
* jdbc.properties and then use the {@code ServiceLoader} mechanism
*/
static {
loadInitialDrivers();
println("JDBC DriverManager initialized");
}

private static void loadInitialDrivers() {
String drivers;

// If the driver is packaged as a Service Provider, load it.
// Get all the drivers through the classloader
// exposed as a java.sql.Driver.class service.
// ServiceLoader.load() replaces the sun.misc.Providers()
AccessController.doPrivileged(new PrivilegedAction<Void>() {
public Void run() {

ServiceLoader<Driver> loadedDrivers = ServiceLoader.load(Driver.class);
Iterator<Driver> driversIterator = loadedDrivers.iterator();

/* Load these drivers, so that they can be instantiated.
* It may be the case that the driver class may not be there
* i.e. there may be a packaged driver with the service class
* as implementation of java.sql.Driver but the actual class
* may be missing. In that case a java.util.ServiceConfigurationError
* will be thrown at runtime by the VM trying to locate
* and load the service.
*
* Adding a try catch block to catch those runtime errors
* if driver not available in classpath but it's
* packaged as service and that service is there in classpath.
*/
try{
while(driversIterator.hasNext()) {
driversIterator.next();
}
} catch(Throwable t) {
// Do nothing
}
return null;
}
});

println("DriverManager.initialize: jdbc.drivers = " + drivers);

}

前几天面试的时候,有个同学问我:我们订单类型分很多种,有美食、外卖、酒店、门票、火车票、机票等等,我们这边是做一个中台(中间平台),为客户端提供统一下单、出单、订单等服务,但是订单需要流转到相对应的业务部门,怎么做?

我说SDK、微服务等形式,比如下单的时候由中台判断订单要流转的业务线,然后依据策略调用不同业务线提供的API服务。

然后又问我每个业务线提供的接口定义不同,调用起来会很麻烦,怎么办?

我说这个很简单啊,由中台定义接口,业务方引入中台的接口依赖,然后实现中台提供的接口,去编写自己的业务逻辑,并把该api暴露给中台去调用,这样中台对外的接口定义都一致,其实就是对外统一接口请求规范。

接着这位同学问了句:你知道SPI么?

艾玛~SPI会把业务方的实现代码依赖进来,如果某个业务方的处理逻辑改变了,或者他们的包版本变更了,岂不是所有的依赖方都要去更新依赖?这种方式其实不是不可取,只是会麻烦一些,并且我们把所有的业务方的实现都依赖进来了,那么我们使用ServiceLoader加载之后在使用的时候判断起来也麻烦。

是吗?