最近学习了JDK SPI

JDK SPI是什么

最近工做中听几个同事说了好几回SPI这个名词，虽然和我不要紧，可是内心默默想仍是学习一下，否则下次和我说到SPI，连是什么都不知道那就尴尬了。

因此SPI是什么呢？SPI全称Service Provider Interface，在Java中仍是一个比较重要的概念，是Java提供的一套用来被第三方实现或者扩展的API，或者换句话说，SPI是一种服务发现机制。

 

JDK SPI使用说明及示例

要使用SPI比较简单，只须要按照如下几个步骤操做便可：

• 在jar包的META-INF/services目录下建立一个以"接口全限定名"为命名的文件，内容为实现类的全限定名
• 接口实现类所在的jar包在classpath下
• 主程序经过java.util.ServiceLoader动态状态实现模块，它经过扫描META-INF/services目录下的配置文件找到实现类的全限定名，把类加载到JVM
• SPI的实现类必须带一个无参构造方法

接着咱们看一下具体例子，首先定义一个SpiService，它是一个接口：

package org.xrq.test.spi;

public interface SpiService {

    public void hello();
    
}

两个实现类，分别为SpiServiceA与SpiServiceB：

package org.xrq.test.spi;

public class SpiServiceA implements SpiService {

    public void hello() {
        System.out.println("SpiServiceA.Hello");
    }
    
}

package org.xrq.test.spi;

public class SpiServiceB implements SpiService {

    @Override
    public void hello() {
        System.out.println("SpiServiceB.hello");
    }
    
}

接着咱们建一个META-INF/services的文件夹，里面建一个file，file的名字是接口的全限定名org.xrq.test.spi.SpiService：

文件的内容是SpiService实现类SpiServiceA、SpiServiceB的全限定名：

org.xrq.test.spi.SpiServiceA
org.xrq.test.spi.SpiServiceB

这样就大功告成了！而后咱们写个测试类自动加载一下这两个类：

public class SpiTest {

    @Test
    public void testSpi() {
        ServiceLoader<SpiService> serviceLoader = ServiceLoader.load(SpiService.class);
        
        Iterator<SpiService> iterator = serviceLoader.iterator();
        while (iterator.hasNext()) {
            SpiService spiService = iterator.next();
            
            spiService.hello();
        }
    }
    
}

结果一目了然，调用了hello()方法：

SpiServiceA.Hello
SpiServiceB.hello

这就是SPI的使用示例，接着咱们看一下SPI在实际场景中的应用。

 

SPI在JDBC中的应用

回看快四年前的文章http://www.javashuo.com/article/p-bxqcguso-dg.html，这篇名为《JDBC学习2：为何要写Class.forName("XXX")？》的文章里面当时技术真的是稚嫩，为何不写Class.forName("XXX")的解释如今看来真的是弱爆了，最后一楼网友的回复"不用写的缘由是，新版本JDBC使用了SPI"，因此学了一下SPI立刻就想起这个例子来了，所以就由JDBC讲讲SPI的实际应用。

在老版本的JDBC中，假设咱们使用的是MySql，初始化JDBC的时候是须要显式调用Class.forName("com.mysql.jdbc.Driver")这一句的，可是在某个版本以后就不须要作这一步操做了，如上所说这是经过SPI实现的，怎么理解呢。Class.forName其实没有实际意义，其实既不会new对象也不会反射生成对象，它只是为了调用com.mysql.jdbc.Driver的static方法块而已：

public class Driver extends NonRegisteringDriver implements java.sql.Driver {
    //
    // Register ourselves with the DriverManager
    //
    static {
        try {
            java.sql.DriverManager.registerDriver(new Driver());
        } catch (SQLException E) {
            throw new RuntimeException("Can't register driver!");
        }
    }

    /**
     * Construct a new driver and register it with DriverManager
     * 
     * @throws SQLException
     *             if a database error occurs.
     */
    public Driver() throws SQLException {
        // Required for Class.forName().newInstance()
    }
}

