前言

SPI，英文全称是Service Provider Interface，直译是“服务提供接口”或“服务提供者接口”，是一种基于ClassLoader来发现并加载服务的机制。

这里的“服务”泛指任何一个可以提供服务的功能、模块、应用或系统，这些“服务”在设计接口或规范体系时，往往会预留一些比较关键的口子或者扩展点，让调用方按照既定的规范去自由发挥实现，而这些所谓的“比较关键的口子或者扩展点”，我们就叫“服务”提供的“接口”。

一个标准的SPI，由3个组件构成，分别是：

• Service：一个公开的接口或抽象类，定义了一个抽象的功能模块；
• Service Provider：Service的一个实现类；
• ServiceLoader：SPI机制中的核心组件，负责在运行时发现并加载Service Provider。

JDK SPI

JDK自带的SPI实现，流程如图所示：

JDBC SPI

以JDBC举例，来看一下具体如何使用。

JDK在java.sql包下有个名为Driver的接口，定义了若干个方法，而具体实现则由具体的DB厂商来实现，如MySQL、Oracle等。

package java.sql;

public interface Driver {

    java.sql.Connection connect(String url, java.util.Properties info) throws SQLException;

    boolean acceptsURL(String url) throws SQLException;

    java.sql.DriverPropertyInfo[] getPropertyInfo(String url, java.util.Properties info) throws SQLException;

    int getMajorVersion();

    int getMinorVersion();

    boolean jdbcCompliant();

    public java.util.logging.Logger getParentLogger() throws SQLFeatureNotSupportedException;
}

在MySQL和Oracle的jar包中，在META-INF/services目录下有个名为java.sql.Driver的文件，里面的内容分别为com.mysql.cj.jdbc.Driver和oracle.jdbc.OracleDriver，即MySQL和Oracle里实现Driver接口的实现类的全路径。

此外，我还自定义了一个SimonLeeSQL工程，来实现Driver接口。

定义AbstractSimonLeeSqlDriver，实现Driver接口：

public abstract class AbstractSimonLeeSqlDriver implements java.sql.Driver {

    @Override
    public java.sql.Connection connect(String url, java.util.Properties info) {
        return null;
    }

    @Override
    public boolean acceptsURL(String url) {
        return false;
    }

    @Override
    public java.sql.DriverPropertyInfo[] getPropertyInfo(String url, java.util.Properties info) {
        return new java.sql.DriverPropertyInfo[0];
    }

    @Override
    public int getMajorVersion() {
        return 0;
    }

    @Override
    public int getMinorVersion() {
        return 0;
    }

    @Override
    public boolean jdbcCompliant() {
        return false;
    }

    @Override
    public java.util.logging.Logger getParentLogger() {
        return null;
    }
}

再定义SimonLeeSqlDriver1与SimonLeeSqlDriver2，继承AbstractSimonLeeSqlDriver：

public class SimonLeeSqlDriver1 extends AbstractSimonLeeSqlDriver {
}

public class SimonLeeSqlDriver2 extends AbstractSimonLeeSqlDriver {
}

最后在resources的META-INF/services目录下定义个名为java.sql.Driver的文件，里面的内容为如下2行：

将SimonLeeSQL工程mvn install，在A工程的pom.xml里分别引入MySQl、Oracle、SimonLeeSQL的坐标。

<dependency>
	<groupId>mysql</groupId>
	<artifactId>mysql-connector-java</artifactId>
	<version>8.0.33</version>
</dependency>
<dependency>
	<groupId>com.oracle.database.jdbc</groupId>
	<artifactId>ojdbc8</artifactId>
	<version>21.3.0.0</version>
</dependency>
<dependency>
	<groupId>com.simonlee</groupId>
	<artifactId>SimonLeeSQL</artifactId>
	<version>1.0-SNAPSHOT</version>
</dependency>

在A工程里，使用java.util.ServiceLoader.load()和其内部的迭代器加载上述4个Driver接口的实现类。

public static void main(String[] args) {
	java.util.ServiceLoader<java.sql.Driver> drivers = java.util.ServiceLoader.load(java.sql.Driver.class);
	java.util.Iterator<java.sql.Driver> iterator = drivers.iterator();
	while (iterator.hasNext()) {
		java.sql.Driver driver = iterator.next();
		System.out.println(driver);
	}
}

