深入理解SPI机制

  • Z时代
  • 2024-01-10
  • 分类：综合

编程

这一机制为很多框架扩展提供了可能，比如在Dubbo、JDBC中都使用到了SPI机制。我们先通过一个很简单的例子来看下它是怎么用的。

1、小栗子

首先，我们需要定义一个接口，SPIService

packagecom.viewscenes.netsupervisor.spi;
publicinterfaceSPIService{
voidexecute();
}

然后，定义两个实现类，没别的意思，只输入一句话。

packagecom.viewscenes.netsupervisor.spi;
publicclassSpiImpl1implementsSPIService{
publicvoidexecute(){
System.out.println("SpiImpl1.execute()");
}
}
----------------------我是乖巧的分割线----------------------
packagecom.viewscenes.netsupervisor.spi;
publicclassSpiImpl2implementsSPIService{
publicvoidexecute(){
System.out.println("SpiImpl2.execute()");
}
}

最后呢，要在ClassPath路径下配置添加一个文件。文件名字是接口的全限定类名，内容是实现类的全限定类名，多个实现类用换行符分隔。
文件路径如下：

 

 

SPI配置文件位置

 

内容就是实现类的全限定类名：

com.viewscenes.netsupervisor.spi.SpiImpl1
com.viewscenes.netsupervisor.spi.SpiImpl2

2、测试

然后我们就可以通过ServiceLoader.load或者Service.providers方法拿到实现类的实例。其中，Service.providers包位于sun.misc.Service，而ServiceLoader.load包位于java.util.ServiceLoader。

publicclassTest{
publicstaticvoidmain(String[] args){
Iterator<SPIService> providers =Service.providers(SPIService.class);
ServiceLoader<SPIService> load =ServiceLoader.load(SPIService.class);
while(providers.hasNext()){
SPIService ser = providers.next();
            ser.execute();
}
System.out.println("--------------------------------");
Iterator<SPIService> iterator = load.iterator();
while(iterator.hasNext()){
SPIService ser = iterator.next();
            ser.execute();
}
}
}

两种方式的输出结果是一致的：

SpiImpl1.execute()
SpiImpl2.execute()
--------------------------------
SpiImpl1.execute()
SpiImpl2.execute()

二、源码分析

我们看到一个位于sun.misc包，一个位于java.util包，sun包下的源码看不到。我们就以ServiceLoader.load为例，通过源码看看它里面到底怎么做的。

1、ServiceLoader

首先，我们先来了解下ServiceLoader，看看它的类结构。

publicfinalclassServiceLoader<S>implementsIterable<S>
//配置文件的路径
privatestaticfinalString PREFIX ="META-INF/services/";
//加载的服务类或接口
privatefinalClass<S> service;
//已加载的服务类集合
privateLinkedHashMap<String,S> providers =newLinkedHashMap<>();
//类加载器
privatefinalClassLoader loader;
//内部类，真正加载服务类
privateLazyIterator lookupIterator;
}

2、Load

load方法创建了一些属性，重要的是实例化了内部类，LazyIterator。最后返回ServiceLoader的实例。

public finalclassServiceLoader<S>implementsIterable<S>
    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;
//先清空
        providers.clear();
//实例化内部类 
        LazyIterator lookupIterator =newLazyIterator(service, loader);
}
}

3、查找实现类

查找实现类和创建实现类的过程，都在LazyIterator完成。当我们调用iterator.hasNext和iterator.next方法的时候，实际上调用的都是LazyIterator的相应方法。

publicIterator<S>iterator(){
returnnewIterator<S>(){
publicbooleanhasNext(){
return lookupIterator.hasNext();
}
publicSnext(){
return lookupIterator.next();
}
.......
};
}

所以，我们重点关注lookupIterator.hasNext()方法，它最终会调用到hasNextService。

private classLazyIteratorimplementsIterator<S>{
    Class<S> service;
    ClassLoader loader;
    Enumeration<URL> configs =null;
    Iterator<String> pending =null;
    String nextName =null;
    private boolean hasNextService(){
//第二次调用的时候，已经解析完成了，直接返回
if(nextName !=null){
returntrue;
}
if(configs ==null){
//META-INF/services/ 加上接口的全限定类名，就是文件服务类的文件
//META-INF/services/com.viewscenes.netsupervisor.spi.SPIService
            String fullName = PREFIX + service.getName();
//将文件路径转成URL对象
            configs = loader.getResources(fullName);
}
while((pending ==null)||!pending.hasNext()){
//解析URL文件对象，读取内容，最后返回
            pending =parse(service, configs.nextElement());
}
//拿到第一个实现类的类名
        nextName = pending.next();
returntrue;
}
}

4、创建实例

当然，调用next方法的时候，实际调用到的是，lookupIterator.nextService。它通过反射的方式，创建实现类的实例并返回。

privateclassLazyIteratorimplementsIterator<S>{
privateSnextService(){
//全限定类名
String cn = nextName;
        nextName =null;
//创建类的Class对象
Class<?> c =Class.forName(cn,false, loader);
//通过newInstance实例化
S p = service.cast(c.newInstance());
//放入集合，返回实例
        providers.put(cn, p);
return p;
}
}

看到这儿，我想已经很清楚了。获取到类的实例，我们自然就可以对它为所欲为了！

