聊一聊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加载之后在使用的时候判断起来也麻烦。

是吗？

串一串浪人

断舍离