看一下输出结果，能正确拿到4个具体实现类的实例。

在具体应用中，A工程如果想更换DB驱动，只需要在pom.xml里引入DB厂商提供的Maven坐标即可（前提是遵循了JDBC的SPI玩法），无需改动任何代码，实现了热插拔。

ServiceLoader实现原理

java.util.ServiceLoader实现了Iterable接口，并且在内部定义了LazyIterator迭代器。

private class LazyIterator implements Iterator<S> {

	private Class<S> service;
	private ClassLoader loader;
	private Enumeration<java.net.URL> configs = null;
	private Iterator<String> pending = null;
	private String nextName = null;

	@Override
	public boolean hasNext() {
		if (nextName != null) {
			return true;
		}
		if (configs == null) {
			try {
				// PREFIX = META-INF/services/
				// service.getName() = java.sql.Driver
				// fullName = META-INF/services/java.sql.Driver
				String fullName = PREFIX + service.getName();
				if (loader == null) {
					configs = ClassLoader.getSystemResources(fullName);
				} else {
					// java.lang.ClassLoader.getResources()扫描所有META-INF/services/java.sql.Driver文件
					// loader = Launcher$AppClassLoader
					configs = loader.getResources(fullName);
				}
			} catch (java.io.IOException x) {
				fail(service, "Error locating configuration files", x);
			}
		}
		while ((pending == null) || !pending.hasNext()) {
			if (!configs.hasMoreElements()) {
				return false;
			}
			// configs.nextElement() =
			//  jar:file:/D:/MavenRepo/com/mysql/mysql-connector-j/8.0.33/mysql-connector-j-8.0.33.jar!/META-INF/services/java.sql.Driver
			//  jar:file:/D:/MavenRepo/com/oracle/database/jdbc/ojdbc8/21.3.0.0/ojdbc8-21.3.0.0.jar!/META-INF/services/java.sql.Driver
			//  jar:file:/D:/MavenRepo/com/simonlee/SimonLeeSQL/1.0-SNAPSHOT/SimonLeeSQL-1.0-SNAPSHOT.jar!/META-INF/services/java.sql.Driver
			pending = parse(service, configs.nextElement());
		}
		// nextName =
		//  com.mysql.cj.jdbc.Driver
		//  oracle.jdbc.OracleDriver
		//  com.simonlee.sql.SimonLeeSqlDriver1
		//  com.simonlee.sql.SimonLeeSqlDriver2
		nextName = pending.next();
		return true;
	}

	@Override
	public S next() {
		if (!hasNext()) {
			throw new NoSuchElementException();
		}
		String cn = nextName;
		nextName = null;
		Class<?> c = null;
		try {
			// java.lang.Class.forName()，反射机制来实例化对象
			// c =
			//  class com.mysql.cj.jdbc.Driver
			//  class oracle.jdbc.OracleDriver
			//  class com.simonlee.sql.SimonLeeSqlDriver1
			//  class com.simonlee.sql.SimonLeeSqlDriver2
			c = Class.forName(cn, false, loader);
		} catch (ClassNotFoundException x) {
			fail(service, "Provider " + cn + " not found");
		}
		if (!service.isAssignableFrom(c)) {
			fail(service, "Provider " + cn + " not a subtype");
		}
		try {
			S p = service.cast(c.newInstance());
			// providers.key = nextName, value = 具体实例
			providers.put(cn, p);
			return p;
		} catch (Throwable x) {
			fail(service, "Provider " + cn + " could not be instantiated", x);
		}
		throw new Error();
	}

	@Override
	public void remove() {
		throw new UnsupportedOperationException();
	}
}

运行完后，providers的内容如图所示：

小结

Spring+SpringBoot SPI

相较于JDK SPI，Spring+SpringBoot的区别是：

• 配置文件路径为META-INF
• 配置文件名固定为spring.factories
• 配置文件内容为key-value，key固定为org.springframework.boot.autoconfigure.EnableAutoConfiguration，value为接口的实现类的全路径

实现原理

通过Spring里的org.springframework.core.io.support.SpringFactoriesLoader.loadFactories()读取所有jar包的META-INF/spring.factories资源文件，并从文件中读取一堆的类似EnableAutoConfiguration标识的类路径，将这些类创建对应的Spring Bean对象注入到容器中，就完成了SpringBoot的自动装配底层核心原理。

