java实践SPI机制及浅析源码

2023-09-16 阅读 22 评论 0

摘要：1.概念正式步入今天的核心内容之前，溪源先给大家介绍一下关于SPI机制的相关概念，最后会提供实践源代码。 SPI即Service Provider Interface，属于JDK内置的一种动态的服务提供发现机制，可以理解为运行时动态加载接口的实现类。更甚至，大家

1.概念

正式步入今天的核心内容之前，溪源先给大家介绍一下关于SPI机制的相关概念，最后会提供实践源代码。

SPI即Service Provider Interface，属于JDK内置的一种动态的服务提供发现机制，可以理解为运行时动态加载接口的实现类。更甚至，大家可以将SPI机制与设计模式中的策略模式建立联系。

SPI机制：

从上图中理解SPI机制：标准化接口+策略模式+配置文件；

SPI机制核心思想：系统设计的各个抽象，往往有很多不同的实现方案，在面向的对象的设计里，一般推荐模块之间基于接口编程，模块之间不对实现类进行硬编码。一旦代码里涉及具体的实现类，就违反了可拔插的原则，如果需要替换一种实现，就需要修改代码。为了实现在模块装配的时候能不在程序里动态指明，这就需要一种服务发现机制

使用场景：
1. 数据库驱动加载：面对不同厂商的数据库，JDBC需要加载不同类型的数据库驱动；
2. 日志接口实现：SLF4J加载不同日志实现类；
3. 溪源在实际开发中也使用了SPI机制：面对不同仪器平台的结果文件上传需要解析具体的结果，文件不同，解析逻辑不同，因此采用SPI机制能够解耦和降低维护成本；
java serializable原理。SPI机制使用约定：

从上面的图中，我们可以清晰的知道SPI的三部分：接口+实现类+配置文件；因此，项目中若要利用SPI机制，则需要遵循以下约定：
1. 当服务提供者提供了接口的一种具体实现后，在jar包的META-INF/services目录下创建一个以“接口全限定名”为命名的文件，内容为实现类的全限定名。
2. 主程序通过java.util.ServiceLoder动态装载实现模块，它通过扫描META-INF/services目录下的配置文件找到实现类的全限定名，把类加载到JVM；

2.实践

整体包结构如图：
在这里插入图片描述

新建标准化接口：

public interface SayService {void say(String word);
}

建立两个实现类

@Service
public class ASayServiceImpl implements SayService {@Overridepublic void say(String word) {System.out.println(word + " A say: I am a boy");}
}@Service
public class BSayServiceImpl implements SayService {@Overridepublic void say(String word) {System.out.println(word + " B say: I am a girl");}
}

新建META-INF/services目录和配置文件（以接口全限定名）

配置文件内容为实现类全限定名

com.qxy.spi.impl.ASayServiceImpl
com.qxy.spi.impl.BSayServiceImpl

单测

@SpringBootTest
@RunWith(SpringRunner.class)
public class SpiTest {static ServiceLoader<SayService> services = ServiceLoader.load(SayService.class);@Testpublic void test1() {for (SayService sayService : services) {sayService.say("Hello");}}}

结果

Hello A say: I am a boy
Hello B say: I am a girl

3.源码

源码主要加载流程如下：

应用程序调用ServiceLoader.load方法 ServiceLoader.load方法内先创建一个新的ServiceLoader，并实例化该类中的成员变量；

loader(ClassLoader类型，类加载器)
acc(AccessControlContext类型，访问控制器)
providers(LinkedHashMap<String,S>类型，用于缓存加载成功的类)
lookupIterator(实现迭代器功能)

应用程序通过迭代器接口获取对象实例 ServiceLoader先判断成员变量providers对象中(LinkedHashMap<String,S>类型)是否有缓存实例对象，如果有缓存，直接返回。如果没有缓存，执行类的装载。