方法块的做用只有一个，经过jdk自带的DriverManager注册Driver，registerDrivers方法没什么套路，把Driver放到CopyOnArrayList里面而已：

public static synchronized void registerDriver(java.sql.Driver driver, DriverAction da)
      throws SQLException {

    /* Register the driver if it has not already been added to our list */
    if(driver != null) {
        registeredDrivers.addIfAbsent(new DriverInfo(driver, da));
    } else {
        // This is for compatibility with the original DriverManager
        throw new NullPointerException();
    }

    println("registerDriver: " + driver);

}

从某个JDK版本，具体也不知道哪一个版本，废弃了这个操做，看下新版的DriverManager，个人是JDK1.8的：

/**
 * 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");
}

直接看一下loadInitialDrivers这个方法的核心部分：

AccessController.doPrivileged(new PrivilegedAction<Void>() {
    public Void run() {

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

        /* 
         * 节约篇幅，注释省略
         */
        try{
            while(driversIterator.hasNext()) {
               driversIterator.next();
            }
        } catch(Throwable t) {
        // Do nothing
        }
        return null;
    }
});

看到使用SPI的方式从META-INF/services下去找java.sql.Driver这个文件，并找到里面的Driver实现类逐一注入。最后咱们看一下Iterator的next()方法作了什么就彻底懂了，经过next()方法调用了：

private S nextService() {
    if (!hasNextService())
        throw new NoSuchElementException();
    String cn = nextName;
    nextName = null;
    Class<?> c = null;
    try {
        c = Class.forName(cn, false, loader);
    } catch (ClassNotFoundException x) {
        fail(service,
             "Provider " + cn + " not found");
   }
    if (!service.isAssignableFrom(c)) {
       fail(service,
             "Provider " + cn  + " not a subtype");
    }
    try {
        S p = service.cast(c.newInstance());
        providers.put(cn, p);
        return p;
    } catch (Throwable x) {
        fail(service,
             "Provider " + cn + " could not be instantiated",
            x);
    }
    throw new Error();          // This cannot happen
}
            

看到Class.forName了吧，虽然都是Class.forName，可是经过SPI的方式把用户手动作的动做变成框架作。

 

对SPI的理解

最后谈一谈我对SPI的理解，学习了怎么用SPI、SPI在实际应用中的示例以后，深入理解SPI机制才能在之后工做中真正将SPI为我所用。

首先你们能够注意到，标题是JDK SPI，也就是说SPI并非JDK专属的。是的，我理解的SPI实际上是一种可插拔技术的总称，最简单的例子就是USB，厂商提供了USB的标准，厂家根据USB的标准制造本身的外设，例如鼠标、键盘、游戏手柄等等，可是USB标准具体在电脑中是怎么用的，厂家就不须要管了。

回到咱们的代码中也是同样的道理。当咱们开发一个框架的时候，除了保证基本的功能外，最重要的一个点是什么？我认为最重要的应该是松耦合，即对扩展开放、对修改关闭，保证框架实现对于使用者来讲是黑盒。

框架不可能作好全部的事情，只能把共性的部分抽离出来进行流程化，松耦合实现的核心就是定义好足够松散的接口，或者能够理解是扩展点，具体的扩展点让使用者去实现，这样不一样的扩展就不须要修改源代码或者对框架进行定制，这就是面向接口编程的好处。

回到咱们框架的部分来讲：

• JDK对于SPI的实现是经过META-INF/services这个目录 + ServiceLoader
• Spring实现SPI的方式是留了N多的接口，例如BeanPostProcessor、InitializingBean、DisposableBean，咱们只须要实现这些接口而后注入便可

对已有框架而言，咱们能够经过框架给咱们提供的扩展点扩展框架功能。对本身写框架而言，记得SPI这个事情，留好足够的扩展点，这将大大增强你写的框架的扩展性。