Java SPI 机制解析

本文以JDBC为例深入讲解 java spi 机制，将帮助你理解：什么是SPI，SPI实现原理，SPI的使用和SPI的优劣。

什么是SPI

SPI，Service Provider Interface，主要用于框架设计。比如java.sql.Driver接口，不同厂商可以针对同一接口做出不同的实现，mysql和oracle都有不同的实现提供给用户，而Java的SPI机制可以为某个接口寻找服务实现。

当服务的提供者提供了一种接口的实现之后，需要在classpath下的META-INF/services/目录里创建一个以服务接口命名的文件，这个文件里的内容就是这个接口的具体的实现类。当其他的程序需要这个服务的时候，就可以通过查找这个jar包(一般都是以jar包做依赖)的META-INF/services/中的配置文件，配置文件中有接口的具体实现类名，可以根据这个类名进行加载实例化，就可以使用该服务了。例如mysql的jar包：

SPI实现原理

下面以JDBC为例深入讲解spi的实现原理：
在JDBC4.0之前，我们开发有连接数据库的时候，通常会用Class.forName("com.mysql.jdbc.Driver")这句先加载数据库相关的驱动，然后再进行获取连接等的操作。而JDBC4.0之后不需要用Class.forName("com.mysql.jdbc.Driver")来加载驱动，直接获取连接就可以了，现在这种方式就是使用了Java的SPI扩展机制来实现。

//1、加载驱动
            //Class.forName("com.mysql.jdbc.Driver");
            //2、建立连接
            Connection connection = DriverManager.getConnection("url", "user", "passport");
            //3、写prepareStatement
            PreparedStatement preparedStatement = connection.prepareStatement("SELECT * from table where 1=1 limit 1 ");
            //4、执行sql
            ResultSet resultSet = preparedStatement.executeQuery();

1、进入到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() {
//使用SPI的ServiceLoader来加载接口的实现
  ServiceLoader<Driver> loadedDrivers = ServiceLoader.load(Driver.class);
//获取迭代器
  Iterator driversIterator = loadedDrivers.iterator();
//遍历所有的驱动实现
   try{
                    while(driversIterator.hasNext()) {
                        driversIterator.next();
                    }
                } catch(Throwable t) {
                // Do nothing
                }

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

  for (String aDriver : driversList) {
            try {
                println("DriverManager.Initialize: loading " + aDriver);
                Class.forName(aDriver, true,
                        ClassLoader.getSystemClassLoader());
            } catch (Exception ex) {
                println("DriverManager.Initialize: load failed: " + ex);
            }
        }

}

2、进入到ServiceLoader，ServiceLoader是查找服务的实现工具
ServiceLoaderd定义了查找实现类的目录位置，和实现了Iterator的内部类LazyIterator。LazyIterator重写了hasNext和next方法，将类的加载延迟到了DriverManager调用的时候(也就是所谓的Lazy)。

DriverManager在遍历的时候，首先调用driversIterator.hasNext()方法，这里会搜索classpath下以及jar包中所有的META-INF/services目录下的java.sql.Driver文件，并找到文件中的实现类的名字，此时并没有实例化具体的实现类。然后是调用driversIterator.next();方法，此时就会根据驱动名字具体实例化各个实现类了。现在驱动就被找到并实例化了。

//查找配置文件的目录
    private static final String PREFIX = "META-INF/services/";

    // The class or interface representing the service being loaded
    //表示要被加载的服务的类或接口
    private Class<S> service;

    // The class loader used to locate, load, and instantiate providers
    private ClassLoader loader;

    // Cached providers, in instantiation order
   // 缓存已经被实例化的服务提供者，按照实例化的顺序存储
    private LinkedHashMap<String,S> providers = new LinkedHashMap<>();

    // The current lazy-lookup iterator
    private LazyIterator lookupIterator;

   //为指定的服务使用指定的类加载器来创建一个ServiceLoader，去加载实现了java.sql.Driver接口的类
    public static <S> ServiceLoader<S> load(Class<S> service) {
        ClassLoader cl = Thread.currentThread().getContextClassLoader();
        return ServiceLoader.load(service, cl);
    }

    private ServiceLoader(Class<S> svc, ClassLoader cl) {
        service = svc;
        loader = cl;
        reload();
    }

 //重新加载，就相当于重新创建ServiceLoader了，用于新的服务提供者安装到正在运行的Java虚拟机中的情况
    public void reload() {
 //清空缓存中所有已实例化的服务提供者
        providers.clear();
//新建一个迭代器，该迭代器会从头查找和实例化服务提供者
        lookupIterator = new LazyIterator(service, loader);
    }

ServiceLoader不是实例化以后，就去读取配置文件中的具体实现，并进行实例化。而是等到使用迭代器去遍历的时候，才会加载对应的配置文件去解析，调用hasNext方法的时候会去加载配置文件进行解析，调用next方法的时候进行实例化并缓存。所有的配置文件只会加载一次，服务提供者也只会被实例化一次，重新加载配置文件可使用reload方法。

SPI的使用

SPI的使用可以仿照DriverManager的方式。如下：

ServiceLoader<Driver> loadedDrivers = ServiceLoader.load(xxx.class);
//获取迭代器
Iterator<Driver> driversIterator = loadedDrivers.iterator();
//遍历
while(driversIterator.hasNext()) {
    driversIterator.next();
    //可以做具体的业务逻辑
}

SPI的缺点

通过上面的分析可以发现，SPI需要把所有的实现都实例化了，即便我们不需要，也都给实例化了。引用dubbo文档的说法是：

• JDK 标准的 SPI 会一次性实例化扩展点所有实现，如果有扩展实现初始化很耗时，但如果没用上也加载，会很浪费资源。
• 如果扩展点加载失败，连扩展点的名称都拿不到了。比如：JDK 标准的 ScriptEngine，通过 getName() 获取脚本类型的名称，但如果 RubyScriptEngine 因为所依赖的 jruby.jar 不存在，导致 RubyScriptEngine 类加载失败，这个失败原因被吃掉了，和 ruby 对应不起来，当用户执行 ruby 脚本时，会报不支持 ruby，而不是真正失败的原因。