三、JDBC中的应用

我们开头说，SPI机制为很多框架的扩展提供了可能，其实JDBC就应用到了这一机制。回忆一下JDBC获取数据库连接的过程。在早期版本中，需要先设置数据库驱动的连接，再通过DriverManager.getConnection获取一个Connection。

String url ="jdbc:mysql:///consult?serverTimezone=UTC";
String user ="root";
String password ="root";
Class.forName("com.mysql.jdbc.Driver");
Connection connection = DriverManager.getConnection(url, user, password);

在较新版本中(具体哪个版本，笔者没有验证)，设置数据库驱动连接，这一步骤就不再需要，那么它是怎么分辨是哪种数据库的呢？答案就在SPI。

1、加载

我们把目光回到DriverManager类，它在静态代码块里面做了一件比较重要的事。很明显，它已经通过SPI机制， 把数据库驱动连接初始化了。

publicclassDriverManager{
static{
loadInitialDrivers();
println("JDBC DriverManager initialized");
}
}

具体过程还得看loadInitialDrivers，它在里面查找的是Driver接口的服务类，所以它的文件路径就是：META-INF/services/java.sql.Driver。

publicclassDriverManager{
privatestaticvoidloadInitialDrivers(){
AccessController.doPrivileged(newPrivilegedAction<Void>(){
publicVoidrun(){
//很明显，它要加载Driver接口的服务类，Driver接口的包为:java.sql.Driver
//所以它要找的就是META-INF/services/java.sql.Driver文件
ServiceLoader<Driver> loadedDrivers =ServiceLoader.load(Driver.class);
Iterator<Driver> driversIterator = loadedDrivers.iterator();
try{
//查到之后创建对象
while(driversIterator.hasNext()){
                        driversIterator.next();
}
}catch(Throwable t){
// Do nothing
}
returnnull;
}
});
}
}

那么，这个文件哪里有呢？我们来看MySQL的jar包，就是这个文件，文件内容为：com.mysql.cj.jdbc.Driver。

 

MySQL SPI文件

 

2、创建实例

上一步已经找到了MySQL中的com.mysql.cj.jdbc.Driver全限定类名，当调用next方法时，就会创建这个类的实例。它就完成了一件事，向DriverManager注册自身的实例。

publicclassDriverextendsNonRegisteringDriverimplements java.sql.Driver{
static{
try{
//注册
//调用DriverManager类的注册方法
//往registeredDrivers集合中加入实例
            java.sql.DriverManager.registerDriver(newDriver());
}catch(SQLExceptionE){
thrownewRuntimeException("Can"t register driver!");
}
}
publicDriver()throwsSQLException{
// Required for Class.forName().newInstance()
}
}

3、创建Connection

在DriverManager.getConnection()方法就是创建连接的地方，它通过循环已注册的数据库驱动程序，调用其connect方法，获取连接并返回。

privatestaticConnectiongetConnection(
String url, java.util.Properties info,Class<?> caller)throwsSQLException{
//registeredDrivers中就包含com.mysql.cj.jdbc.Driver实例
for(DriverInfo aDriver : registeredDrivers){
if(isDriverAllowed(aDriver.driver, callerCL)){
try{
//调用connect方法创建连接
Connection con = aDriver.driver.connect(url, info);
if(con !=null){
return(con);
}
}catch(SQLException ex){
if(reason ==null){
                    reason = ex;
}
}
}else{
println("    skipping: "+ aDriver.getClass().getName());
}
}
}

4、再扩展

既然我们知道JDBC是这样创建数据库连接的，我们能不能再扩展一下呢？如果我们自己也创建一个java.sql.Driver文件，自定义实现类MyDriver，那么，在获取连接的前后就可以动态修改一些信息。

还是先在项目ClassPath下创建文件，文件内容为自定义驱动类com.viewscenes.netsupervisor.spi.MyDriver

 

自定义数据库驱动程序

我们的MyDriver实现类，继承自MySQL中的NonRegisteringDriver，还要实现java.sql.Driver接口。这样，在调用connect方法的时候，就会调用到此类，但实际创建的过程还靠MySQL完成。

packagecom.viewscenes.netsupervisor.spi
publicclassMyDriverextendsNonRegisteringDriverimplementsDriver{
static{
try{
            java.sql.DriverManager.registerDriver(newMyDriver());
}catch(SQLExceptionE){
thrownewRuntimeException("Can"t register driver!");
}
}
publicMyDriver()throwsSQLException{}
publicConnectionconnect(String url,Properties info)throwsSQLException{
System.out.println("准备创建数据库连接.url:"+url);
System.out.println("JDBC配置信息："+info);
        info.setProperty("user","root");
Connection connection =super.connect(url, info);
System.out.println("数据库连接创建完成!"+connection.toString());
return connection;
}
}
--------------------输出结果---------------------
准备创建数据库连接.url:jdbc:mysql:///consult?serverTimezone=UTC
JDBC配置信息：{user=root, password=root}
数据库连接创建完成!com.mysql.cj.jdbc.ConnectionImpl@7cf10a6f



作者：清幽之地


链接：https://www.jianshu.com/p/3a3edbcd8f24


来源：简书


著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

以上是 深入理解SPI机制 的全部内容， 来源链接： utcz.com/z/516105.html

回到顶部