Spring里的org.springframework.core.io.support.SpringFactoriesLoader：

public class SpringFactoriesLoader {

    public static final String FACTORIES_RESOURCE_LOCATION = "META-INF/spring.factories";

    static final Map<ClassLoader, Map<String, List<String>>> cache = new org.springframework.util.ConcurrentReferenceHashMap<>();

    public static List<String> loadFactoryNames(Class<?> factoryType, @org.springframework.lang.Nullable ClassLoader classLoader) {
        ClassLoader classLoaderToUse = classLoader;
        if (classLoaderToUse == null) {
            classLoaderToUse = org.springframework.core.io.support.SpringFactoriesLoader.class.getClassLoader();
        }
        String factoryTypeName = factoryType.getName();
        return loadSpringFactories(classLoaderToUse).getOrDefault(factoryTypeName, Collections.emptyList());
    }

    private static Map<String, List<String>> loadSpringFactories(ClassLoader classLoader) {
        Map<String, List<String>> result = cache.get(classLoader);
        if (result != null) {
            return result;
        }

        result = new HashMap<>();
        try {
            // FACTORIES_RESOURCE_LOCATION = META-INF/spring.factories
            // java.lang.ClassLoader.getResources()扫描所有META-INF/spring.factories文件
            Enumeration<java.net.URL> urls = classLoader.getResources(FACTORIES_RESOURCE_LOCATION);
            while (urls.hasMoreElements()) {
                java.net.URL url = urls.nextElement();
                org.springframework.core.io.UrlResource resource = new org.springframework.core.io.UrlResource(url);
                Properties properties = org.springframework.core.io.support.PropertiesLoaderUtils.loadProperties(resource);
                // 遍历每个META-INF/spring.factories文件，拿到里面的key-value对
                for (Map.Entry<?, ?> entry : properties.entrySet()) {
                    String factoryTypeName = ((String) entry.getKey()).trim();
                    // 将value按半角逗号分割，转成数组
                    String[] factoryImplementationNames = StringUtils.commaDelimitedListToStringArray((String) entry.getValue());
                    // 遍历数组，拿到里面的值
                    for (String factoryImplementationName : factoryImplementationNames) {
                        // result.key = org.springframework.boot.autoconfigure.EnableAutoConfiguration（包括但不限于）
                        // result.value = 接口的实现类的全路径
                        result.computeIfAbsent(factoryTypeName, key -> new ArrayList<>()).add(factoryImplementationName.trim());
                    }
                }
            }

            // Replace all lists with unmodifiable lists containing unique elements
            result.replaceAll((factoryType, implementations) -> implementations.stream()
                    .distinct()
                    .collect(java.util.stream.Collectors.collectingAndThen(java.util.stream.Collectors.toList(), Collections::unmodifiableList)));
            // 将result放到cache里，后续调用时可直接拿到
            cache.put(classLoader, result);
        } catch (java.io.IOException ex) {
            throw new IllegalArgumentException("Unable to load factories from location [" + FACTORIES_RESOURCE_LOCATION + "]", ex);
        }
        return result;
    }
}

SpringBoot里的org.springframework.boot.autoconfigure.AutoConfigurationImportSelector：

public class AutoConfigurationImportSelector
        implements org.springframework.context.annotation.DeferredImportSelector,
        org.springframework.beans.factory.BeanClassLoaderAware,
        org.springframework.context.ResourceLoaderAware,
        org.springframework.beans.factory.BeanFactoryAware,
        org.springframework.context.EnvironmentAware,
        org.springframework.core.Ordered {

    protected List<String> getCandidateConfigurations(org.springframework.core.type.AnnotationMetadata metadata,
                                                      org.springframework.core.annotation.AnnotationAttributes attributes) {
        // getSpringFactoriesLoaderFactoryClass() = EnableAutoConfiguration.class
        // 调用Spring里的org.springframework.core.io.support.SpringFactoriesLoader
        // 从cache里获取key = org.springframework.boot.autoconfigure.EnableAutoConfiguration的value，即接口的实现类的全路径
        List<String> configurations = SpringFactoriesLoader.loadFactoryNames(getSpringFactoriesLoaderFactoryClass(), getBeanClassLoader());
        Assert.notEmpty(configurations, "No auto configuration classes found in META-INF/spring.factories." +
                " If you are using a custom packaging, make sure that file is correct.");
        return configurations;
    }

    protected Class<?> getSpringFactoriesLoaderFactoryClass() {
        return org.springframework.boot.autoconfigure.EnableAutoConfiguration.class;
    }
}

