Service Provider Interface

SPI类加载

SPI是Java提供的一种加载外部类或者是第三放插件的方式，通过这种方式可以进行加载第三方扩展包，一般平时开发中可能用的很少，但是当进行开发某个框架或者中间件的时候，就会大量用到SPI技术，例如Spring中也应用到了SPI，还有Sharding jdbc, JDBC驱动连接等等。下面将以JDBC驱动连接来进行简单的介绍以及学习。

代码实例

下面将来演示一个简单的例子，来进行分析。这个例子主要是利用JDBC来连接MySQL服务来进行简单的查询操作。

String url = "jdbc:mysql://localhost:3306/test";
// 获取数据库连接
Connection connection = DriverManager.getConnection(url, "root", "chusen");
String sql = "select * from pm_product";
PreparedStatement preparedStatement = connection.prepareStatement(sql);
ResultSet resultSet = preparedStatement.executeQuery();
ResultSetMetaData metaData = resultSet.getMetaData();
while (resultSet.next()) {
    long id = resultSet.getLong(1);
    String prodName = resultSet.getString(2);
    System.out.println("id: " + id + ",prodName:" + prodName);
}

上面代码与之前代码最大的区别是少了一行代码，Class.forName(“com.mysql.jdbc.Driver”); 之前加入这行代码的作用是加载类com.mysql.jdbc.Driver。

static {
    try {
        java.sql.DriverManager.registerDriver(new Driver());
    } catch (SQLException E) {
        throw new RuntimeException("Can't register driver!");
    }
}

伴随着类的加载，会触发Driver中这段代码的执行，从而将Driver加到DriverManager中。从而后续就可以使用MySQL提供的一系列操作数据库的实现。来进行对数据库的操作。那么如今省略掉了，那这个Driver是如何加入到DriverManger中的呢？要回到DriverManager中来继续寻找答案了。

首先上述代码，DriverManager.getConnection会触发DriverManager的类加载，从而导致其内部静态代码块的执行。然后去看一下DriverManager的静态代码块做了哪些操作。

static {
        loadInitialDrivers();
        println("JDBC DriverManager initialized");
}

可以发现其内部有一个很重要的方法loadInitalDrivers()。看其名字就知道进行加载初始化Drivers。点进去继续看。由于这里loadInitalDrivers中方法有些冗长，这里只截取关键部分。

String drivers;
try {
    drivers = AccessController.doPrivileged(new PrivilegedAction<String>() {
        public String run() {
            // 从系统属性中拿Driver.
            return System.getProperty("jdbc.drivers");
        }
    });
} catch (Exception ex) {
    drivers = null;
}

AccessController.doPrivileged(new PrivilegedAction<Void>() {
    public Void run() {
        // 通过SPI的方式，来进行加载Driver
        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;
}

可以看到这里主要有两个途径来进行获取Driver。首先通过在系统属性中来获取Driver。如果获取不到，再通过SPI类加载的方式来进行加载第三方实现。

然后点进去ServiceLoader的load方法来进行查看其内部具体做了那些事。

public static <S> ServiceLoader<S> load(Class<S> service) {
    // 切换当前类加载器
    ClassLoader cl = Thread.currentThread().getContextClassLoader();
    return ServiceLoader.load(service, cl);
}
// 继续点
public static <S> ServiceLoader<S> load(Class<S> service,
                                            ClassLoader loader)
{       // 这里new了一个ServiceLoader的实例
        return new ServiceLoader<>(service, loader);
}
// 然后继续点 来到其构造方法内部
private ServiceLoader(Class<S> svc, ClassLoader cl) {
    service = Objects.requireNonNull(svc, "Service interface cannot be null");
    loader = (cl == null) ? ClassLoader.getSystemClassLoader() : cl;
    acc = (System.getSecurityManager() != null) ? AccessController.getContext() : null;
    // 点进去这个方法
    reload();
}
// 接着向下点
public void reload() {
    providers.clear();
    // 点到进去
    lookupIterator = new LazyIterator(service, loader);
}
private LazyIterator(Class<S> service, ClassLoader loader) {
    this.service = service;
    this.loader = loader;
}

通过上述代码实例可以看到最终new了一个LazyInterator。将需要通过SPI加载的接口赋给了service，将当前线程类加载器赋给了loader。

然后继续回到DriverManager中来进行分析Iterator<Driver> driversIterator = loadedDrivers.iterator(); 这行代码做了哪些事，点进去看一下。

public Iterator<S> iterator() {
    return new Iterator<S>() {

        Iterator<Map.Entry<String,S>> knownProviders
            = providers.entrySet().iterator();

        public boolean hasNext() {
            if (knownProviders.hasNext())
                return true;
            // 这里的lookupInterator就是上一步的LazyIterator。
            return lookupIterator.hasNext();
        }

        public S next() {
            if (knownProviders.hasNext())
                return knownProviders.next().getValue();
            return lookupIterator.next();
        }

        public void remove() {
            throw new UnsupportedOperationException();
        }

    };
}

可以看到其方法内部new了一个Iterator。在其hasNext()方法中调用了LazyIterator的hasNext方法。回到DriverManager中来看这个while循环。

// 最终会调用LazyInterator的hasNext()方法。
while(driversIterator.hasNext()) {
    driversIterator.next();
}

所以直接点进去看一下。最终会调用到LazyInterator的这段代码。

private boolean hasNextService() {
    if (nextName != null) {
        return true;
    }
    if (configs == null) {
        try {
            String fullName = PREFIX + service.getName();
            if (loader == null)
                configs = ClassLoader.getSystemResources(fullName);
            else
                configs = loader.getResources(fullName);
        } catch (IOException x) {
            fail(service, "Error locating configuration files", x);
        }
    }
    while ((pending == null) || !pending.hasNext()) {
        if (!configs.hasMoreElements()) {
            return false;
        }
        pending = parse(service, configs.nextElement());
    }
    nextName = pending.next();
    return true;
}

通过这里可以大概明白了,PREFIX是类中定义的一个常量。

private static final String PREFIX = "META-INF/services/";

可以看到其最终会在当前环境中找META-INF/services/java.sql.Driver文件。然后进行一行行的解析其内容。于是可以去mysql的jar包中看一下是否有这个文件，看其内部内容是什么。

可以看到其内部正是我们需要加载的Driver。我这里的数据库连接版本比较新，所以不是com.mysql.jdbc.Driver了。

然后再回到DriverManager中，继续分析。

while(driversIterator.hasNext()) {
    // 上一步找到了，会返回true,继续这个方法
    driversIterator.next();
}

[图片上传失败...(image-20718a-1582472774739)]

通过最后逐层调用，会来到上述地方，进行调用你Class.forName进行加载，找到的类，到这里就彻底明白了，原来，我们不用Class.forName。JDK内部已经通过SPI的方式来帮我们做好了。走到这里算是彻底结束了。之后会调用静态代码块，将Driver放到DriverManager中，供之后使用。

小结

1. 通过SPI来进行加载第三方组件，可以实现动态插拔，不需要开发者手动进行加载了。
2. 利用SPI技术可以扩展定义好的接口，便于实现定义好的规范。实现动态扩展。