<code>ServiceLoader<LandingOnTheMoon> loader = ServiceLoader.load(LandingOnTheMoon.class);

看下这个方法的源码：

public static <S> ServiceLoader<S> load(Class<S> service) { -- -->

ClassLoader cl = Thread.currentThread().getContextClassLoader();

return ServiceLoader.load(service, cl);

}

可以看到这个方法 只是获取了当前线程的上下文类加载器 然后又调用了一个load的重载方法

public static <S> ServiceLoader<S> load(Class<S> service,

ClassLoader loader)

{

return new ServiceLoader<>(service, loader);

}

在重载的load方法中又调用了ServiceLoader的私有构造器

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;

reload();

}

然后调用 reload();方法

public void reload() {

providers.clear();

lookupIterator = new LazyIterator(service, loader);

}

reload();方法里面 调用了 new LazyIterator(service, loader);

具体的类加载行为就是在LazyIterator内部类中完成的。

这里的 lookupIterator = new LazyIterator(service, loader); 创建LazyIterator 懒加载迭代器对象，并没有马上去加载SPI的具体服务。

当我们调用 for (LandingOnTheMoon landingOnTheMoon : loader) {…} 循环时，会触发迭代器，在ServiceLoader中，迭代器是由Iterable接口的iterator()方法提供的。当第一次调用iterator()时，如果之前没有创建过迭代器，它会创建一个新的LazyIterator实例。

对应下面的源码：

// lookupIterator 在 调用reload 方法时 创建过了

private LazyIterator lookupIterator;

// 存储已经加载过的服务提供者实例 在 调用reload 方法时 调用了providers.clear(); 清空了这个集合

private LinkedHashMap<String,S> providers = new LinkedHashMap<>();

public Iterator<S> iterator() {

return new Iterator<S>() {

// 第一次调用时 providers 是空集合 会调用 lookupIterator 也就是 LazyIterator 的实例

Iterator<Map.Entry<String,S>> knownProviders

= providers.entrySet().iterator();

public boolean hasNext() {

if (knownProviders.hasNext())

return true;

return lookupIterator.hasNext();

}

public S next() {

if (knownProviders.hasNext())

return knownProviders.next().getValue();

return lookupIterator.next();

}

public void remove() {

throw new UnsupportedOperationException();

}

};

}

下面看 LazyIterator 的实现 具体的类加载就在这里：

LazyIterator 的 hasNext 和 next方法 中判断了 acc 是否是null

其中 acc = (System.getSecurityManager() != null) ? AccessController.getContext() : null; 这段代码是在 ServiceLoader初始化的时候执行的

主要用于判断 当前Java运行环境中是否存在安全管理器（SecurityManager），默认情况下不会配置，如果配置了SecurityManager，某些敏感操作（比如文件访问、网络连接等）可能会受到安全策略的限制或需要相应的权限检查。

这个不重要，我们还是看具体的方法 hasNextService 和 nextService方法。

public boolean hasNext() {

if (acc == null) {

return hasNextService();

} else {

PrivilegedAction<Boolean> action = new PrivilegedAction<Boolean>() {

public Boolean run() { return hasNextService(); }

};

return AccessController.doPrivileged(action, acc);

}

}

public S next() {

if (acc == null) {

return nextService();

} else {

PrivilegedAction<S> action = new PrivilegedAction<S>() {

public S run() { return nextService(); }

};

return AccessController.doPrivileged(action, acc);

}

}

LazyIterator 的 hasNextService 和 nextService方法

终于到了加载具体服务的地方了。

// 迭代器

Iterator<String> pending = null;

