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中，供之后使用。
小结
- 通过SPI来进行加载第三方组件，可以实现动态插拔，不需要开发者手动进行加载了。
- 利用SPI技术可以扩展定义好的接口，便于实现定义好的规范。实现动态扩展。
