前言

前面在深入策略模式系列中，我们简单介绍了策略模式的原理，以及策略模式在jdk线程池中的应用，这里来和大家学习下策略模式在jdk SPI的应用，这里结合SPI的源码来一起学习下。

SPI简介

SPI全称Service Provider Interface，是Java提供的一套用来被第三方实现或者扩展的API，它可以用来启用框架扩展和替换组件。常见的 SPI 有 JDBC、日志门面接口、Spring、SpringBoot相关starter组件、Dubbo、JNDI等。 实际上Java SPI是"面向接口的编程＋策略模式＋配置文件"组合实现的动态加载机制，在JDK中提供了工具类："java.util.ServiceLoader"来实现服务查找。我们为了实现各功能模块之间解耦，一般都是基于接口编程，模块之间不对实现类进行硬编码。一旦代码里涉及具体的实现类的耦合，就违反了可插拔、闭开等原则，如果我们希望实现在模块装配的时候能够不在程序硬编码指定，那就需要一种服务发现的机制。Java SPI就是提供这样的一个机制：为某个接口寻找服务实现的机制。将装配的控制权移到程序之外，在模块化设计中这个机制尤其重要。所以SPI的核心思想就是解耦。

SPI规范

在工程的META-INF/services/目录下，以接口的全限定名作为文件名，文件内容为实现接口的服务类；使用ServiceLoader动态加载META-INF/services下的实现类；接口的实现类需含无参构造函数；（因为类默认包含无参构造函数，如果我们没有重载构造函数所以此处可忽略）

ServiceLoader源码解析 

首先看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; ...... }

 load方中初始化了ServiceLoader对象，通过ServiceLoader构造器来实例化了内部类LazyIterator

public static <S> ServiceLoader<S> load(Class<S> service,ClassLoader loader){ //load方中初始化了ServiceLoader对象 return new ServiceLoader<>(service, loader); } public final class ServiceLoader<S> implements Iterable<S> // ServiceLoader构造器 private ServiceLoader(Class<S> svc, ClassLoader cl) { //要加载的接口 service = Objects.requireNonNull(svc, "Service interface cannot be null"); //(ClassLoader类型，类加载器) loader = (cl == null) ? ClassLoader.getSystemClassLoader() : cl; //(AccessControlContext类型，访问控制器) acc = (System.getSecurityManager() != null) ? AccessController.getContext() : null; //(LinkedHashMap<String,S>类型，用于缓存加载成功的类) providers.clear();//先清空 //实例化内部类(实现迭代器功能) LazyIterator lookupIterator = new LazyIterator(service, loader); } }

LazyIterator类如下

private class LazyIterator implements Iterator<S>{ Class<S> service; ClassLoader loader; Enumeration<URL> configs = null; Iterator<String> pending = null; String nextName = null; private boolean hasNextService() { //第二次调用的时候，已经解析完成了，直接返回 if (nextName != null) { return true; } if (configs == null) { try { //META-INF/services/ 加上接口的全限定类名，就是文件服务类的文件 //META-INF/services/com.viewscenes.netsupervisor.spi.SPIService String fullName = PREFIX + service.getName(); if (loader == null) configs = ClassLoader.getSystemResources(fullName); else configs = loader.getResources(fullName);//将文件路径转成URL对象 } catch (IOException x) { fail(service, "Error locating configuration files", x); } } while ((pending == null) || !pending.hasNext()) { if (!configs.hasMoreElements()) { return false; } //解析URL文件对象，读取内容，最后返回 pending = parse(service, configs.nextElement()); } //拿到第一个实现类的类名 nextName = pending.next(); return true; }

可以看到上面通过pending.next()拿到实现类的类名

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); } } private S nextService() { if (!hasNextService()) throw new NoSuchElementException(); String cn = nextName; nextName = null; Class<?> c = null; try { //终究还是通过class.forName然后再newInstance()完成实例化的 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.put(cn, p); return p; } catch (Throwable x) { fail(service, "Provider " + cn + " could not be instantiated", x); } throw new Error(); // This cannot happen }

实例化完成之后， 把实例化后的类缓存到providers对象中，(LinkedHashMap<String,S>类型）然后返回实例对象。