Java中的SPI机制案例分享（简述spi的编程步骤）

Java中的SPI机制案例分享（简述spi的编程步骤）

目录1 简单介绍2 SPI 案例3 SPI 的原理剖析

1 简单介绍

当我们封装了一套接口，其它项目想要调用我们的接口只需要引入我们写好的包，但是其它项目如果想要对我们的接口进行扩展，由于接口是被封装在依赖包中的，想要扩展并不容易，这时就需要依赖于java为我们提供的SPI机制。

SPI的全称是Service Provider http://Interface，服务提供者接口，而与之最接近的概念就是API，全称Application Programming Interface，应用程序编程接口。那么这两者主要的区别是什么呢？

API的调用方只能依赖使用提供方已有的实现，而SPI就是可定制化的API，调用方可以自定义实现替换API提供的默认实现。

SPI机制是非常重要的，尤其是对于框架来说，它可以用来启用框架扩展和替换组件，我们在读框架源码时也会看到大量的SPI的应用。

SPI的作用就是为这些被扩展的API寻找服务实现。

2 SPI 案例

创建一个工程，一个做SPI的服务提供者，一个做SPI服务引入扩展的测试，此案例构建最简单的Maven子父工程即可，在spi-test工程引入spi-provider的依赖。

spi-test添加依赖

org.example

spi-provider

1.0-SNAPSHOT

在spi-provider中，提供接口和一个默认的实现类

在资源文件中加上如下图文件，并在改文件中指定接口的默认实现类

spi-test中构建可执行的测试方法，直接执行，会拿到默认的实现

我们可以在spi-test中扩展，这个接口，如下图所示：

这时我们的扩展并不能生效，我们仍需要在资源文件下，为接口指定我们扩展的实现类，这时在运行上述测试方法即可得到我们扩展后的结果，这就是SPI机制。

3 SPI 的原理剖析

ServiceLoader这个类包含了SPI的核心原理，从开头指定的路径前缀，我们就能猜到为什么我们必须将文件放入这个路径下才会生效。

通过load方法，创建一个ServiceLoader的对象，进入其构造方法，进行reload， 会创建一个新的LazyIterator迭代器，LazyIterator是一个内部类，它负责扫描META-INF/services/下的配置文件，并parse所有接口的名字，然后通过全限定类名通过反射进行实现类的加载。

public final class ServiceLoader

implements Iterable

{

// 扫描路径前缀

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

// 被加载的类或者接口

private final Class service;

// 用于定位、加载和实例化需要加载类的类加载器

private final ClassLoader loader;

// 上下文对象

private final AccessControlContext acc;

// 按照实例化的顺序缓存已经实例化的类

private LinkedHashMap providers = new LinkedHashMap<>();

// 懒查找迭代器

private LazyIterator lookupIterator;

// 重新加载

public void reload() {

// 清理缓存

providers.clear();

// 新的懒查找迭代器

lookupIterator = new LazyIterator(service, loader);

}

// 构造方法

private ServiceLoader(Class 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);

}

private int parseLine(Class> service, URL u, BufferedReader r, int lc,

List names)

throws IOException, ServiceConfigurationError

{

String ln = r.readLine();

if (ln == null) {

return -1;

}

int ci = ln.indexOf('#');

if (ci >= 0) ln = ln.substring(0, ci);

ln = ln.trim();

int n = ln.length();

if (n != 0) {

if ((ln.indexOf(' ') >= 0) || (ln.indexOf('\t') >= 0))

fail(service, u, lc, "Illegal configuration-file syntax");

int cp = ln.codePointAt(0);

if (!Character.isJavaIdentifierStart(cp))

fail(service, u, lc, "Illegal provider-class name: " + ln);

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 parse(Class> service, URL u)

throws ServiceConfigurationError

{

InputStream in = null;

BufferedReader r = null;

ArrayList 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 class LazyIterator

implements Iterator

{

Class service;

ClassLoader loader;

Enumeration configs = null;

Iterator pending = null;

String nextName = null;

private LazyIterator(Class service, ClassLoader loader) {

this.service = service;

this.loader = loader;

}

private boolean hasNextService() {

if (nextName != null) {

return true;

}

if (configs == null) {

try {

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

String cn = nextName;

nextName = null;

Class> c = null;

try {

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

}

public boolean hasNext() {

if (acc == null) {

return hasNextService();

} else {

PrivilegedAction action = new PrivilegedAction() {

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

};

return AccessController.doPrivileged(action, acc);

}

}

public S next() {

if (acc == null) {

return nextService();

} else {

PrivilegedAction action = new PrivilegedAction() {

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

};

return AccessController.doPrivileged(action, acc);

}

}

public void remove() {

throw new UnsupportedOperationException();

}

}

public Iterator iterator() {

return new Iterator() {

Iterator> 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 ServiceLoader load(Class service) {

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

return ServiceLoader.load(service, cl);

}

public static ServiceLoader loadInstalled(Class 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() + "]";

}

}

从上面的源码中，我们不难发现ServiceLoader并没有额外的加锁机制，所以会存在并发问题，再就是获取对应的实现类不够灵活，需要使用迭代器的方式获取已知接口的所有具体实现类，所以每次都要加载和实例化所有的实现类，扩展如果依赖了其它的扩展，做不到自动注入和装配，扩展很难和其它框架集成。

也正是基于这种种原因，许多框架中不会去直接使用ServiceLoader这种原生的SPI机制而是会去基于这种思想进行一定的扩展，使其的功能更加强大，典型的案例就是dubbo的SPI，SpringBoot的SPI。

的这篇文章《SpringBoot借助spring.factories文件跨模块实例化Bean》就是讲SpringBoot中的SPI机制，感兴趣的同学可以阅读一下。

版权声明：本文内容由网络用户投稿，版权归原作者所有，本站不拥有其著作权，亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容，请联系我们jiasou666@gmail.com 处理，核实后本网站将在24小时内删除侵权内容。