SPI(Service Provider Interface) 是 JDK 内置的一种服务提供发现机制：可以用来启用框架扩展和替换组件，主要用于框架中开发。例如：Dubbo、Spring、Common-Logging，JDBC 等都是采用 SPI 机制，针对同一接口采用不同的实现提供给不同的用户，从而提高了框架的扩展性

1. Java SPI 实现

Java 内置的 SPI 通过 java.util.ServiceLoader 类解析 classPath 和 jar 包的 META-INF/services/ 目录下的以接口全限定名命名的文件，并加载该文件中指定的接口实现类，以此完成调用

1.1 案例

对于智能家居系统，只要是相同品牌下的产品，连上 wifi 就能够通过手机 app 控制了，非常方便。虽然产品不断更新换代，型号更新层出不穷，但是同种家电在 app 上操作起来，功能一般都是一样的。就拿空调来说，我们在 app 上操作起来一般也就三个主要功能：开关，选模式，调节温度。

假设：我现在在客厅、卧室、书房安装了 3 款不同型号的空调，并把它们都接入到了我 app 中，那么之后的操作都是相同的几个按键，简单粗暴。

问题：无论是开关还是调温，都是通过 app 去调用设备的接口罢了，那么如果不同型号的空调各写各的接口，后端 app 在开发的时候光对接接口都麻烦的要死

解决方法：我先定义一套接口规范，不管你以后什么型号的空调，都按我的规范来实现接口。以后只要我能发现你的设备，那么都可以按相同的方法来调用接口

①：定义接口

新建一个 maven 项目 aircondition-standard，定义一个接口：

