一、什么是SPI
SPI ，全称为 Service Provider Interface，是一种服务发现机制。它通过在ClassPath路径下的META-INF/services文件夹查找文件，自动加载文件里所定义的类。 这一机制为很多框架扩展提供了可能，比如在Dubbo、JDBC中都使用到了SPI机制。我们先通过一个很简单的例子来看下它是怎么用的。
1.1、小例子
首先，我们需要定义一个接口，SPIService
1 package com.viewscenes.netsupervisor.spi;
2 public interface SPIService
3 {
4 void execute();
5 }
然后，定义两个实现类，没别的意思，只输入一句话。
1 package com.viewscenes.netsupervisor.spi;
2 public class SpiImpl1 implements SPIService
3 {
4 public void execute()
5 {
6 System.out.println("SpiImpl1.execute()");
7 }
8 }
9 ----------------------我是乖巧的分割线----------------------
10 package com.viewscenes.netsupervisor.spi;
11 public class SpiImpl2 implements SPIService
12 {
13 public void execute()
14 {
15 System.out.println("SpiImpl2.execute()");
16 }
17 }
最后呢，要在ClassPath路径下配置添加一个文件。文件名字是接口的全限定类名，内容是实现类的全限定类名，多个实现类用换行符分隔。 文件路径如下：
内容就是实现类的全限定类名：
1 com.viewscenes.netsupervisor.spi.SpiImpl1 2 com.viewscenes.netsupervisor.spi.SpiImpl2
1.2、测试
然后我们就可以通过ServiceLoader.load或者Service.providers方法拿到实现类的实例。其中，Service.providers包位于sun.misc.Service，而ServiceLoader.load包位于java.util.ServiceLoader。
1 public class Test {
2 public static void main(String[] args) {
3 Iterator<SPIService> providers = Service.providers(SPIService.class);
4 ServiceLoader<SPIService> load = ServiceLoader.load(SPIService.class);
5
6 while(providers.hasNext()) {
7 SPIService ser = providers.next();
8 ser.execute();
9 }
10 System.out.println("--------------------------------");
11 Iterator<SPIService> iterator = load.iterator();
12 while(iterator.hasNext()) {
13 SPIService ser = iterator.next();
14 ser.execute();
15 }
16 }
17 }
两种方式的输出结果是一致的：
1 SpiImpl1.execute() 2 SpiImpl2.execute() 3 -------------------------------- 4 SpiImpl1.execute() 5 SpiImpl2.execute()
二、源码分析
我们看到一个位于sun.misc包，一个位于java.util包，sun包下的源码看不到。我们就以ServiceLoader.load为例，通过源码看看它里面到底怎么做的。
2.1、ServiceLoader
首先，我们先来了解下ServiceLoader，看看它的类结构。
1 public final class ServiceLoader<S> implements Iterable<S> 2 //配置文件的路径 3 private static final String PREFIX = "META-INF/services/"; 4 //加载的服务类或接口 5 private final Class<S> service; 6 //已加载的服务类集合 7 private LinkedHashMap<String,S> providers = new LinkedHashMap<>(); 8 //类加载器 9 private final ClassLoader loader; 10 //内部类，真正加载服务类 11 private LazyIterator lookupIterator; 12 }
2.2、Load
load方法创建了一些属性，重要的是实例化了内部类，LazyIterator。最后返回ServiceLoader的实例。
1 public final class ServiceLoader<S> implements Iterable<S>
2 private ServiceLoader(Class<S> svc, ClassLoader cl) {
3 //要加载的接口
4 service = Objects.requireNonNull(svc, "Service interface cannot be null");
5 //类加载器
6 loader = (cl == null) ? ClassLoader.getSystemClassLoader() : cl;
7 //访问控制器
8 acc = (System.getSecurityManager() != null) ? AccessController.getContext() : null;
9 //先清空
10 providers.clear();
11 //实例化内部类
12 LazyIterator lookupIterator = new LazyIterator(service, loader);
13 }
14 }
2.3、查找实现类
查找实现类和创建实现类的过程，都在LazyIterator完成。当我们调用iterator.hasNext和iterator.next方法的时候，实际上调用的都是LazyIterator的相应方法。
1 public Iterator<S> iterator() {
2 return new Iterator<S>() {
3 public boolean hasNext() {
4 return lookupIterator.hasNext();
5 }
6 public S next() {
7 return lookupIterator.next();
8 }
9 .......
10 };
11 }
所以，我们重点关注lookupIterator.hasNext()方法，它最终会调用到hasNextService。
1 private class LazyIterator implements Iterator<S>{
2 Class<S> service;
3 ClassLoader loader;
4 Enumeration<URL> configs = null;
5 Iterator<String> pending = null;
6 String nextName = null;
7 private boolean hasNextService() {
8 //第二次调用的时候，已经解析完成了，直接返回
9 if (nextName != null) {
10 return true;
11 }
12 if (configs == null) {
13 //META-INF/services/ 加上接口的全限定类名，就是文件服务类的文件
14 //META-INF/services/com.viewscenes.netsupervisor.spi.SPIService
15 String fullName = PREFIX + service.getName();
16 //将文件路径转成URL对象
17 configs = loader.getResources(fullName);
18 }
19 while ((pending == null) || !pending.hasNext()) {
20 //解析URL文件对象，读取内容，最后返回
21 pending = parse(service, configs.nextElement());
22 }
23 //拿到第一个实现类的类名
24 nextName = pending.next();
25 return true;
26 }
27 }
2.4、创建实例
当然，调用next方法的时候，实际调用到的是，lookupIterator.nextService。它通过反射的方式，创建实现类的实例并返回。
1 private class LazyIterator implements Iterator<S>{
2 private S nextService() {
3 //全限定类名
4 String cn = nextName;
5 nextName = null;
6 //创建类的Class对象
7 Class<?> c = Class.forName(cn, false, loader);
8 //通过newInstance实例化
9 S p = service.cast(c.newInstance());
10 //放入集合，返回实例
11 providers.put(cn, p);
12 return p;
13 }
14 }
看到这儿，我想已经很清楚了。获取到类的实例，我们自然就可以对它为所欲为了！
三、JDBC中的应用
我们开头说，SPI机制为很多框架的扩展提供了可能，其实JDBC就应用到了这一机制。回忆一下JDBC获取数据库连接的过程。在早期版本中，需要先设置数据库驱动的连接，再通过DriverManager.getConnection获取一个Connection。
1 String url = "jdbc:mysql:///consult?serverTimezone=UTC";
2 String user = "root";
3 String password = "root";
4
5 Class.forName("com.mysql.jdbc.Driver");
6 Connection connection = DriverManager.getConnection(url, user, password);
在较新版本中(具体哪个版本，笔者没有验证)，设置数据库驱动连接，这一步骤就不再需要，那么它是怎么分辨是哪种数据库的呢？答案就在SPI。
3.1、加载
我们把目光回到DriverManager类，它在静态代码块里面做了一件比较重要的事。很明显，它已经通过SPI机制， 把数据库驱动连接初始化了。
1 public class DriverManager {
2 static {
3 loadInitialDrivers();
4 println("JDBC DriverManager initialized");
5 }
6 }
具体过程还得看loadInitialDrivers，它在里面查找的是Driver接口的服务类，所以它的文件路径就是：META-INF/services/java.sql.Driver。
1 public class DriverManager {
2 private static void loadInitialDrivers() {
3 AccessController.doPrivileged(new PrivilegedAction<Void>() {
4 public Void run() {
5 //很明显，它要加载Driver接口的服务类，Driver接口的包为:java.sql.Driver
6 //所以它要找的就是META-INF/services/java.sql.Driver文件
7 ServiceLoader<Driver> loadedDrivers = ServiceLoader.load(Driver.class);
8 Iterator<Driver> driversIterator = loadedDrivers.iterator();
9 try{
10 //查到之后创建对象
11 while(driversIterator.hasNext()) {
12 driversIterator.next();
13 }
14 } catch(Throwable t) {
15 // Do nothing
16 }
17 return null;
18 }
19 });
20 }
21 }
那么，这个文件哪里有呢？我们来看MySQL的jar包，就是这个文件，文件内容为：com.mysql.cj.jdbc.Driver。
3.2、创建实例
上一步已经找到了MySQL中的com.mysql.cj.jdbc.Driver全限定类名，当调用next方法时，就会创建这个类的实例。它就完成了一件事，向DriverManager注册自身的实例。
1 public class Driver extends NonRegisteringDriver implements java.sql.Driver {
2 static {
3 try {
4 //注册
5 //调用DriverManager类的注册方法
6 //往registeredDrivers集合中加入实例
7 java.sql.DriverManager.registerDriver(new Driver());
8 } catch (SQLException E) {
9 throw new RuntimeException("Can't register driver!");
10 }
11 }
12 public Driver() throws SQLException {
13 // Required for Class.forName().newInstance()
14 }
15 }
3.3、创建Connection
在DriverManager.getConnection()方法就是创建连接的地方，它通过循环已注册的数据库驱动程序，调用其connect方法，获取连接并返回。
1 private static Connection getConnection(
2 String url, java.util.Properties info, Class<?> caller) throws SQLException {
3 //registeredDrivers中就包含com.mysql.cj.jdbc.Driver实例
4 for(DriverInfo aDriver : registeredDrivers) {
5 if(isDriverAllowed(aDriver.driver, callerCL)) {
6 try {
7 //调用connect方法创建连接
8 Connection con = aDriver.driver.connect(url, info);
9 if (con != null) {
10 return (con);
11 }
12 }catch (SQLException ex) {
13 if (reason == null) {
14 reason = ex;
15 }
16 }
17 } else {
18 println(" skipping: " + aDriver.getClass().getName());
19 }
20 }
21 }
3.4、再扩展
既然我们知道JDBC是这样创建数据库连接的，我们能不能再扩展一下呢？如果我们自己也创建一个java.sql.Driver文件，自定义实现类MyDriver，那么，在获取连接的前后就可以动态修改一些信息。 还是先在项目ClassPath下创建文件，文件内容为自定义驱动类com.viewscenes.netsupervisor.spi.MyDriver
我们的MyDriver实现类，继承自MySQL中的NonRegisteringDriver，还要实现java.sql.Driver接口。这样，在调用connect方法的时候，就会调用到此类，但实际创建的过程还靠MySQL完成。
1 package com.viewscenes.netsupervisor.spi
2
3 public class MyDriver extends NonRegisteringDriver implements Driver{
4 static {
5 try {
6 java.sql.DriverManager.registerDriver(new MyDriver());
7 } catch (SQLException E) {
8 throw new RuntimeException("Can't register driver!");
9 }
10 }
11 public MyDriver()throws SQLException {}
12
13 public Connection connect(String url, Properties info) throws SQLException {
14 System.out.println("准备创建数据库连接.url:"+url);
15 System.out.println("JDBC配置信息："+info);
16 info.setProperty("user", "root");
17 Connection connection = super.connect(url, info);
18 System.out.println("数据库连接创建完成!"+connection.toString());
19 return connection;
20 }
21 }
22 --------------------输出结果---------------------
23 准备创建数据库连接.url:jdbc:mysql:///consult?serverTimezone=UTC
24 JDBC配置信息：{user=root, password=root}
25 数据库连接创建完成!com.mysql.cj.jdbc.ConnectionImpl@7cf10a6f