private boolean hasNextService() {

if (nextName != null) {

return true;

}

if (configs == null) {

try {

// 这里获取 SPI配置文件的文件名 包含 META-INF/services/

String fullName = PREFIX + service.getName();

// 获取配置

if (loader == null)

configs = ClassLoader.getSystemResources(fullName);

else

configs = loader.getResources(fullName);

} catch (IOException x) {

fail(service, "Error locating configuration files", x);

}

}

// 迭代器如果为空 或者没有值

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();

// nextName 在hasNextService中已经被赋值了

String cn = nextName;

nextName = null;

Class<?> c = null;

try {

// 关键点终于来了 最终还是利用Java的反射机制 完成类的加载

c = Class.forName(cn, false, loader);

} catch (ClassNotFoundException x) {

fail(service,

"Provider " + cn + " not found");

}

// 判断下 加载的 Class 的类型 是否实现了 给定的 SPI接口 拿上面NASA登月的例子看，这里的 service 就是 LandingOnTheMoon.class

if (!service.isAssignableFrom(c)) {

fail(service,

"Provider " + cn + " not a subtype");

}

try {

// 通过反射实例化 SPI的实现类 并且转换成 SPI接口类型

S p = service.cast(c.newInstance());

// 保存到 LinkedHashMap<String,S> providers 缓存中

providers.put(cn, p);

return p;

} catch (Throwable x) {

fail(service,

"Provider " + cn + " could not be instantiated",

x);

}

throw new Error(); // This cannot happen

}

看 具体的parse 方法(解析服务实现者提供的配置文件)

private Iterator<String> parse(Class<?> service, URL u)

throws ServiceConfigurationError

{

InputStream in = null;

BufferedReader r = null;

// 保存解析配置文件内的 全限定类名

ArrayList<String> names = new ArrayList<>();

try {

in = u.openStream();

r = new BufferedReader(new InputStreamReader(in, "utf-8"));

int lc = 1;

// 一行一行的读取配置信息 并将每行解析出的全限定类名 保存到 names

// parseLine 方法不用看了 就是解析字符串的

while ((lc = parseLine(service, u, r, lc, names)) >= 0);

} catch (IOException x) {

fail(service, "Error reading configuration file", x);

} finally {

try {

if (r != null) r.close();

if (in != null) in.close();

} catch (IOException y) {

fail(service, "Error closing configuration file", y);

}

}

// 返回 拥有所有实现SPI接口的服务提供者全限定类名集合的迭代器

return names.iterator();

}

绕了半天 通过源码发现 最终类的加载还是通过 Java反射机制实现的。

那了解了ServiceLoader的具体实现之后，我们也可以实现一个自己的 服务加载器。

ServiceLoader只不过在实现了核心的SPI服务加载功能的基础上增加了一些额外的功能，比如通过LazyIterator 实现延迟加载，

可以调用reload() 在应用运行时实现服务的动态加载(不用重启应用就能加载服务)，访问控制(比如判断 当前Java运行环境中是否存在安全管理器)，还有按照加载顺序保存已加载的服务等等。不过ServiceLoader也是线程不安全的这点需要注意。

4、实现自己的ServiceLoader

我们实现一个最简单的ServiceLoader只考虑加载服务的功能，其他的安全、性能之类的都不考虑。

我们也仿照ServiceLoader类的结构，和SPI配置类规定的路径来实现。

package com.nasa;

import java.io.BufferedReader;

import java.io.InputStream;

import java.io.InputStreamReader;

import java.net.URL;

import java.util.*;

public class MySimpleServiceLoader<T> {

// 直接copy ServiceLoader的规则

private static final String PREFIX = "META-INF/services/";

// 定义的SPI接口

private final Class<T> service;

// 类加载器

private final ClassLoader loader;

// 保存已加载的服务实例

private final LinkedHashMap<String, T> providers = new LinkedHashMap<>();

// 构造方法T

private MySimpleServiceLoader(Class<T> svc, ClassLoader cl) {

service = Objects.requireNonNull(svc, "Service interface cannot be null");

loader = (cl == null) ? ClassLoader.getSystemClassLoader() : cl;

// 加载服务

realLoad();

}

public static <T> MySimpleServiceLoader<T> load(Class<T> service) {

ClassLoader contextClassLoader = Thread.currentThread().getContextClassLoader();

return new MySimpleServiceLoader<>(service, contextClassLoader);

}

private void realLoad() {

String fullName = PREFIX + service.getName();

try {

// 获取配置文件

Enumeration<URL> resources = loader.getResources(fullName);

// 读取配置文件

while (resources.hasMoreElements()) {

URL url = resources.nextElement();

InputStream inputStream = url.openStream();

BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream, "utf-8"));

// 我们就不做解析错误之类的逻辑了 默认给的配置文件都是对的

String name = reader.readLine();

// 通过反射创建对象

Class<?> aClass = Class.forName(name, false, loader);

// 判断 服务实现类是否实现了 给定的SPI接口

if (service.isAssignableFrom(aClass)) {

T cast = service.cast(aClass.newInstance());

providers.put(name, cast);

}

}

} catch (Exception e) {

System.out.println("出现异常！");

e.printStackTrace();

}

}