Debug

对SimonLeeSQL工程进行改造，定义SimonLeeSqlDriver3与SimonLeeSqlDriver4，继承AbstractSimonLeeSqlDriver。

public class SimonLeeSqlDriver3 extends AbstractSimonLeeSqlDriver {
}

public class SimonLeeSqlDriver4 extends AbstractSimonLeeSqlDriver {
}

最后在resources的META-INF目录下定义个名为spring.factories的文件，里面的内容为如下2行：

将SimonLeeSQL工程重新mvn install，在A工程的pom.xml里新加引入mybatis-spring-boot-autoconfigure的坐标。

<dependency>
	<groupId>org.mybatis.spring.boot</groupId>
	<artifactId>mybatis-spring-boot-autoconfigure</artifactId>
	<version>2.3.2</version>
</dependency>

其中的META-INF/spring.factories文件如下所示：

启动A工程，Debug结果如下所示：

可以看到，cache里有key=EnableAutoConfiguration和SimonLeeTestKey的，并且key=EnableAutoConfiguration的value里有MybatisLanguageDriverAutoConfiguration、MybatisAutoConfiguration、SimonLeeSqlDriver3、SimonLeeSqlDriver4，符合预期。

小结

相较于JDK SPI，Spring+SpringBoot做了如下优化：

• 如果想让一个jar包利用SPI机制支持2个接口com.xxx.Interface1和com.xxx.Interface2，JDK需要在META-INT/services目录下创建2个文件com.xxx.Interface1和com.xxx.Interface2，而Spring+SpringBoot只需在META-INT目录下的spring.factories文件里加入对应的key即可（参考mybatis-spring-boot-autoconfigure）
• 如果想获取特定的接口的实现类，JDK由于采用List存储，需要自己进行遍历并编写各种比较代码，而Spring+SpringBoot采用Map存储，getKey即可（参考AutoConfigurationImportSelector获取key=EnableAutoConfiguration）。

参考：SpringBoot——SpringBoot SPI原理

Dubbo SPI

如何使用

自定义SimonLeeDubbo接口，并加上@org.apache.dubbo.common.extension.SPI注解。

@org.apache.dubbo.common.extension.SPI
public interface SimonLeeDubbo {
}

自定义2个类SimonLeeDubboImpl1和SimonLeeDubboImpl2，实现SimonLeeDubbo接口

public class SimonLeeDubboImpl1 implements SimonLeeDubbo {
}

public class SimonLeeDubboImpl2 implements SimonLeeDubbo {
}

最后在resources的META-INF/services目录下定义个名为com.simonlee.dubbo.SimonLeeDubbo的文件，里面的内容为如下2行：

使用org.apache.dubbo.common.extension.ExtensionLoader.getExtension()加载上述2个SimonLeeDubbo接口的实现类。

public static void main(String[] args) {
	org.apache.dubbo.rpc.model.ApplicationModel applicationModel = org.apache.dubbo.rpc.model.ApplicationModel.defaultModel();
	// 通过Protocol获取指定像ServiceLoader一样的加载器
	org.apache.dubbo.common.extension.ExtensionLoader<SimonLeeDubbo> dubbos = applicationModel.getExtensionLoader(SimonLeeDubbo.class);

	// 通过指定的名称从加载器中获取指定的实现类
	SimonLeeDubbo dubbo11 = dubbos.getExtension("simonLeeDubboImpl1");
	System.out.println(dubbo11);

	// 再次通过指定的名称从加载器中获取指定的实现类，看看打印的引用是否创建了新对象
	SimonLeeDubbo dubbo12 = dubbos.getExtension("simonLeeDubboImpl1");
	System.out.println(dubbo12);

	SimonLeeDubbo dubbo2 = dubbos.getExtension("simonLeeDubboImpl2");
	System.out.println(dubbo2);
}

看一下输出结果，2次拿到的simonLeeDubboImpl1是同个引用，说明用到了缓存。

