一、背景知识
在阅读开源框架源码时，发现许多框架都支持SPI（Service Provider Interface ），前面有篇文章JDBC对Driver的加载时应用了SPI，参考【Hibernate实战】源码解析Hibernate参数绑定及PreparedStatement防SQL注入原理，于是借着JDBC对Driver的加载实现，分析下SPI机制。
二、什么是SPI
看下Wikipedia对其的解释
Service Provider Interface (SPI) is an API intended to be implemented or extended by a third party. It can be used to enable framework extension and replaceable components.
简单翻译下：
服务提供者接口(SPI)是一个API，它是由第三方实现或扩展的。它可以用于支持框架扩展和可替换组件。
简单来说SPI就是为了框架扩展而生的。在不修改原始应用程序的基础上扩展应用，可以看下Creating Extensible Applications With the Java Platform对其的解释，其中也有详细的示例。
A service provider interface (SPI) is the set of public interfaces and abstract classes that a service defines. The SPI defines the classes and methods available to your application. A service provider implements the SPI. An application with extensible services will allow you, vendors, and perhaps even customers to add service providers without modifying the original application.
简单翻译如下：
服务提供者接口(SPI)是服务定义的公共接口和抽象类的集合。SPI定义了应用程序可用的类和方法。 服务提供者实现SPI。具有可扩展服务的应用程序将允许您、供应商甚至客户在不修改原始应用程序的情况下添加服务提供者。
自JDK1.6对外提供了对SPI的支持，java.util.ServiceLoader.java，下面以Driver加载为例分析SPI机制。jdk1.8、mySQLDriver5.1.38
三、SPI原理
1、JDBC示例程序
public static void JDBCExample(){
try {
//Class.forName("com.mysql.jdbc.Driver");
Connection connection = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/hhl?useServerPrepStmts=true&cachePrepStmts=true&prepStmtCacheSize=25&prepStmtCacheSqlLimit=2048&characterEncoding=utf8&useSSL=false",
"root", "123456");
PreparedStatement preparedStatement = connection.prepareStatement("SELECT * FROM product p WHERE p.productName=?");
preparedStatement.setString(1,"Mango");
ResultSet resultSet = preparedStatement.executeQuery();
while (resultSet.next()){
System.out.println(resultSet.getString(1));
}
resultSet.close();
preparedStatement.close();
connection.close();
} catch (Exception e) {
e.printStackTrace();
}
}
自JDBC4.0以后就支持SPI了，不在需要用Class.forName()加载数据库驱动了，当然以前程序中用Class.forName()加载数据库驱动的仍然可以正常工作（用数据库连接池的还都是用Class.forName()加载数据库驱动的）。那么加载数据库驱动的操作在哪儿实现呢，java.sql.DriverManager.java
/**
* Load the initial JDBC drivers by checking the System property
* jdbc.properties and then use the {@code ServiceLoader} mechanism
*/
static {
loadInitialDrivers();
println("JDBC DriverManager initialized");
}
根据注释看出从jdbc.properties和利用ServiceLoader机制加载JDBC驱动。jdbc.properties的先不管，看下ServiceLoader机制
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;
}
// If the driver is packaged as a Service Provider, load it.
// Get all the drivers through the classloader
// exposed as a java.sql.Driver.class service.
// ServiceLoader.load() replaces the sun.misc.Providers()
AccessController.doPrivileged(new PrivilegedAction<Void>() {
public Void run() {
ServiceLoader<Driver> loadedDrivers = ServiceLoader.load(Driver.class);
Iterator<Driver> driversIterator = loadedDrivers.iterator();
/* Load these drivers, so that they can be instantiated.
* It may be the case that the driver class may not be there
* i.e. there may be a packaged driver with the service class
* as implementation of java.sql.Driver but the actual class
* may be missing. In that case a java.util.ServiceConfigurationError
* will be thrown at runtime by the VM trying to locate
* and load the service.
*
* Adding a try catch block to catch those runtime errors
* if driver not available in classpath but it's
* packaged as service and that service is there in classpath.
*/
try{
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关键代码如下几行
ServiceLoader<Driver> loadedDrivers = ServiceLoader.load(Driver.class); 2
Iterator<Driver> driversIterator = loadedDrivers.iterator(); 3
try{
while(driversIterator.hasNext()) { 4
driversIterator.next(); 5
}
} catch(Throwable t) {
// Do nothing
}
2、逐行看下 java.util.ServiceLoader.java
public static <S> ServiceLoader<S> load(Class<S> service) {
ClassLoader cl = Thread.currentThread().getContextClassLoader();
return ServiceLoader.load(service, cl);
}
其中的classLoader是当前线程上下文的加载器，泛型S代表服务类型的类，本例中就是Driver；参数service 为代表服务的接口或者抽象类，本例中是Driver.class。
public static <S> ServiceLoader<S> load(Class<S> service,
ClassLoader loader)
{
return new ServiceLoader<>(service, loader);
}
最终根据service和loader创建了一个ServiceLoader
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();
}
本例中，其中acc为null，接着看reload方法
public void reload() {
providers.clear();
lookupIterator = new LazyIterator(service, loader);
}
清空了providers缓存
// Cached providers, in instantiation order
private LinkedHashMap<String,S> providers = new LinkedHashMap<>();
创建了lookupIterator
// The current lazy-lookup iterator
private LazyIterator lookupIterator;
// Private inner class implementing fully-lazy provider lookup
//
private class LazyIterator
implements Iterator<S>
{
Class<S> service;
ClassLoader loader;
Enumeration<URL> configs = null;
Iterator<String> pending = null;
String nextName = null;
private LazyIterator(Class<S> 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);
} 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;
}
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
}
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);
}
}
public S next() {
if (acc == null) {
return nextService();
} else {
PrivilegedAction<S> action = new PrivilegedAction<S>() {
public S run() { return nextService(); }
};
return AccessController.doPrivileged(action, acc);
}
}
public void remove() {
throw new UnsupportedOperationException();
}
}
创建改对象的原因就是为了实现延迟服务提供者查找。延迟到什么时候，继续看代码。
3、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;
return lookupIterator.hasNext();
}
public S next() {
if (knownProviders.hasNext())
return knownProviders.next().getValue();
return lookupIterator.next();
}
public void remove() {
throw new UnsupportedOperationException();
}
};
}
创建了一个内部类Iterator，用于操作缓存providers和延迟加载类lookupIterator
4、driversIterator.hasNext()
操作的就是上面的hasNext
public boolean hasNext() {
if (knownProviders.hasNext())
return true;
return lookupIterator.hasNext();
}
用到了LazyIterator中的hasNext()
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);
}
}
这里acc为null，不需要特权继续执行hasNextService
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;
}
起初nextName为null，configs也为null，这个时候就会根据fullName获取包含其的资源，然后parse解析
private static final String PREFIX = "META-INF/services/";
本例中fullName就是META-INF/services/java.sql.Driver，mysql驱动中该文件内容如下：
com.mysql.jdbc.Driver com.mysql.fabric.jdbc.FabricMySQLDriver
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();
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();
}
改文件需要utf-8编码，返回的就是包含有文件内容的集合迭代器。
5、driversIterator.next()
接着看Next
public S next() {
if (knownProviders.hasNext())
return knownProviders.next().getValue();
return lookupIterator.next();
}
起初走lookupIterator.next()
public S next() {
if (acc == null) {
return nextService();
} else {
PrivilegedAction<S> action = new PrivilegedAction<S>() {
public S run() { return nextService(); }
};
return AccessController.doPrivileged(action, acc);
}
}
直接走nextService
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
}
这里会加载并初始化获取到的驱动，例如com.mysql.jdbc.Driver，这里还是需要Class.forName。采用
S p = service.cast(c.newInstance());
providers.put(cn, p);
初始化驱动，因此驱动需要有一个默认的构造函数。
至此，利用ServiceLoader加载并初始化驱动的操作就完成了。那么那么多驱动，要选择哪个驱动呢，就是根据url确定
jdbc:mysql://127.0.0.1:3306/hhl
如上url就会选择com.mysql.jdbc.Driver进行连接操作，其判断由驱动自己去做，由驱动中的acceptsURL及parseURL判断驱动支持的url，具体可看代码com.mysql.jdbc.NonRegisteringDriver.java
总结：SPI的机制就是在不修改原有程序的基础上实现扩展
当服务的提供者，提供了服务接口（java.sql.Driver）的一种实现之后，在jar包的META-INF/services/目录里同时创建一个以服务接口命名的文件。该文件里就是实现该服务接口的具体实现类。而当外部程序装配这个模块的时候，就能通过该jar包META-INF/services/里的配置文件找到具体的实现类名，并装载实例化，完成模块的注入。 基于这样一个约定就能很好的找到服务接口的实现类，而不需要再代码里指定。
