一、SPI 简介：
SPI 全称为 (Service Provider Interface) ,是JDK（1.5开始）内置的一种服务提供发现机制。
二、SPI场景和产生原因：
我们系统里抽象的各个模块，往往有很多不同的实现方案，比如日志模块的方案，xml解析模块、jdbc模块的方案等。面向的对象的设计里，我们一般推荐模块之间基于接口编程，模块之间不对实现类进行硬编码。一旦代码里涉及具体的实现类，就违反了可拔插的原则，如果需要替换一种实现，就需要修改代码。
为了实现在模块装配的时候能不在程序里动态指明，这就需要一种服务发现机制。java spi就是提供这样的一个机制：为某个接口寻找服务实现的机制。有点类似IOC的思想，就是将装配的控制权移到程序之外，在模块化设计中这个机制尤其重要。
三、使用spi需要遵循的规范：
四、具体使用
第一步：提供一个接口和它的若干个实现：
有一个接口
package com.xihe.api;
public interface XiheInterface {
public void sayHi();
}
该接口有两个实现
package com.xihe.api;
public class XiheBJ implements XiheInterface {
public void sayHi() {
System.out.println("xihe in beijing ");
}
}
public class XiheZZ implements XiheInterface {
public void sayHi() {
System.out.println("xihe in zhengzhou");
}
}
第二步： 在src下创建META-INF/services/目录中创建一个名为com.xihe.api.XiheInterface 的文件,文件的内容是实现类的全名。
如果该Service有多个服务实现，则每一行写一个服务实现，如：
com.xihe.api.XiheZZ
com.xihe.api.XiheBJ
第三步：加载
public class Demo { public static void main(String[] args) { ServiceLoaderserviceLoader = ServiceLoader.load(XiheInterface.class); Iterator it = serviceLoader.iterator();
while (it!=null && it.hasNext()) {
XiheInterface demoService = it.next();
System.out.println("class:"+demoService.getClass().getName());
demoService.sayHi();
}
}
}
运行结果：
class:com.xihe.api.XiheZZ
xihe in zhengzhou
class:com.xihe.api.XiheBJ
xihe in beijing
五、源码分析
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.security.AccessControlContext;
import java.security.AccessController;
import java.security.PrivilegedAction;
import java.util.*;
//ServiceLoader实现了Iterable接口，可以遍历所有的服务实现者
public final class ServiceLoader
implements Iterable
{
//查找配置文件的目录
private static final StringPREFIX ="META-INF/services/";
//表示要被加载的服务的类或接口
private final Classservice;
//这个ClassLoader用来定位，加载，实例化服务提供者
private final ClassLoaderloader;
// 访问控制上下文
private final AccessControlContextacc;
// 缓存已经被实例化的服务提供者，按照实例化的顺序存储
private LinkedHashMapproviders =new LinkedHashMap<>();
// 迭代器
private LazyIteratorlookupIterator;
//重新加载，就相当于重新创建ServiceLoader了，用于新的服务提供者安装到正在运行的Java虚拟机中的情况。
public void reload() {
//清空缓存中所有已实例化的服务提供者
providers.clear();
//新建一个迭代器，该迭代器会从头查找和实例化服务提供者
lookupIterator =new LazyIterator(service, loader);
}
//私有构造器
//使用指定的类加载器和服务创建服务加载器
//如果没有指定类加载器，使用系统类加载器，就是应用类加载器。
private ServiceLoader(Class 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();
}
//解析失败处理的方法
private static void fail(Class service, String msg, Throwable cause)
throws ServiceConfigurationError
{
throw new ServiceConfigurationError(service.getName() +": " + msg,
cause);
}
private static void fail(Class service, String msg)
throws ServiceConfigurationError
{
throw new ServiceConfigurationError(service.getName() +": " + msg);
}
private static void fail(Class service, URL u, int line, String msg)
throws ServiceConfigurationError
{
fail(service, u +":" + line +": " + msg);
}
//解析服务提供者配置文件中的一行
//首先去掉注释校验，然后保存
//返回下一行行号
//重复的配置项和已经被实例化的配置项不会被保存
private int parseLine(Class service, URL u, BufferedReader r, int lc,
List 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;
}
//解析配置文件，解析指定的url配置文件
//使用parseLine方法进行解析，未被实例化的服务提供者会被保存到缓存中去
private Iteratorparse(Class service, URL u)
throws ServiceConfigurationError
{
InputStream in =null;
BufferedReader r =null;
ArrayList 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);
}
return names.iterator();
}
//服务提供者查找的迭代器
private class LazyIterator
implements Iterator
{
Classservice;//服务提供者接口
ClassLoaderloader;//类加载器
Enumerationconfigs =null;//保存实现类的url
Iteratorpending =null;//保存实现类的全名
StringnextName =null;//迭代器中下一个实现类的全名
private LazyIterator(Class service, ClassLoader loader) {
this.service = service;
this.loader = loader;
}
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);
}
}
while ((pending ==null) || !pending.hasNext()) {
if (!configs.hasMoreElements()) {
return false;
}
pending = parse(service, configs.nextElement());
}
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);
}
if (!service.isAssignableFrom(c)) {
fail(service, "Provider " + cn +" not a subtype");
}
try {
S p =service.cast(c.newInstance());
providers.put(cn, p);
return p;
}
}
public boolean hasNext() {
if (acc ==null) {
return hasNextService();
}else {
PrivilegedAction action =new PrivilegedAction() {
public Booleanrun() {return hasNextService(); }
};
return AccessController.doPrivileged(action, acc);
}
}
public S next() {
if (acc ==null) {
return nextService();
}else {
PrivilegedAction action =new PrivilegedAction() {
public S run() {return nextService(); }
};
return AccessController.doPrivileged(action, acc);
}
}
public void remove() {
throw new UnsupportedOperationException();
}
}
//获取迭代器
//返回遍历服务提供者的迭代器
//以懒加载的方式加载可用的服务提供者
//懒加载的实现是：解析配置文件和实例化服务提供者的工作由迭代器本身完成
public Iteratoriterator() {
return new Iterator() {
//按照实例化顺序返回已经缓存的服务提供者实例
Iterator>knownProviders
=providers.entrySet().iterator();
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();
}
};
}
//为指定的服务使用指定的类加载器来创建一个ServiceLoader
public static ServiceLoaderload(Class service,
ClassLoader loader)
{
return new ServiceLoader<>(service, loader);
}
//使用线程上下文的类加载器来创建ServiceLoader
public static ServiceLoaderload(Class service) {
ClassLoader cl = Thread.currentThread().getContextClassLoader();
return ServiceLoader.load(service, cl);
}
//使用扩展类加载器为指定的服务创建ServiceLoader
//只能找到并加载已经安装到当前Java虚拟机中的服务提供者，应用程序类路径中的服务提供者将被忽略
public static ServiceLoaderloadInstalled(Class service) {
ClassLoader cl = ClassLoader.getSystemClassLoader();
ClassLoader prev =null;
while (cl !=null) {
prev = cl;
cl = cl.getParent();
}
return ServiceLoader.load(service, prev);
}
public StringtoString() {
return "java.util.ServiceLoader[" +service.getName() +"]";
}
}
ServiceLoader不是实例化以后，就去读取配置文件中的具体实现，并进行实例化。而是等到使用迭代器去遍历的时候，才会加载对应的配置文件去解析，调用hasNext方法的时候会去加载配置文件进行解析，调用next方法的时候进行实例化并缓存。
所有的配置文件只会加载一次，服务提供者也只会被实例化一次，重新加载配置文件可使用reload方法。
六、SPI缺点
通过上面的解析，可以发现，我们使用SPI查找具体的实现的时候，需要遍历所有的实现，并实例化，然后我们在循环中才能找到我们需要实现。这应该也是最大的缺点，需要把所有的实现都实例化了，即便我们不需要，也都给实例化了。
有关SPI的东西暂先了解到这里，有深入的以后再添加。
参考：
https://www.jianshu.com/p/32d3e108f30a
http://cxis.me/2017/04/17/Java%E4%B8%ADSPI%E6%9C%BA%E5%88%B6%E6%B7%B1%E5%85%A5%E5%8F%8A%E6%BA%90%E7%A0%81%E8%A7%A3%E6%9E%90/
