前面已经讲过SPI的基本实现原理了，demo也基本实现了，再来说说SPI。
背景：SPI是什么？SPI，即是Service Provider Interface，是一种服务提供（接口实现）发现机制，可以通过ClassPath路径下的META-INF/Service文件查找文件，加载里面定义的类。
一般可以用来启用框架拓展和替换组件，比如在最常见的数据库连接JDBC中，java.sql.Driver,不同的数据库产商可以对接口做不一样的实现，但是JDK怎么知道别人有哪些实现呢？这就需要SPI,可以查找到接口的实现，对其进行操作。
用两个字解释：解耦。
再简单点说？
就是Java核心包不知道第三方的包会怎么实现一个接口，定义了一个规则：你要对这个类拓展，那你就把你的实现类配置到一个文件里面，文件名就是你要拓展的接口，这样子，我只要用ServiceLoader加载接口，我就可以获取到实现类的实例。
对于java核心包来说，我不知道你要怎么实现接口，但是只要你按我说的做，配置好，我就能保证你只要引入你自己的包，我就可以运行到你的代码。
核心代码如下：
ServiceLoader<DBConnectionService> serviceLoader= ServiceLoader.load(DBConnectionService.class);
所以我们此时假设自己对ServiceLoader已经十分好奇了,这是什么？这是怎么实现的？这么牛逼？
那就看源码？夜深人静刚刚好，白天也看不下去。
这里需要注意的是，这个ServiceLoader是一个泛型类，实现了Iterable，说明了什么？说明它的功能有一部分和集合是差不多的，可以将多个服务的实现类加载在里面！！！可以通过遍历的方式，一一取出来
先看看ServiceLoader的类成员接口，不急着看load()函数：
public final class ServiceLoader<S>
implements Iterable<S>{
// 读取配置文件的路径
private static final String PREFIX = "META-INF/services/";
// 加载的服务类或者接口的实现类
private final Class<S> service;
// 类加载器
private final ClassLoader loader;
// 访问控制器
private final AccessControlContext acc;
// 已加载的服务类集合
private LinkedHashMap<String,S> providers = new LinkedHashMap<>();
// 内部类，真正加载服务类的迭代器
private LazyIterator lookupIterator;
...}
现在来看load()函数,其实里面调用的也还是serviceLoader本身的构造器，两个load方法
- 一个只需要传入需要实现的服务接口
service - 另一个则是需要同时传入类加载器
loader
// 当前线程的类加载器作为默认加载器
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)
{
return new ServiceLoader<>(service, loader);
}
我们还是来看serviceLoader的构造器：
private ServiceLoader(Class<S> svc, ClassLoader cl) {
// 要加载的接口
service = Objects.requireNonNull(svc, "Service interface cannot be null");
// 加载器，如果为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);
}
查找加载类的迭代器，到底是什么？从名字来看，是一个懒加载器，就是延迟加载，从名字来看，大概能猜到，这个就是使用的时候才加载，真的是这样么？？？接着看下去：
上面 ???? 我们说到ServiceLoader其实是一个泛型类，实现了Iterator接口，说明它可以被遍历，遍历的元素是什么呢？就是上面所说的成员变量LinkedHashMap，实现的服务都加载在里面了。
那我们就看看遍历的时候怎么取的？
这就涉及到了Iterable接口的方法foreach()了，我们就来看看。
总所周知，Iterable接口的方法如下：
Iterator<T> iterator();
default void forEach(Consumer<? super T> action) {
Objects.requireNonNull(action);
for (T t : this) {
action.accept(t);
}
}
default Spliterator<T> spliterator() {
return Spliterators.spliteratorUnknownSize(iterator(), 0);
}
那我猜遍历的方法应该被ServiceLoader实现的时候，已经重写了,果不其然：
看获取Iterator的方法实现，我们可以发现一个惊天㊙️密：也就是其实我们遍历的时候，优先是使用已知的集合迭代器，这个集合，就是存储我们的服务提供者的集合，也就是已经加载的服务类集合。如果这个集合已经遍历完成的时候，就会调用查找迭代器去查找，不管next()还是hasNext()方法，都是这样的。
同时已经加载的服务，是不可以被移除的，为了防止这一点，在移除的时候会返回异常。
public Iterator<S> iterator() {
return new Iterator<S>() {
// 被查找到的已知的服务提供者的迭代器
Iterator<Map.Entry<String,S>> knownProviders = providers.entrySet().iterator();
// 如果已知的迭代器，也就是存储服务提供者的集合迭代器，如果这个有下一个元素，那么就会直接返回true，如果没有那么就会调用查找迭代器的hasNext()
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 UnsupportedOperationException();
}
};
}
那Iterator的其他方法呢？
当然是用了默认实现了，其他两个方法都加了default关键字，ServiceLoader没有去实现它，可以不实现，用默认实现就可以。
所以我们的重点是什么？当然是这个lookupIterator，它可是一个延迟加载器，为什么这么说，我觉得应该和上面的分析有关，先遍历已经加载的，然后没有了，才会使用这个延迟查找迭代器，从它的名字就可以很清楚的看出来，这其实就是一个查找的迭代器，别人都是迭代遍历已经存在的元素，它倒好，懒到一定程度了，用来查找。
废话少说，直接看看它怎么实现的，这么???? 牛！
在回头看看前面初始化的时候，构造是这样子的：
// 初始化查找加载类的迭代器 lookupIterator = new LazyIterator(service, loader);
可以看到其实是将需要加载的服务接口以及类加载器传递进来了。
代码精简，看????下面的代码加注解，应该很清晰了。
private class LazyIterator
implements Iterator<S>
{
// 需要加载的服务
Class<S> service;
// 类加载器
ClassLoader loader;
// 实现类的url（多个）
Enumeration<URL> configs = null;
// 实现类的全名（多个）
Iterator<String> pending = null;
// 迭代器中下一个实现类的全名
String nextName = null;
// 构造器其实没有什么操作，单纯保存
private LazyIterator(Class<S> service, ClassLoader loader) {
this.service = service;
this.loader = loader;
}
// 获取下一个
public S next() {
// 如果控制访问器是空的
if (acc == null) {
// 调用获取下一个元素
return nextService();
} else {
// 特权动作，重写的其实也是调用nextService()
PrivilegedAction<S> action = new PrivilegedAction<S>() {
public S run() { return nextService(); }
};
// 通过控制访问器的特权访问，跳过检查
return AccessController.doPrivileged(action, acc);
}
}
// 是否有下一个元素
public boolean hasNext() {
if (acc == null) {
// 如果访问控制器是null，那么久直接调用hasNextService方法
return hasNextService();
} else {
// 生成特权动作
PrivilegedAction<Boolean> action = new PrivilegedAction<Boolean>() {
public Boolean run() { return hasNextService(); }
};
// 使用访问控制器执行特权动作
return AccessController.doPrivileged(action, acc);
}
}
// 不可以移除
public void remove() {
throw new UnsupportedOperationException();
}
// 是否有下一个元素
private boolean hasNextService() {
// 如果下一个元素的全类名名字不为null，那么肯定是有下一个元素
if (nextName != null) {
return true;
}
// 如果这个实现类的url是空的，怎么办？加载进去
if (configs == null) {
try {
// 获取全名
String fullName = PREFIX + service.getName();
// 如果类加载器是null
if (loader == null)
// 通过全名，拿到全名的url，这个url其实就是根据名字找到的配置文件的路径
configs = ClassLoader.getSystemResources(fullName);
else
// 否则调用loader自身的方法获取
configs = loader.getResources(fullName);
} catch (IOException x) {
fail(service, "Error locating configuration files", x);
}
}
// 如果实现类的全限定类名是空的，那就肯定需要从文件里面读出来呀，因为文件名是接口，里面配置的是接口的实现类，pending保存的就是实现类
while ((pending == null) || !pending.hasNext()) {
// 如果需要读取的配置没有要读的了
if (!configs.hasMoreElements()) {
// 直接返回false
return false;
}
// 否则需要解析配置文件里面的内容
pending = parse(service, configs.nextElement());
}
// 下一个service的名字就更新为读取到的接口实现类，如果文件里面什么都没有配置，那就很有可能是空的。
nextName = pending.next();
return true;
}
// 获取下一个接口实现类，也就是服务
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");
}
// 判断服务c是不是实现来自于service,两者是不是继承关系
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
}
}
通过上面的代码，其实我们可以清楚的看到，这个延迟加载器，会去读取配置类，以及实现的的接口，将实现类全类名放到configs，然后通过反射的形式构建实例对象，实例化之后才放到providers中，然后返回实现类对象。
值得注意的是，如果访问控制器是空的，那么就会调用特权执行：AccessController.doPrivileged(action, acc);,获取到服务实现的时候，也会判断是不是实现来自于我们需要实现的接口，否则会报错，调用的是service.isAssignableFrom(c)。
上面还有一段解析配置的代码没有说明，补上：
private Iterator<String> parse(Class<?> service, URL u)
throws ServiceConfigurationError {
// 输入流
InputStream in = null;
// buffer读入
BufferedReader r = null;
ArrayList<String> names = new ArrayList<>();
try {
in = u.openStream();
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) {
if ((ln.indexOf(' ') >= 0) || (ln.indexOf('\t') >= 0))
fail(service, u, lc, "Illegal configuration-file syntax");
int cp = ln.codePointAt(0);
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;
}
到这里，serviceLoader的内容就解读完毕了，思想挺好的，有两个迭代器，一个是提供服务的集合本身的迭代器，迭代完成之后，才会去使用延迟调用lookup迭代器，触发寻找操作，如果查找了，那么就加载到集合中，下次就不用再找了。
查找的时候，直接根据该路径下的文件，文件名就是接口，接口里面每一行都是接口的实现类。
实例化接口实现类的时候，其实是使用了反射，然后判断类型之后，类型转换成为⤴️上转型，放到已经发现的服务集合中，返回。