public interface AirConditionService {// 获取型号String getType();// 开关void turnOnOff();// 调节温度void adjustTemperature(int temperature);// 模式变更void changeModel(int modelId);}

用 maven 把它打成 jar 包，供后续的服务实现使用（服务提供者在项目中就可以引入这个 jar 包）

mvn clean install

有了这套规范，就保证了产品后期不管怎么更新换代，都能接入到系统来

②：服务实现

现有两个类型的空调：挂式空调（HangingType）、立式空调（VerticalType）

挂式空调： 新建一个项目 aircondition-hanging-type，并引入上述 jar：

<dependency><groupId>com.zzc</groupId><artifactId>aircondition-standard</artifactId><version>0.0.1-SNAPSHOT</version>
</dependency>

创建服务类，并实现前面定义的接口：

public class HangingTypeAirConditionService implements AirConditionService {@Overridepublic String getType() {return "HangingType";}@Overridepublic void turnOnOff() {// TODOSystem.out.println("挂式空调开关");}@Overridepublic void adjustTemperature(int temperature) {// TODOSystem.out.println("挂式空调调节温度");}@Overridepublic void changeModel(int modelId) {// TODOSystem.out.println("挂式空调更换模式");}}

在项目的 resources 的目录下，创建 META-INF/services目录，然后以前面定义的接口名 com.zzc.airconditionstandard.service.AirConditionService 创建文件，并在文件中写入实现类的全限定名：

com.zzc.airconditionhangingtype.service.HangingTypeAirConditionService

如下图：

这样，一个服务方的简单实现就搞定了，用 maven 打成 jar 包，之后就可以提供给调用方使用了

同理，我们可以再创建一个立式空调的项目 aircondition-vertical-type

public class VerticalTypeAirConditionService implements AirConditionService {@Overridepublic String getType() {// TODOreturn "VerticalType";}@Overridepublic void turnOnOff() {// TODOSystem.out.println("立式空调开关");}@Overridepublic void adjustTemperature(int i) {// TODOSystem.out.println("立式空调调节温度");}@Overridepublic void changeModel(int i) {// TODOSystem.out.println("立式空调更换模式");}}

在项目的 resources 的目录下，创建 META-INF/services目录，然后以前面定义的接口名 com.zzc.airconditionstandard.service.AirConditionService 创建文件，并在文件中写入实现类的全限定名：

com.zzc.service.VerticalTypeAirConditionService

③：服务发现

现在两个服务提供方都实现了接口，下面关键的一步就是服务发现，这一步 Java 中的 spi 发现机制已经帮我们实现好了

创建一个新项目 aircondition-app，引入上面打好的两个 jar 包

<dependency><groupId>com.zzc</groupId><artifactId>aircondition-hanging-type</artifactId><version>0.0.1-SNAPSHOT</version>
</dependency>
<dependency><groupId>com.zzc</groupId><artifactId>aircondition-vertical-type</artifactId><version>0.0.1-SNAPSHOT</version>
</dependency>

按照上面的说法，虽然每个服务提供者对于接口都有不同的实现，但是作为调用者来说，它并不需要关心具体的实现类，我们要做的是通过接口来调用服务提供者实现的方法

下面，就是关键的服务发现环节，我们写一个方法，根据型号去调用对应空调的开关方法：

public class AirConditionApp {public static void main(String[] args) {new AirConditionApp().turnOn("VerticalType");}public void turnOn(String type){ServiceLoader<AirConditionService> load = ServiceLoader.load(AirConditionService.class);for (AirConditionService iAircondition : load) {System.out.println("检测到:"+iAircondition.getClass().getSimpleName());if (type.equals(iAircondition.getType())){iAircondition.turnOnOff();}}}
}

测试结果：

可以看到，测试过程中，通过定义的接口 AirConditionService 发现了两个实现类，并通过参数，调用了特定实现类的某个方法。整段代码中没有出现过具体的服务实现类，操作都是通过接口调用

1.3 JDBC 的 SPI 机制

深入理解 Java 中的 SPI 机制

2. Spring 的 SPI 机制

2.1 简介

Spring SPI 配置文件是一个固定的文件 - META-INF/spring.factories，功能上和 JDK 的类似，每个接口可以有多个扩展实现，使用起来非常简单：

//获取所有factories文件中配置的LoggingSystemFactory
List<LoggingSystemFactory>> factories = SpringFactoriesLoader.loadFactories(LoggingSystemFactory.class, classLoader);

Spring 也是支持 ClassPath 中存在多个 spring.factories 文件的，加载时会按照 classpath 的顺序依次加载这些 spring.factories 文件，添加到一个 ArrayList 中。由于没有别名，所以也没有去重的概念，有多少就添加多少

但由于 Spring 的 SPI 主要用在 Spring Boot 中，而 Spring Boot 中的 ClassLoader 会优先加载项目中的文件，而不是依赖包中的文件。所以如果在你的项目中定义个 spring.factories 文件，那么你项目中的文件会被第一个加载，得到的 Factories中，项目中 spring.factories 里配置的那个实现类也会排在第一个

如果我们要扩展某个接口的话，只需要在你的项目（spring boot）里新建一个 META-INF/spring.factories 文件，只添加你要的那个配置，不要完整的复制一遍 Spring Boot 的 spring.factories 文件然后修改

2.2 案例

①：定义接口：HelloService

public interface HelloService {void sayHello();
}

②：其实现类：HelloServiceImpl1

public class HelloServiceImpl1 implements HelloService {@Overridepublic void sayHello() {System.out.println("Hello World from HelloServiceImpl1!");}
}

HelloServiceImpl2

public class HelloServiceImpl2 implements HelloService {@Overridepublic void sayHello() {System.out.println("Hello World from HelloServiceImpl2!");}
}

③：spring.factories 文件：resources/META-INF 路径下

com.zzc.service.HelloService=\
com.zzc.service.impl.HelloServiceImpl1,\
com.zzc.service.impl.HelloServiceImpl2

idea当中如何创建*.factories文件

④：HelloServiceLoader

public class HelloServiceLoader {public static void main(String[] args) {// 使用Spring SPI机制动态加载HelloService实现类List<HelloService> loader = SpringFactoriesLoader.loadFactories(HelloService.class, Thread.currentThread().getContextClassLoader());// 遍历所有实现类并调用sayHello方法for (HelloService helloService : loader) {helloService.sayHello();}}
}

2.3 实现原理

查看 SpringFactoriesLoader 类源码：

public final class SpringFactoriesLoader {public static final String FACTORIES_RESOURCE_LOCATION = "META-INF/spring.factories";private static final Log logger = LogFactory.getLog(SpringFactoriesLoader.class);static final Map<ClassLoader, Map<String, List<String>>> cache = new ConcurrentReferenceHashMap();private SpringFactoriesLoader() {}// 加载并实例化给定类型的工厂实现public static <T> List<T> loadFactories(Class<T> factoryType, @Nullable ClassLoader classLoader) {List<String> factoryImplementationNames = loadFactoryNames(factoryType, classLoaderToUse);List<T> result = new ArrayList(factoryImplementationNames.size());Iterator var5 = factoryImplementationNames.iterator();while(var5.hasNext()) {String factoryImplementationName = (String)var5.next();result.add(instantiateFactory(factoryImplementationName, factoryType, classLoaderToUse));}return result;}public static List<String> loadFactoryNames(Class<?> factoryType, @Nullable ClassLoader classLoader) {String factoryTypeName = factoryType.getName();return (List)loadSpringFactories(classLoaderToUse).getOrDefault(factoryTypeName, Collections.emptyList());}// 获取所有 jar 包中 META-INF/spring.factories 文件路径，整合 factoryClass 类型的实现类名称，获取到实现类的全类名称后进行类的实例化操作private static Map<String, List<String>> loadSpringFactories(ClassLoader classLoader) {Map<String, List<String>> result = (Map)cache.get(classLoader);if (result != null) {return result;} else {HashMap result = new HashMap();try {Enumeration urls = classLoader.getResources("META-INF/spring.factories");while(urls.hasMoreElements()) {URL url = (URL)urls.nextElement();UrlResource resource = new UrlResource(url);Properties properties = PropertiesLoaderUtils.loadProperties(resource);Iterator var6 = properties.entrySet().iterator();while(var6.hasNext()) {Entry<?, ?> entry = (Entry)var6.next();String factoryTypeName = ((String)entry.getKey()).trim();String[] factoryImplementationNames = StringUtils.commaDelimitedListToStringArray((String)entry.getValue());String[] var10 = factoryImplementationNames;int var11 = factoryImplementationNames.length;for(int var12 = 0; var12 < var11; ++var12) {String factoryImplementationName = var10[var12];((List)result.computeIfAbsent(factoryTypeName, (key) -> {return new ArrayList();})).add(factoryImplementationName.trim());}}}result.replaceAll((factoryType, implementations) -> {return (List)implementations.stream().distinct().collect(Collectors.collectingAndThen(Collectors.toList(), Collections::unmodifiableList));});cache.put(classLoader, result);return result;} catch (IOException var14) {throw new IllegalArgumentException("Unable to load factories from location [META-INF/spring.factories]", var14);}}}// 实例化 Bean：通过反射来实现对应的初始化private static <T> T instantiateFactory(String factoryImplementationName, Class<T> factoryType, ClassLoader classLoader) {Class<?> factoryImplementationClass = ClassUtils.forName(factoryImplementationName, classLoader);return ReflectionUtils.accessibleConstructor(factoryImplementationClass, new Class[0]).newInstance();}
}

3. Common-Logging 的 SPI