详解java实践SPI机制及浅析源码

详解java实践SPI机制及浅析源码

1.概念

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

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

SPI机制：

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

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

使用场景：

1.数据库驱动加载：面对不同厂商的数据库，JDBC需要加载不同类型的数据库驱动；

2.日志接口实现：SLF4J加载不同日志实现类；

3.溪源在实际开发中也使用了SPI机制：面对不同仪器平台的结果文件上传需要解析具体的结果，文件不同，解析逻辑不同，因此采用SPI机制能够解耦和降低维护成本；

SPI机制使用约定：

从上面的图中，我们可以清晰的知道SPI的三部分：接口+实现类+配置文件；因此，项目中若要利用SPI机制，则需要遵循以下约定：

当服务提供者提供了接口的一种具体实现后，在jar包的META-INF/services目录下创建一个以“接口全限定名”为命名的文件，内容为实现类的全限定名。

主程序通过java.util.ServiceLoder动态装载实现模块，它通过扫描META-INF/services目录下的配置文件找到实现类的全限定名，把类加载到JVM；

注意：除SPI，我还发布了最新Java架构项目实战教程+大厂面试题库， 点击此处免费获取，小白勿进！

2.实践

整体包结构如图：

新建标准化接口：

public interfacehttp:// SayService {

void say(String word);

}

建立两个实现类

@Service

public class ASayServiceImpl implements SayService {

@Override

public void say(String word) {

System.out.println(word + " A say: I am a boy");

}

}

@Service

public class BSayServiceImpl implements SayService {

@Override

public 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 services = ServiceLoader.load(SayService.class);

@Test

public 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类型，用于缓存加载成功的类)

lookupIterator(实现迭代器功能)

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

读取META-INF/services/下的配置文件，获得所有能被实例化的类的名称，值得注意的是，ServiceLoader可以跨越jar包获取META-INF下的配置文件；

通过反射方法Class.forName()加载类对象，并用instance()方法将类实例化。

把实例化后的类缓存到providers对象中，(LinkedHashMap类型） 然后返回实例对象。

public final class ServiceLoader

implements Iterable

{

// 加载具体实现类信息的前缀

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

// 需要加载的接口

// The class or interface representing the service being loaded

private final Class service;

// 用于加载的类加载器

// The class loader used to locate, load, and instantiate providers

private final ClassLoader loader;

// 创建ServiceLoader时采用的访问控制上下文

// The access control context taken when the ServiceLoader is created

private final AccessControlContext acc;

// 用于缓存已经加载的接口实现类，其中key为实现类的完整类名

// Cached providers, in instantiation order

private LinkedHashMap providers = new LinkedHashMap<>();

// 用于延迟加载接口的实现类

// The current lazy-lookup iterator

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

}

// 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 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 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 inner class implementing fully-lazy provider lookup

//

private class LazyIterator

implements Iterator

{

Class service;

ClassLoader loader;

// 加载资源的URL集合

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 {

// 资源名称，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();

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 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 loader)

{

// 返回ServiceLoader的实例

return new ServiceLoader<>(service, loader);

}

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() + "]";

}

}

4.总结

SPI机制在实际开发中使用得场景也有很多。特别是统一标准的不同厂商实现，溪源也正是利用SPI机制(但略做改进，避免过多加载资源浪费)实现不同技术平台的结果文件解析需求。

优点

使用Java SPI机制的优势是实现解耦，使得第三方服务模块的装配控制的逻辑与调用者的业务代码分离，而不是耦合在一起。应用程序可以根据实际业务情况启用框架扩展或替换框架组件。

缺点

虽然ServiceLoader也算是使用的延迟加载，但是基本只能通过遍历全部获取，也就是接口的实现类全部加载并实例化一遍。如果你并不想用某些实现类，它也被加载并实例化了，这就造成了浪费。

源码传送门：SPI Service

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