聊一聊SPI

前言

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

使用方式

• 场景

  如果在使用过程中需要动态替换接口类的实现逻辑，那么比较适合使用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的，所以也不能从这个类进行扩展。

    public final class ServiceLoader<S> implements Iterable<S>
    {
    	private static final String PREFIX = "META-INF/services/";
    }
    

  • 为什么需要一个无参的public构造器？

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

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

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

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

    

案例

1. 服务方

   • 接口

     package cc.kevinlu.spidemo.spi;
     
     public interface SPIUserService {
     
         void name();
     
     }
     

   • 实现类

     // 领导实现类
     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

     cc.kevinlu.spidemoimpl.spi.LeaderServiceImpl
     cc.kevinlu.spidemoimpl.spi.EmployeeServiceImpl
     

   • 项目结构

     

2. 调用方

   • pom.xml引入依赖

     <dependency>
       <groupId>cc.kevinlu</groupId>
       <artifactId>spi-demo-impl</artifactId>
       <version>0.0.1-SNAPSHOT</version>
     </dependency>
     

   • 调用

     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类中的静态代码块实现的对目标类的加载

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

是吗？