文章目录
- 一、什么是SPI
- 1. SPI优缺点
- 2. SPI使用流程
- 2.1 加配置文件这样的好处在哪，我直接实现接口或者重写不行么？
- 3. 示例代码
- 二、SPI和API区别
- 三、应用场景
- 四、参考
一、什么是SPI
SPI全称Service Provider Interface，是Java提供的一套用来被第三方实现或者扩展的接口，它可以用来启用框架扩展和替换组件。 SPI的作用就是为这些被扩展的API寻找服务实现。
在开发过程中，将问题进抽象成API，可以为API提供各种实现。如果现在需要对API提供一种新的实现，我们可以不用修改原来的代码，直接生成新的Jar包，在包里提供API的新实现。通过Java的SPI机制，可以实现了框架的动态扩展，让第三方的实现能像插件一样嵌入到系统中。
Java的SPI类似于IOC的功能，将装配的控制权移到了程序之外，实现在模块装配的时候不用在程序中动态指明。所以SPI的核心思想就是解耦，这在模块化设计中尤其重要。
SPI全称Service Provider Interface，是Java提供的一套用来被第三方实现或者扩展的API，它可以用来启用框架扩展和替换组件。
Java SPI 实际上是“基于接口的编程＋策略模式＋配置文件”组合实现的动态加载机制。
1. SPI优缺点
优点：
- 不需要改动源码就可以实现扩展，解耦。
- 实现扩展对原来的代码几乎没有侵入性。
- 只需要添加配置就可以实现扩展，符合开闭原则。
缺点：
- ServiceLoader在加载实现类的时候会全部加载并实例化，假如不想使用某些实现类，它也会被加载示例化的，这就造成了浪费。另外获取某个实现类只能通过迭代器迭代获取，不能根据某个参数来获取，使用方式上不够灵活。
- 多个并发多线程使用ServiceLoader类的实例是不安全的。
Dubbo框架中大量使用了SPI来进行框架扩展，但它是重新对SPI进行了实现，完美的解决上面提到的问题。
2. SPI使用流程
要使用Java SPI，需要遵循如下约定：
1、当服务提供者提供了接口的一种具体实现后，在jar包的META-INF/services目录下创建一个以“接口全限定名”为命名的文件，内容为实现类的全限定名；
2、接口实现类所在的jar包放在主程序的classpath中；
3、主程序通过java.util.ServiceLoder动态装载实现模块，它通过扫描META-INF/services目录下的配置文件找到实现类的全限定名，把类加载到JVM；
4、SPI的实现类必须携带一个不带参数的构造方法；
2.1 加配置文件这样的好处在哪，我直接实现接口或者重写不行么？
因为有些引入的第三方开源包无法修改内部实现，但是可以如果有用该机制，可以重定义实现。
其实和实现接口作用是一样的，只是适用的场景不一样。用spi调用可以不用硬编码实现类的全路径。
举个例子，当我们引入别人的开源框架，例如dubbo，我们想添加一些自定义的扩展点，例如自定义权限校验逻辑，加解密实现，如果开源框架有预留SPI扩展点，就很容易实现，否则可能要改它的源码，dubbo就有预留这种扩展点。
3. 示例代码
高级开发必须理解的Java中SPI机制
参考URL: https://www.jianshu.com/p/46b42f7f593c
步骤1、定义一组接口 (假设是org.foo.demo.IShout)，并写出接口的一个或多个实现，(假设是org.foo.demo.animal.Dog、org.foo.demo.animal.Cat)。
public interface IShout {
void shout();
}
public class Cat implements IShout {
@Override
public void shout() {
System.out.println("miao miao");
}
}
public class Dog implements IShout {
@Override
public void shout() {
System.out.println("wang wang");
}
}步骤2、在 src/main/resources/ 下建立 /META-INF/services 目录， 新增一个以接口命名的文件 (org.foo.demo.IShout文件)，内容是要应用的实现类（这里是org.foo.demo.animal.Dog和org.foo.demo.animal.Cat，每行一个类）。
文件位置
- src
-main
-resources
- META-INF
- services
- org.foo.demo.IShout文件内容
org.foo.demo.animal.Dog
org.foo.demo.animal.Cat步骤3、使用 ServiceLoader 来加载配置文件中指定的实现。
public class SPIMain {
public static void main(String[] args) {
ServiceLoader<IShout> shouts = ServiceLoader.load(IShout.class);
for (IShout s : shouts) {
s.shout();
}
}
}代码输出：
wang wang
miao miao总结： ServiceLoader java sdk提供的类，利用这个类 读取META-INF/services/下的配置文件，获得所有能被实例化的类的名称。
二、SPI和API区别
API （Application Programming Interface）在大多数情况下，都是实现方制定接口并完成对接口的实现，调用方仅仅依赖接口调用，且无权选择不同实现。 从使用人员上来说，API 直接被应用开发人员使用。
SPI （Service Provider Interface）是**调用方来制定接口规范，提供给外部来实现，**调用方在调用时则选择自己需要的外部实现。 从使用人员上来说，SPI 被框架扩展人员使用。
总结：
API：API由开发人员调用。
SPI：SPI是框架接口规范，需要框架开发人员实现。
三、应用场景
比较常见的应用场景：
JDK提供一个数据库驱动接口类，JDBC加载不同的数据库驱动实现类。
日志门面接口实现类加载，SLF4J加载不同厂商提供的日志实现类。
这里以JDBC为例，看看SPI是如何自动加载驱动的。下面一段代码大家都应该很熟悉了，首先加载驱动程序，然后获取数据库连接。
//加载驱动程序
//Class.forName("com.mysql.jdbc.Driver");
//获取数据库连接
Connection conn = DriverManager.getConnection(url, user, password);这里首先要说明一下，使用mysql-connector-java连接数据库，在5.1.6之前的版本都需要加上Class.forName(“com.mysql.jdbc.Driver”); 但是从5.1.6版本以及后面的版本，这句代码就可以去掉了。这是为什么呢？下面通过代码来一探究竟。
public class DriverManager {
// List of registered JDBC drivers
private final static CopyOnWriteArrayList<DriverInfo> registeredDrivers = new CopyOnWriteArrayList<>();
private DriverManager(){}
/**
* 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");
}
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();
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);
}
}
}
public static synchronized void registerDriver(java.sql.Driver driver)
throws SQLException {
registerDriver(driver, null);
}
public static synchronized void registerDriver(java.sql.Driver driver,
DriverAction da)
throws SQLException {
/* Register the driver if it has not already been added to our list */
if(driver != null) {
registeredDrivers.addIfAbsent(new DriverInfo(driver, da));
} else {
// This is for compatibility with the original DriverManager
throw new NullPointerException();
}
println("registerDriver: " + driver);
}
@CallerSensitive
public static Connection getConnection(String url,
String user, String password) throws SQLException {
java.util.Properties info = new java.util.Properties();
if (user != null) {
info.put("user", user);
}
if (password != null) {
info.put("password", password);
}
return (getConnection(url, info, Reflection.getCallerClass()));
}
// Worker method called by the public getConnection() methods.
private static Connection getConnection(
String url, java.util.Properties info, Class<?> caller) throws SQLException {
/*
* When callerCl is null, we should check the application's
* (which is invoking this class indirectly)
* classloader, so that the JDBC driver class outside rt.jar
* can be loaded from here.
*/
ClassLoader callerCL = caller != null ? caller.getClassLoader() : null;
synchronized(DriverManager.class) {
// synchronize loading of the correct classloader.
if (callerCL == null) {
callerCL = Thread.currentThread().getContextClassLoader();
}
}
if(url == null) {
throw new SQLException("The url cannot be null", "08001");
}
println("DriverManager.getConnection(\"" + url + "\")");
// Walk through the loaded registeredDrivers attempting to make a connection.
// Remember the first exception that gets raised so we can reraise it.
SQLException reason = null;
for(DriverInfo aDriver : registeredDrivers) {
// If the caller does not have permission to load the driver then
// skip it.
if(isDriverAllowed(aDriver.driver, callerCL)) {
try {
println(" trying " + aDriver.driver.getClass().getName());
Connection con = aDriver.driver.connect(url, info);
if (con != null) {
// Success!
println("getConnection returning " + aDriver.driver.getClass().getName());
return (con);
}
} catch (SQLException ex) {
if (reason == null) {
reason = ex;
}
}
} else {
println(" skipping: " + aDriver.getClass().getName());
}
}
// if we got here nobody could connect.
if (reason != null) {
println("getConnection failed: " + reason);
throw reason;
}
println("getConnection: no suitable driver found for "+ url);
throw new SQLException("No suitable driver found for "+ url, "08001");
}
}DriverManager.getConnection(url, user, password); 执行时首先执行静态代码块，会调用loadInitialDrivers(); 这个方法能清楚看到这儿有段代码，就是通过Java的SPI加载Driver接口的所有实例，并将实例初始化。mysql-connector-java 包中META-INF/services目录下有个名为java.sql.Driver的文件，内容就是Driver接口的实现类。
com.mysql.jdbc.Driver
com.mysql.fabric.jdbc.FabricMySQLDriver
ServiceLoader<Driver> loadedDrivers = ServiceLoader.load(Driver.class);
Iterator<Driver> driversIterator = loadedDrivers.iterator();
try{
while(driversIterator.hasNext()) {
driversIterator.next();
}
} catch(Throwable t) {
// Do nothing
}当Driver 和 FabricMySQLDriver实例化的时候，会先执行静态代码块，向DriverManager注册一个自己的实例，在DriverManager中注册的驱动信息都保存在registeredDrivers中。
public class Driver extends NonRegisteringDriver implements java.sql.Driver {
public Driver() throws SQLException {
}
static {
try {
DriverManager.registerDriver(new Driver());
} catch (SQLException var1) {
throw new RuntimeException("Can't register driver!");
}
}
}DriverManager.getConnection方法真正调用的时候，就是遍历registeredDrivers 中驱动信息，找到可以使用的驱动，拿到数据库连接。
这里通过SPI机制成功的进行解耦，代码中不再强制指定使用哪个驱动实现，而是将装配的控制权移到了程序外，成功的做到了业务代码和与第三方装配逻辑分离。
四、参考
Java SPI详解
参考URL:
Java的SPI机制
参考URL:
高级开发必须理解的Java中SPI机制
参考URL: https://www.jianshu.com/p/46b42f7f593c