// 返回加载好的 服务实现

public LinkedHashMap<String, T> getProviders() {

return providers;

}

}

使用自定义的服务加载器 MySimpleServiceLoader

package com.nasa;

import java.util.ArrayList;

import java.util.LinkedHashMap;

import java.util.List;

/**

* 加载具体的服务实现

* */

public class LandingOnTheMoonLoader {

private static volatile LandingOnTheMoonLoader LOADER;

private final LandingOnTheMoon landingOnTheMoon;

private final List<LandingOnTheMoon> landingOnTheMoons = new ArrayList<>();

/**

* 加载服务

* */

private LandingOnTheMoonLoader() {

// 通过自定义的服务加载器 去加载服务实现

MySimpleServiceLoader<LandingOnTheMoon> mySimpleServiceLoader = MySimpleServiceLoader.load(LandingOnTheMoon.class);

LinkedHashMap<String, LandingOnTheMoon> providers = mySimpleServiceLoader.getProviders();

providers.forEach((k,v)->{

System.out.println(k);

landingOnTheMoons.add(v);

});

if (!landingOnTheMoons.isEmpty()) {

// 取第一个

landingOnTheMoon = landingOnTheMoons.get(0);

} else {

landingOnTheMoon = null;

}

}

/**

* LandingOnTheMoonLoader 单例加载

* */

public static LandingOnTheMoonLoader getLOADER() {

if (LOADER == null) {

synchronized (LandingOnTheMoonLoader.class) {

if (LOADER == null) {

LOADER = new LandingOnTheMoonLoader();

}

}

}

return LOADER;

}

public void land(){

if(landingOnTheMoons.isEmpty()){

System.out.println("LandingOnTheMoon服务未加载！");

}else {

LandingOnTheMoon landingOnTheMoon = landingOnTheMoons.get(0);

landingOnTheMoon.land();

}

}

}

测试：

public static void main(String[] args) {

LandingOnTheMoonLoader service = LandingOnTheMoonLoader.getLOADER();

service.land();

}

使用SpaceX的实现，结果如下：

com.spacex.SpaceXLand

SpaceX landing on the moon with StarShip~

5、Java中还有哪些SPI实现？

1、JDBC (Java Database Connectivity): JDBC驱动的加载就是SPI的一个经典应用。各个数据库厂商提供自己的JDBC驱动实现，应用程序无需直接引用具体驱动的实现类，只需将驱动JAR包放入类路径，Java SPI机制会自动发现并加载合适的驱动。

2、日志框架: 如SLF4J (Simple Logging Facade for Java) 和Logback、Log4j等，它们利用SPI机制来发现和加载具体的日志实现。用户可以根据需要选择或更换日志实现，而无需修改应用程序代码。

3、Spring框架: 虽然Spring框架本身更倾向于使用其自身的bean工厂和依赖注入机制来管理组件和服务，但Spring也支持SPI机制，特别是在某些扩展点和与第三方库集成时。

4、Dubbo: Apache Dubbo是一个高性能的RPC框架，它大量使用SPI机制来实现其插件体系，允许用户轻松替换或扩展序列化、负载均衡、集群容错等核心组件。

5、JNDI (Java Naming and Directory Interface): JNDI服务提供者也是通过SPI机制注册和发现的，允许应用程序访问不同的命名和目录服务。

6、JAX-WS (Java API for XML Web Services) 和 JAX-RS (Java API for RESTful Web Services): 这些Java Web服务技术框架使用SPI来发现和加载实现特定功能的服务提供者，比如SOAP绑定和HTTP连接器。

7、JavaBeans Activation Framework (JAF): 用于处理MIME类型的邮件附件等，通过SPI来发现数据处理器。

8、JavaMail: 用于发送和接收电子邮件的API，利用SPI来加载传输协议和其他服务提供者。

…