Java实战源码解析Java SPI（Service Provider Interface ）机制原理
Posted Herman-Hong
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Java实战源码解析Java SPI（Service Provider Interface ）机制原理相关的知识，希望对你有一定的参考价值。
一、背景知识
在阅读开源框架源码时，发现许多框架都支持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是当前线程上下文的加载器（为了解决spi问题，引入了现成上下文类加载器 Thread Context ClassLoader，打破了双亲委派模型《深入理解java虚拟机--虚拟机执行子系统233页》），泛型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/里的配置文件找到具体的实现类名，并装载实例化，完成模块的注入。 基于这样一个约定就能很好的找到服务接口的实现类，而不需要再代码里指定。
以上是关于Java实战源码解析Java SPI（Service Provider Interface ）机制原理的主要内容，如果未能解决你的问题，请参考以下文章
Java实战源码解析Java SPI（Service Provider Interface ）机制原理