实现原理

// 获取该接口的所有扩展点集合
private Map<String, Class<?>> getExtensionClasses() {
    // 先从缓存里面取，看看有没有该接口的扩展点集合
    Map<String, Class<?>> classes = cachedClasses.get();
    // 如果没有任何缓存的话
    if (classes == null) {
        // 则采用双检索的形式保证线程安全粒度去读取磁盘文件加载扩展点
        synchronized (cachedClasses) {
            classes = cachedClasses.get();
            if (classes == null) {
                // 真正加载扩展点的逻辑
                classes = loadExtensionClasses();
                // 如果加载到的话，则放入到缓存中，下一次就可以直接从缓存中取了
                cachedClasses.set(classes);
            }
        }
    }
    return classes;
}
                  ↓
// 正在加载扩展点的逻辑
private Map<String, Class<?>> loadExtensionClasses() {
    // 此处省略若干行代码...
    Map<String, Class<?>> extensionClasses = new HashMap<>();
    for (LoadingStrategy strategy : strategies) {
        // 按照每种磁盘路径的策略去加载磁盘文件
        loadDirectory(extensionClasses, strategy, type.getName());
        // compatible with old ExtensionFactory
        if (this.type == ExtensionInjector.class) {
            loadDirectory(extensionClasses, strategy, ExtensionFactory.class.getName());
        }
    }
    return extensionClasses;
}
                  ↓
// 查看加载磁盘的策略有哪些，发现是一个方法
private static volatile LoadingStrategy[] strategies = loadLoadingStrategies();
                  ↓
// 继续查看该方法的逻辑，结果发现该方法加载了 LoadingStrategy 接口的所有实现类
private static LoadingStrategy[] loadLoadingStrategies() {
    // java.util.ServiceLoader.load()
    return stream(load(LoadingStrategy.class).spliterator(), false)
        .sorted()
        .toArray(LoadingStrategy[]::new);
}
                  ↓
// LoadingStrategy 实现类之一，重点关注 directory 方法
public class DubboInternalLoadingStrategy implements LoadingStrategy {
    @Override
    public String directory() {
        return "META-INF/dubbo/internal/";
    }
    // 此处省略若干行代码...
}
                  ↓
// LoadingStrategy 实现类之一，重点关注 directory 方法
public class DubboLoadingStrategy implements LoadingStrategy {
    @Override
    public String directory() {
        return "META-INF/dubbo/";
    }
    // 此处省略若干行代码...
}
                  ↓
// LoadingStrategy 实现类之一，重点关注 directory 方法
public class ServicesLoadingStrategy implements LoadingStrategy {
    @Override
    public String directory() {
        return "META-INF/services/";
    }
    // 此处省略若干行代码...
}

private void loadDirectory(Map<String, Class<?>> extensionClasses, LoadingStrategy strategy, String type) {
	loadDirectory(extensionClasses, strategy.directory(), type, strategy.preferExtensionClassLoader(), strategy.overridden(),
			strategy.includedPackages(), strategy.excludedPackages(), strategy.onlyExtensionClassLoaderPackages());
	String oldType = type.replace("org.apache", "com.alibaba");
	loadDirectory(extensionClasses, strategy.directory(), oldType, strategy.preferExtensionClassLoader(), strategy.overridden(),
		strategy.includedPackagesInCompatibleType(), strategy.excludedPackages(), strategy.onlyExtensionClassLoaderPackages());
}
                  ↓
