一、什么是SPI
SPI ,全称为 Service Provider Interface,是一种服务发现机制。它通过在ClassPath路径下的META-INF/services文件夹查找文件,自动加载文件里所定义的类。 这一机制为很多框架扩展提供了可能,比如在Dubbo、JDBC中都使用到了SPI机制。我们先通过一个很简单的例子来看下它是怎么用的。
1.1、小例子
首先,我们需要定义一个接口,SPIService
1 packagecom.viewscenes.netsupervisor.spi;2 public interfaceSPIService3 {4 voidexecute();5 }
然后,定义两个实现类,没别的意思,只输入一句话。
1 packagecom.viewscenes.netsupervisor.spi;2 public class SpiImpl1 implementsSPIService3 {4 public voidexecute()5 {6 System.out.println("SpiImpl1.execute()");7 }8 }9 ----------------------我是乖巧的分割线----------------------
10 packagecom.viewscenes.netsupervisor.spi;11 public class SpiImpl2 implementsSPIService12 {13 public voidexecute()14 {15 System.out.println("SpiImpl2.execute()");16 }17 }
最后呢,要在ClassPath路径下配置添加一个文件。文件名字是接口的全限定类名,内容是实现类的全限定类名,多个实现类用换行符分隔。 文件路径如下:
内容就是实现类的全限定类名:
1 com.viewscenes.netsupervisor.spi.SpiImpl12 com.viewscenes.netsupervisor.spi.SpiImpl2
1.2、测试
然后我们就可以通过ServiceLoader.load或者Service.providers方法拿到实现类的实例。其中,Service.providers包位于sun.misc.Service,而ServiceLoader.load包位于java.util.ServiceLoader。
1 public classTest {2 public static voidmain(String[] args) {3 Iterator providers = Service.providers(SPIService.class);4 ServiceLoader 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 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 implements Iterable
2 //配置文件的路径
3 private static final String PREFIX = "META-INF/services/";4 //加载的服务类或接口
5 private final Classservice;6 //已加载的服务类集合
7 private LinkedHashMap providers = new LinkedHashMap<>();8 //类加载器
9 private finalClassLoader loader;10 //内部类,真正加载服务类
11 privateLazyIterator lookupIterator;12 }
2.2、Load
load方法创建了一些属性,重要的是实例化了内部类,LazyIterator。最后返回ServiceLoader的实例。
1 public final class ServiceLoader implements Iterable
2 private ServiceLoader(Classsvc, 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 = newLazyIterator(service, loader);13 }14 }
2.3、查找实现类
查找实现类和创建实现类的过程,都在LazyIterator完成。当我们调用iterator.hasNext和iterator.next方法的时候,实际上调用的都是LazyIterator的相应方法。
1 public Iteratoriterator() {2 return new Iterator() {3 public booleanhasNext() {4 returnlookupIterator.hasNext();5 }6 publicS next() {7 returnlookupIterator.next();8 }9 .......10 };11 }
所以,我们重点关注lookupIterator.hasNext()方法,它最终会调用到hasNextService。
1 private class LazyIterator implements Iterator{2 Classservice;3 ClassLoader loader;4 Enumeration configs = null;5 Iterator pending = null;6 String nextName = null;7 private booleanhasNextService() {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{2 privateS 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 returnp;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 classDriverManager {2 static{3 loadInitialDrivers();4 println("JDBC DriverManager initialized");5 }6 }
具体过程还得看loadInitialDrivers,它在里面查找的是Driver接口的服务类,所以它的文件路径就是:META-INF/services/java.sql.Driver。
1 public classDriverManager {2 private static voidloadInitialDrivers() {3 AccessController.doPrivileged(new PrivilegedAction() {4 publicVoid run() {5 //很明显,它要加载Driver接口的服务类,Driver接口的包为:java.sql.Driver6 //所以它要找的就是META-INF/services/java.sql.Driver文件
7 ServiceLoader loadedDrivers = ServiceLoader.load(Driver.class);8 Iterator 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 implementsjava.sql.Driver {2 static{3 try{4 //注册5 //调用DriverManager类的注册方法6 //往registeredDrivers集合中加入实例
7 java.sql.DriverManager.registerDriver(newDriver());8 } catch(SQLException E) {9 throw new RuntimeException("Can't register driver!");10 }11 }12 public Driver() throwsSQLException {13 //Required for Class.forName().newInstance()
14 }15 }
3.3、创建Connection
在DriverManager.getConnection()方法就是创建连接的地方,它通过循环已注册的数据库驱动程序,调用其connect方法,获取连接并返回。
1 private staticConnection getConnection(2 String url, java.util.Properties info, Class> caller) throwsSQLException {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 packagecom.viewscenes.netsupervisor.spi2
3 public class MyDriver extends NonRegisteringDriver implementsDriver{4 static{5 try{6 java.sql.DriverManager.registerDriver(newMyDriver());7 } catch(SQLException E) {8 throw new RuntimeException("Can't register driver!");9 }10 }11 public MyDriver()throwsSQLException {}12
13 public Connection connect(String url, Properties info) throwsSQLException {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 returnconnection;20 }21 }22 --------------------输出结果---------------------
23 准备创建数据库连接.url:jdbc:mysql:///consult?serverTimezone=UTC
24 JDBC配置信息:{user=root, password=root}25 数据库连接创建完成!com.mysql.cj.jdbc.ConnectionImpl@7cf10a6f