前言
这段时间在
研究一个开源框架，
发现其中有一些以SPI命名的包，经过搜索、整理以及思考之后，将学习的笔记、心得整理出来，供日后
复习使用。
SPI
SPI全称是
Service Provider Interface，翻译过来是服务提供者
接口，这个翻译其实不那么形象，
理解起来也不是很好理解，至少不那么见名知意。
其实SPI是一种机制，一种类似于服务发现的机制，什么叫做服务发现呢，就是能够根据情况发现已有服务的机制，好像说了跟没说一样，对吧，下面我们逐个来理解。
首先是服务，英文叫做Service，服务可以理解为就是某一种或者某几种功能，比如日常生活中的医生，提供看病的服务；家政公司，提供家政服务；房产中介公司，提供，这样子的话，关于服务，应该是理清楚了。
接下来是服务的发现，英文是Service Discovery，理解了服务，那么服务的发现就应该很好理解了，用大白话讲就是具有某种能力，可以发现某些服务，比如生活中的房产中介公司(服务发现)，
他们就能够发现很多的拥有空闲房子并且愿意出租的人(服务)。
SPI机制的作用就是服务发现，也就是说，我们有一些服务，然后通过SPI机制，就能让这些服务被需要的人所使用，而我们这些服务被发现的过程就是SPI的任务了。
说到这里，可能你还是不太理解SPI是什么，接下来我们通过具体的
例子分析来理解SPI。
在JDBC4.0之前，我们使用JDBC去连接数据库的时候，通常会经过如下的步骤
将对应数据库的驱动加到类路径中
通过Class.forName()注册所要使用的驱动，如Class.forName(com.mysql.jdbc.Driver)
使用驱动管理器DriverManager来获取连接
后面的内容我们不关心了。
这种方式有个缺点，加载驱动是由用户来操作的，这样就很容易出现加载错驱动或者更换驱动的时候，忘记更改加载的类了。
在JDBC4.0，现在我们使用的时候，上面的第二步就不需要了，并且能够
正常使用，这个就是SPI的功劳了。
接下来我们先来看下为什么不需要第二步。
熟悉反射的同学应该知道，第二步其实就是将对应的驱动类加载到虚拟机中，也就是说，现在我们没有手动加载，那么对应的驱动类是如何加载到虚拟机中的呢，我们通过DriverManger的源码的了解SPI是如何实现这个功能的。
DriverManager.java
在DriverManager中，有一段静态代码(静态代码在类被加载的时候就会执行)
static {
// 在这里加载对应的驱动类
loadInitialDrivers();
println("JDBC DriverManager initialized");
}
接下来我们来具体看下其内容
loadInitialDrivers()
private static void loadInitialDrivers() {
String drivers;
try {
// 先获取系统变量
drivers = AccessController.doPrivileged(new PrivilegedAction<String>() {
public String run() {
return System.getProperty("jdbc.drivers");
}
});
} catch (Exception ex) {
drivers = null;
}
// SPI机制加载驱动类
AccessController.doPrivileged(new PrivilegedAction<Void>() {
public Void run() {
// 通过ServiceLoader.load进行查找，我们的重点也是这里，后面分析
ServiceLoader<Driver> loadedDrivers = ServiceLoader.load(Driver.
class);
// 获取迭代器，也请注意这里
Iterator<Driver> driversIterator = loadedDrivers.iterator();
try{
// 遍历迭代器
// 这里需要这么做，是因为ServiceLoader默认是延迟加载
// 只是找到对应的class，但是不加载
// 所以这里在调用next的时候，其实就是实例化了对应的对象了
// 请注意这里 -------------------------------------------------------------------- 1
while(driversIterator.
hasNext()) {
// 真正实例化的逻辑，详见后面分析
driversIterator.next();
}
} catch(Throwable t) {
// Do nothing
}
return null;
}
});
println("DriverManager.initialize: jdbc.drivers = " + drivers);
if (drivers == null || drivers.equals("")) {
return;
}
// 同时加载系统变量中找到的驱动类
String[] driversList = drivers.split(":");
println("number of Drivers:" + driversList.length);
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);
}
}
}
从上面的代码中并没有找到对应的操作逻辑，唯一的一个突破点就是ServiceLoader.load(Driver.class)方法，该方法其实就是SPI的核心啦
接下来我们来分析这个类的代码(代码可能有点长哦，要有心理准备)
ServiceLoader.java
public final class ServiceLoader<S>
implements Iterable<S>
{
/**
* 由于是调用ServiceLoader.load(Driver.class)方法，所以我们先从该
方法分析
*/
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)
{
// 只是返回一哥ServiceLoader对象，调用自己的
构造函数嘛
return new ServiceLoader<>(service, loader);
}
/**
* 私有构造函数
*/
private ServiceLoader(Class<S> svc, ClassLoader cl) {
// 目标加载类不能为null
service = Objects.requireNonNull(svc, "Service interface
cannot be null");
// 获取类加载器，如果cl是null，则使用系统类加载器
loader = (cl == null) ? ClassLoader.getSystemClassLoader() : cl;
acc = (System.getSecurityManager() != null) ? AccessController.getContext() : null;
// 调用reload方法
reload();
}
// 用于缓存加载的服务提供者
private LinkedHashMap<String,S> providers = new LinkedHashMap<>();
// 真正查找逻辑的实现
private LazyIterator lookupIterator;
/**
* reload方法
*/
public void reload() {
// 先清空内容
providers.clear();
// 初始化lookupIterator
lookupIterator = new LazyIterator(service, loader);
}
}
LazyIterator.class
LazyIterator是ServiceLoader的私有内部类
private class LazyIterator
implements Iterator<S>
{
Class<S> service;
ClassLoader loader;
/**
* 私有构造函数，用于初始化参数
*/
private LazyIterator(Class<S> service, ClassLoader loader) {
this.service = service;
this.loader = loader;
}
}
到了上面的内容，其实ServiceLoader.load()方法就结束了，并没有实际上去查找具体的实现类，那么什么时候才去查找以及加载呢，还记得上面的Iterator<Driver> driversIterator = loadedDrivers.iterator();这一行代码吗，这一行代码用于获取一个迭代器，这里同样也没有进行加载，但是，其后面还有遍历迭代器的代码，上面标注为1的部分。
迭代器以及遍历迭代器的过程如下所示
ServiceLoader.java
public Iterator<S> iterator() {
return new Iterator<S>() {
// 注意这里的providers，这里就是上面提到的用于缓存
// 已经加载的服务提供者的容器。
Iterator<Map.Entry<String,S>> knownProviders
= providers.entrySet().iterator();
// 底层其实委托给了providers
public boolean hasNext() {
if (knownProviders.hasNext())
return true;
// 如果没有缓存，则查找及加载
return lookupIterator.hasNext();
}
// 同上
public S next() {
if (knownProviders.hasNext())
return knownProviders.next().getValue();
return lookupIterator.next();
}
public void remove() {
throw new Unsupported
OperationException();
}
};
}
上面已经分析过了，ServiceLoader.load()方法执行到LazyIterator的初始化之后就结束了，真正地查找直到调用lookupIterator.hasNext()才开始。
LazyIterator.java
// 希望你还记得他
private class LazyIterator
implements Iterator<S>
{
Class<S> service;
ClassLoader loader;
Enumeration<URL> configs = null;
Iterator<String> pending = null;
String nextName = null;
//检查 AccessControlContext，这个我们不关系
// 关键的核心是都调用了hasNextService()方法
public boolean hasNext() {
if (acc == null) {
return hasNextService();
} else {
PrivilegedAction<Boolean> action = new PrivilegedAction<Boolean>() {
public Boolean run() { return hasNextService(); }
};
return AccessController.doPrivileged(action, acc);
}
}
private boolean hasNextService() {
// 第一次加载
if (nextName != null) {
return true;
}
// 第一次加载
if (configs == null) {
try {
// 注意这里，获取了的完整名称
// PREFIX定义在ServiceLoader中
// private static final String PREFIX = "META-INF/services/"
// 这里可以看到，完整的类名称就是 META-INF/services/CLASS_FULL_NAME
// 比如这里的 Driver.class，完整的路径就是
// META-INF/services/java.sql.Driver，注意这个只是
文件名，不是具体的类哈
String fullName = PREFIX + service.getName();
// 如果类加载器为null，则使用系统类加载器进行加载
// 类加载会加载指定路径下的所有类
if (loader == null)
configs = ClassLoader.getSystemResources(fullName);
else // 使用传入的类加载器进行加载，其实就是应用类加载器
configs = loader.getResources(fullName);
} catch (IOException x) {
fail(service, "Error locating configuration
files", x);
}
}
// 如果pending为null或者没有内容，则进行加载，一次只加载一个文件的一行
while ((pending == null) || !pending.hasNext()) {
if (!configs.hasMoreElements()) {
return false;
}
//
解析读取到的每个文件，高潮来了
pending = parse(service, configs.nextElement());
}
nextName = pending.next();
return true;
}
/**
* 解析读取到的每个文件
*/
private Iterator<String> parse(Class<?> service, URL u)
throws ServiceConfigurationError
{
InputStream in = null;
BufferedReader r = null;
ArrayList<String> names = new ArrayList<>();
try {
in = u.openStream();
// utf-8
编码
r = new BufferedReader(new InputStreamReader(in, "utf-8"));
int lc = 1;
// 一行一行地读取数据
while ((lc = parseLine(service, u, r, lc, names)) >= 0);
} catch (IOException x) {
fail(service, "Error reading configuration file", x);
} finally {
try {
if (r != null) r.close();
if (in != null) in.close();
} catch (IOException y) {
fail(service, "Error closing configuration file", y);
}
}
// 返回迭代器
return names.iterator();
}
// 解析一行行的数据
private int parseLine(Class<?> service, URL u, BufferedReader r, int lc,
List<String> names)
throws IOException, ServiceConfigurationError
{
String ln = r.readLine();
if (ln == null) {
return -1;
}
// 查找是否存在#
// 如果存在，则剪取#前面的内容
// 目的是防止读取到#及后面的内容
int ci = ln.indexOf('#');
if (ci >= 0) ln = ln.substring(0, ci);
ln = ln.trim();
int n = ln.length();
if (n != 0) {
// 不能包含空格及制表符\t
if ((ln.indexOf(' ') >= 0) || (ln.indexOf('\t') >= 0))
fail(service, u, lc, "Illegal configuration-file syntax");
int cp = ln.codePointAt(0);
// 检查第一个字符是否是Java语法规范的
单词
if (!Character.isJavaIdentifierStart(cp))
fail(service, u, lc, "Illegal provider-class name: " + ln);
// 检查每个字符
for (int i = Character.charCount(cp); i < n; i += Character.charCount(cp)) {
cp = ln.codePointAt(i);
if (!Character.isJavaIdentifierPart(cp) && (cp != '.'))
fail(service, u, lc, "Illegal provider-class name: " + ln);
}
// 如果缓存中没有，并且当前列表中也没有，则加入列表。
if (!providers.containsKey(ln) && !names.contains(ln))
names.add(ln);
}
return lc + 1;
}
/**
* 上面解析完文件之后，就开始加载文件的内容了
*/
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
}
}
到此，解析的步骤就完成了，在一开始的DriverManager中，我们也看到了在DriveirManager中一直在调用next方法，也就是持续地加载找到的所有的Driver的实现类了，比如MySQL的驱动类，Oracle的驱动类啦。
这个例子有点长，但我们收获还是很多，我们知道了JDBC4不用手动加载驱动类的实现原理，其实就是通过ServiceLoader去查找当前类加载器能访问到的目录下的WEB-INF/services/FULL_CLASS_NAME文件中的所有内容，而这些内容由一定的规范，如下
每行只能写一个全类名
#作为
注释
只能使用utf-8及其兼容的编码
每个实现类必须提供一个无参构造函数，因为是直接使用class.newInstance()来创建实例的嘛
由此我们也明白了SPI机制的工作原理，那么这个东西有什么用呢，其实JDBC就是个最好的例子啦，这样用户就不需要知道到底是要加载哪个实现类，一方面是简化了操作，另一方面避免了操作的
错误，当然，这种一般是用于写框架之类的用途，用于向框架使用者提供更加便利的操作，比如上面的引导我看到SPI的例子，其实是来自一个RPC框架，通过SPI机制，让我们可以直接编写
自定义的序列化方式，然后由框架来负责加载即可。
SPI实战小案例
上面学习完了SPI的例子，也学习完了JDBC是如何实现的，接下来我们来通过一个小案例，来动手实践一下SPI是如何工作的。
新建一个接口，内容随便啦
HelloServie.java
public interface HelloService {
void sayHello();
}
然后编写其实现类
HelloServiceImpl.java
public class HelloServiceImpl implements HelloService {
@Override
public void sayHello() {
System.out.println("hello world");
}
}
关键点来了，既然是学习SPI，那么我们肯定不是手动new一个实现类啦，而是通过SPI的机制来加载，如果认真地看完上面的分析，那么下面的内容应该很容易看懂啦，如果没看懂，再回去看一下啦。
在实现类所在项目(这里是同个项目哈)的类路径下，如果是maven项目，则是在resources目录下
建立目录META-INF/services
建立文件cn.xuhuanfeng.spi.HelloService（接口的全限定名哈）
内容是实现类的类名:cn.xuhuanfeng.spi.impl.HelloServiceImpl(注意这里我们直接放在同个项目，不是同个项目也可以的！！！)
自定义一个加载的类，并且通过ServiceLoader.load()方法进行加载，如下所示
public class HelloServiceFactory {
public HelloService getHelloService() {
ServiceLoader<HelloService> load = ServiceLoader.load(HelloService.class);
return load.iterator().next();
}
}
测试一下，enjoy
如果你有兴趣的话，可以尝试将实现放在另一个项目中，然后打包成jar包，再放置在测试项目的classpath中，enjoy
总结
本小节我们主要学习了SPI，主要包括了SPI是什么，JDBC4中不需要手动加载驱动类的原理，并且详细看了DriverManager中的代码实现，最后，通过一个简单的小案例来实现我们自己的SPI服务，通过这个小节，应该说，SPI的大部分内容我们是掌握了，当然，里面管理类加载器部分我们还没有学习，这里先挖个坑，后面有时间再分析一下。
作者：颜洛滨
链接：https://www.jianshu.com/p/3039aa89b1b5
来源：简书
著作权归作者所有。
商业转载请联系作者获得
授权，非商业转载请注明出处。
相关文章