读取META-INF/services/下的配置文件，获得所有能被实例化的类的名称，值得注意的是，ServiceLoader可以跨越jar包获取META-INF下的配置文件；
通过反射方法Class.forName()加载类对象，并用instance()方法将类实例化。
把实例化后的类缓存到providers对象中，(LinkedHashMap<String,S>类型）然后返回实例对象。

public final class ServiceLoader<S>implements Iterable<S>
{// 加载具体实现类信息的前缀private static final String PREFIX = "META-INF/services/";// 需要加载的接口// The class or interface representing the service being loadedprivate final Class<S> service;// 用于加载的类加载器// The class loader used to locate, load, and instantiate providersprivate final ClassLoader loader;// 创建ServiceLoader时采用的访问控制上下文// The access control context taken when the ServiceLoader is createdprivate final AccessControlContext acc;// 用于缓存已经加载的接口实现类，其中key为实现类的完整类名// Cached providers, in instantiation orderprivate LinkedHashMap<String,S> providers = new LinkedHashMap<>();// 用于延迟加载接口的实现类// The current lazy-lookup iteratorprivate LazyIterator lookupIterator;public void reload() {providers.clear();lookupIterator = new LazyIterator(service, loader);}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();}private static void fail(Class<?> service, String msg, Throwable cause)throws ServiceConfigurationError{throw new ServiceConfigurationError(service.getName() + ": " + msg,cause);}private static void fail(Class<?> service, String msg)throws ServiceConfigurationError{throw new ServiceConfigurationError(service.getName() + ": " + msg);}private static void fail(Class<?> service, URL u, int line, String msg)throws ServiceConfigurationError{fail(service, u + ":" + line + ": " + msg);}// Parse a single line from the given configuration file, adding the name// on the line to the names list.//具体解析资源文件中的每一行内容private int parseLine(Class<?> service, URL u, BufferedReader r, int lc,List<String> names)throws IOException, ServiceConfigurationError{String ln = r.readLine();if (ln == null) {//-1表示解析完成return -1;}// 如果存在'#'字符，截取第一个'#'字符串之前的内容，'#'字符之后的属于注释内容int ci = ln.indexOf('#');if (ci >= 0) ln = ln.substring(0, ci);ln = ln.trim();int n = ln.length();if (n != 0) {//不合法的标识：' '、'\t'if ((ln.indexOf(' ') >= 0) || (ln.indexOf('\t') >= 0))fail(service, u, lc, "Illegal configuration-file syntax");int cp = ln.codePointAt(0);//判断第一个 char 是否一个合法的 Java 起始标识符if (!Character.isJavaIdentifierStart(cp))fail(service, u, lc, "Illegal provider-class name: " + ln);//判断所有其他字符串是否属于合法的Java标识符for (int i = Character.charCount(cp); i < n; i += Character.charCount(cp)) {cp = ln.codePointAt(i);if (!Character.isJavaIdentifierPart(cp) && (cp != '.'))fail(service, u, lc, "Illegal provider-class name: " + ln);}//不存在则缓存if (!providers.containsKey(ln) && !names.contains(ln))names.add(ln);}return lc + 1;}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;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);}}return names.iterator();}// Private inner class implementing fully-lazy provider lookup//private class LazyIteratorimplements Iterator<S>{Class<S> service;ClassLoader loader;// 加载资源的URL集合Enumeration<URL> configs = null; // 需加载的实现类的全限定类名的集合Iterator<String> pending = null;// 下一个需要加载的实现类的全限定类名String nextName = null;private LazyIterator(Class<S> service, ClassLoader loader) {this.service = service;this.loader = loader;}private boolean hasNextService() {if (nextName != null) {return true;}if (configs == null) {try {// 资源名称，META-INF/services + 全限定名String fullName = PREFIX + service.getName();if (loader == null)configs = ClassLoader.getSystemResources(fullName);elseconfigs = 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();String cn = nextName;nextName = null;Class<?> c = null;try {//反射构造Class实例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());// 实例完成，添加缓存，Key：实现类全限定类名，Value：实现类实例providers.put(cn, p);return p;} catch (Throwable x) {fail(service,"Provider " + cn + " could not be instantiated",x);}throw new Error();          // This cannot happen}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);}}public void remove() {throw new UnsupportedOperationException();}}public Iterator<S> iterator() {return new Iterator<S>() {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();}};}public static <S> ServiceLoader<S> load(Class<S> service,ClassLoader loader){// 返回ServiceLoader的实例return new ServiceLoader<>(service, loader);}public static <S> ServiceLoader<S> loadInstalled(Class<S> service) {ClassLoader cl = ClassLoader.getSystemClassLoader();ClassLoader prev = null;while (cl != null) {prev = cl;cl = cl.getParent();}return ServiceLoader.load(service, prev);}public String toString() {return "java.util.ServiceLoader[" + service.getName() + "]";}}