JDBC【4】-- SPI底层原理解析
前面已经讲过SPI的基本实现原理了，demo也基本实现了，再来讲说SPI。java
http://aphysia.cn/archives/jd...sql
背景：SPI是什么？SPI，便是Service Provider Interface，是一种服务提供（接口实现）发现机制，能够经过ClassPath路径下的META-INF/Service文件查找文件，加载里面定义的类。
通常能够用来启用框架拓展和替换组件，好比在最多见的数据库链接JDBC中，java.sql.Driver,不一样的数据库产商能够对接口作不同的实现，可是JDK怎么知作别人有哪些实现呢？这就须要SPI,能够查找到接口的实现，对其进行操做。
用两个字解释：解耦。数据库
再简单点说？
就是Java核心包不知道第三方的包会怎么实现一个接口，定义了一个规则：你要对这个类拓展，那你就把你的实现类配置到一个文件里面，文件名就是你要拓展的接口，这样子，我只要用ServiceLoader加载接口，我就能够获取到实现类的实例。app
对于java核心包来讲，我不知道你要怎么实现接口，可是只要你按我说的作，配置好，我就能保证你只要引入你本身的包，我就能够运行到你的代码。
框架
核心代码以下：ide
ServiceLoader<DBConnectionService> serviceLoader= ServiceLoader.load(DBConnectionService.class);
因此咱们此时假设本身对ServiceLoader已经十分好奇了,这是什么？这是怎么实现的？这么牛逼？函数
那就看源码？夜深人静刚恰好，白天也看不下去。学习
这里须要注意的是，这个ServiceLoader是一个泛型类，实现了Iterable，说明了什么？说明它的功能有一部分和集合是差很少的，能够将多个服务的实现类加载在里面！！！能够经过遍历的方式，一一取出来ui
先看看ServiceLoader的类成员接口，不急着看load()函数：this
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<String,S> providers，实现的服务都加载在里面了。
那咱们就看看遍历的时候怎么取的？
这就涉及到了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迭代器，触发寻找操做，若是查找了，那么就加载到集合中，下次就不用再找了。
查找的时候，直接根据该路径下的文件，文件名就是接口，接口里面每一行都是接口的实现类。
实例化接口实现类的时候，实际上是使用了反射，而后判断类型以后，类型转换成为⤴️上转型，放到已经发现的服务集合中，返回。
【做者简介】：
秦怀，公众号【秦怀杂货店】做者，技术之路不在一时，山高水长，纵使缓慢，驰而不息。这个世界但愿一切都很快，更快，可是我但愿本身能走好每一步，写好每一篇文章，期待和大家一块儿交流。
此文章仅表明本身（本菜鸟）学习积累记录，或者学习笔记，若有侵权，请联系做者核实删除。人无完人，文章也同样，文笔稚嫩，在下不才，勿喷，若是有错误之处，还望指出，感激涕零~
- 1. spring底层原理解析
- 2. BufferedInputStream 底层原理解析
- 3. AOP底层原理解析
- 4. volatile 底层原理解析
- 5. synchronized底层原理解析
- 6. JDBC 及链接池底层原理
- 7. 浅析SpringIOC底层原理
- 8. Lucence底层原理浅析
- 9. AQS底层原理分析
- 10. volatile底层原理分析
- 更多相关文章...
- • XML DOM 解析器 - XML DOM 教程
- • MyBatis的工作原理 - MyBatis教程
- • ☆技术问答集锦（13）Java Instrument原理
- • Java Agent入门实战（三）-JVM Attach原理与使用
-
每一个你不满意的现在，都有一个你没有努力的曾经。
- 1. spring底层原理解析
- 2. BufferedInputStream 底层原理解析
- 3. AOP底层原理解析
- 4. volatile 底层原理解析
- 5. synchronized底层原理解析
- 6. JDBC 及链接池底层原理
- 7. 浅析SpringIOC底层原理
- 8. Lucence底层原理浅析
- 9. AQS底层原理分析
- 10. volatile底层原理分析