private void loadDirectory(Map<String, Class<?>> extensionClasses, String dir, String type, boolean extensionLoaderClassLoaderFirst,
						   boolean overridden, String[] includedPackages, String[] excludedPackages, String[] onlyExtensionClassLoaderPackages) {
	// dir = META-INF/services/
	// type = com.simonlee.dubbo.SimonLeeDubbo
	// fileName = META-INF/services/com.simonlee.dubbo.SimonLeeDubbo
	String fileName = dir + type;
	try {
		List<ClassLoader> classLoadersToLoad = new LinkedList<>();

		// try to load from ExtensionLoader's ClassLoader first
		if (extensionLoaderClassLoaderFirst) {
			ClassLoader extensionLoaderClassLoader = ExtensionLoader.class.getClassLoader();
			if (ClassLoader.getSystemClassLoader() != extensionLoaderClassLoader) {
				classLoadersToLoad.add(extensionLoaderClassLoader);
			}
		}

		// load from scope model
		Set<ClassLoader> classLoaders = scopeModel.getClassLoaders();

		if (CollectionUtils.isEmpty(classLoaders)) {
			// java.lang.ClassLoader.getSystemResources()
			Enumeration<java.net.URL> resources = ClassLoader.getSystemResources(fileName);
			if (resources != null) {
				while (resources.hasMoreElements()) {
					loadResource(extensionClasses, null, resources.nextElement(), overridden, includedPackages, excludedPackages,
						onlyExtensionClassLoaderPackages);
				}
			}
		} else {
			classLoadersToLoad.addAll(classLoaders);
		}

		Map<ClassLoader, Set<java.net.URL>> resources = ClassLoaderResourceLoader.loadResources(fileName, classLoadersToLoad);
		resources.forEach(((classLoader, urls) -> loadFromClass(
			extensionClasses, overridden, urls, classLoader, includedPackages, excludedPackages, onlyExtensionClassLoaderPackages)));
	} catch (Throwable t) {
		logger.error("Exception occurred when loading extension class (interface: " + type + ", description file: " + fileName + ").", t);
	}
}
                  ↓
private void loadFromClass(Map<String, Class<?>> extensionClasses, boolean overridden, Set<java.net.URL> urls, ClassLoader classLoader,
						   String[] includedPackages, String[] excludedPackages, String[] onlyExtensionClassLoaderPackages) {
	if (CollectionUtils.isNotEmpty(urls)) {
		for (java.net.URL url : urls) {
			loadResource(extensionClasses, classLoader, url, overridden, includedPackages, excludedPackages, onlyExtensionClassLoaderPackages);
		}
	}
}
                  ↓
private void loadResource(Map<String, Class<?>> extensionClasses, ClassLoader classLoader, java.net.URL resourceURL, boolean overridden,
						  String[] includedPackages, String[] excludedPackages, String[] onlyExtensionClassLoaderPackages) {
	try {
		try (BufferedReader reader = new BufferedReader(new InputStreamReader(resourceURL.openStream(), StandardCharsets.UTF_8))) {
			String line;
			String clazz;
			// 遍历每1行，每1行即为1个SimonLeeDubbo接口的具体实现类
			while ((line = reader.readLine()) != null) {
				final int ci = line.indexOf('#');
				if (ci >= 0) {
					line = line.substring(0, ci);
				}
				line = line.trim();
				if (line.length() > 0) {
					try {
						String name = null;
						int i = line.indexOf('=');
						if (i > 0) {
							name = line.substring(0, i).trim();
							clazz = line.substring(i + 1).trim();
						} else {
							clazz = line;
						}
						if (StringUtils.isNotEmpty(clazz)
							&& !isExcluded(clazz, excludedPackages)
							&& isIncluded(clazz, includedPackages)
							&& !isExcludedByClassLoader(clazz, classLoader, onlyExtensionClassLoaderPackages)) {
							// java.lang.Class.forName()，反射机制来实例化对象
							loadClass(extensionClasses, resourceURL, Class.forName(clazz, true, classLoader), name, overridden);
						}
					} catch (Throwable t) {
						IllegalStateException e = new IllegalStateException("Failed to load extension class (interface: " + type +
							", class line: " + line + ") in " + resourceURL + ", cause: " + t.getMessage(), t);
						exceptions.put(line, e);
					}
				}
			}
		}
	} catch (Throwable t) {
		logger.error("Exception occurred when loading extension class (interface: " + type + ", class file: " + resourceURL + ") in " + resourceURL, t);
	}
}

简单跟踪代码后，发现原来我们可以在三个路径下添加SPI机制的文件，分别为：

• META-INF/dubbo/internal/
• META-INF/dubbo/
• META-INF/services/

真相也清楚了，Dubbo框架会从这3个资源目录下去加载SPI机制的文件，只不过从路径的名称上可以看出，META-INF/dubbo/internal/存放的是Dubbo内置的一些扩展点，META-INF/services/存放的是Dubbo自身的一些业务逻辑所需要的一些扩展点，而META-INF/dubbo/存放的是上层业务系统自身的一些定制Dubbo的相关扩展点。

作者：曼特宁