关于插件:可插拔组件设计机制SPI

61次阅读

共计 3592 个字符,预计需要花费 9 分钟才能阅读完成。

作者:京东物流 孔祥东

1.SPI 是什么?

SPI 的全称是 Service Provider Interface, 即提供服务接口;是一种服务发现机制,SPI 的实质是将接口实现类的全限定名配置在文件中,并由服务加载器读取配置文件,加载实现类。这样能够在运行时,动静为接口替换实现类。正因而个性,咱们能够很容易的通过 SPI 机制为咱们的程序提供拓展性能。

如下图:

零碎设计的各个形象,往往有很多不同的实现计划,在面对象设计里,个别举荐模块之间基于接口编程,模块之间不对实现硬编码,一旦代码波及具体的实现类,就违反了可插拔的准则。Java SPI 就是提供这样的一个机制,为某一个接口寻找服务的实现,有点相似 IOC 的思维,把拆卸的控制权移到程序之外,在模块化波及外面这个各尤为重要。与其说 SPI 是 java 提供的一种服务发现机制,倒不如说是一种解耦思维。

2. 应用场景?

  • 数据库驱动加载接口实现类的加载;如:JDBC 加载 Mysql,Oracle…
  • 日志门面接口实现类加载, 如:SLF4J 对 log4j、logback 的反对
  • Spring 中大量应用了 SPI,特地是 spring-boot 中自动化配置的实现
  • Dubbo 也是大量应用 SPI 的形式实现框架的扩大,它是对原生的 SPI 做了封装,容许用户扩大实现 Filter 接口。

3. 应用介绍

要应用 Java SPI,须要遵循以下约定:

  • 当服务提供者提供了接口的一种具体实现后,须要在 JAR 包的 META-INF/services 目录下创立一个以“接口全限度定名”为命名的文件,内容为实现类的全限定名;
  • 接口实现类所在的 JAR 放在主程序的 classpath 下,也就是引入依赖。
  • 主程序通过 java.util.ServiceLoder 动静加载实现模块,它会通过扫描 META-INF/services 目录下的文件找到实现类的全限定名,把类加载值 JVM, 并实例化它;
  • SPI 的实现类必须携带一个不带参数的构造方法。

示例:

spi-interface 模块定义

 定义一组接口:public interface MyDriver 

spi-jd-driver

spi-ali-driver

 实现为:public class JdDriver implements MyDriver
  public class AliDriver implements MyDriver 

在 src/main/resources/ 下建设 /META-INF/services 目录,新增一个以接口命名的文件 (org.MyDriver 文件)

内容是要利用的实现类别离 com.jd.JdDriver 和 com.ali.AliDriver

spi-core

个别都是平台提供的外围包,蕴含加载应用实现类的策略等等,咱们这边就简略实现一下逻辑:a. 没有找到具体实现抛出异样 b. 如果发现多个实现,别离打印

public void invoker(){ServiceLoader<MyDriver>  serviceLoader = ServiceLoader.load(MyDriver.class);
    Iterator<MyDriver> drivers = serviceLoader.iterator();
    boolean isNotFound = true;
    while (drivers.hasNext()){
        isNotFound = false;
        drivers.next().load();
    }
    if(isNotFound){throw new RuntimeException("一个驱动实现类都不存在");
    }
}

spi-test

public class App 
{public static void main( String[] args )
    {DriverFactory factory = new DriverFactory();
        factory.invoker();}
}

1. 引入 spi-core 包,执行后果

2. 引入 spi-core,spi-jd-driver 包

3. 引入 spi-core,spi-jd-driver,spi-ali-driver

4. 原理解析

看看咱们刚刚是怎么拿到具体的实现类的?

就两行代码:

ServiceLoader<MyDriver>  serviceLoader = ServiceLoader.load(MyDriver.class);
Iterator<MyDriver> drivers = serviceLoader.iterator();

所以,首先咱们看 ServiceLoader 类:

public final class ServiceLoader<S> implements Iterable<S>{
// 配置文件的门路
 private static final String PREFIX = "META-INF/services/";
    // 代表被加载的类或者接口
    private final Class<S> service;
    // 用于定位,加载和实例化 providers 的类加载器
    private final ClassLoader loader;
    // 创立 ServiceLoader 时采纳的访问控制上下文
    private final AccessControlContext acc;
    // 缓存 providers,按实例化的顺序排列
    private LinkedHashMap<String,S> providers = new LinkedHashMap<>();
    // 懒查找迭代器,真正加载服务的类
    private LazyIterator lookupIterator;
  
 // 服务提供者查找的迭代器
    private class LazyIterator
        implements Iterator<S>
    {
 .....
private boolean hasNextService() {if (nextName != null) {return true;}
            if (configs == null) {
                try {
// 全限定名:com.xxxx.xxx
                    String fullName = PREFIX + service.getName();
                    if (loader == null)
                        configs = ClassLoader.getSystemResources(fullName);
                    else
                        configs = loader.getResources(fullName);
                }
            }
            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);
            }
            if (!service.isAssignableFrom(c)) {fail(service, "Provider" + cn  + "not a subtype");
            }
            try {S p = service.cast(c.newInstance());
                providers.put(cn, p);
                return p;
            }
        }
........

大略的流程就是上面这张图:

  • 应用程序调用 ServiceLoader.load 办法
  • 应用程序通过迭代器获取对象实例,会先判断 providers 对象中是否曾经有缓存的示例对象,如果存在间接返回
  • 如果没有存在,执行类转载读取 META-INF/services 下的配置文件,获取所有能被实例化的类的名称,能够逾越 JAR 获取配置文件通过反射办法 Class.forName() 加载对象并用 Instance() 办法示例化类将实例化类缓存至 providers 对象中,同步返回。

5. 总结

长处:解耦

SPI 的应用,使得第三方服务模块的拆卸管制逻辑与调用者的业务代码拆散,不会耦合在一起,应用程序能够依据理论业务状况来启用框架扩大和替换框架组件。

SPI 的应用,使得毋庸通过上面几种形式获取实现类

  • 代码硬编码 import 导入
  • 指定类全限定名反射获取,例如 JDBC4.0 之前;Class.forName(“com.mysql.jdbc.Driver”)

毛病:

尽管 ServiceLoader 也算是应用的提早加载,然而根本只能通过遍历全副获取,也就是接口的实现类全副加载并实例化一遍。如果你并不想用某些实现类,它也被加载并实例化了,这就造成了节约。获取某个实现类的形式不够灵便,只能通过 Iterator 模式获取,不能依据某个参数来获取对应的实现类。

6. 比照

正文完
 0