Java的spi,java中spi有什么作用

　　00-1010 1两个SPI案例简介3 SPI原理分析

　　00-1010当我们封装一个windows sockets的时候，其他项目如果要调用我们的接口，只需要引入我们写的包就可以了。但是，如果其他项目想扩展我们的接口，由于接口封装在依赖包中，所以扩展起来并不容易。这时候就需要依靠Java提供的SPI机制了。

　　SPI的全称是Service Provider Interface，服务提供者接口,和它最接近的概念是API，全称应用编程接口，application programming interface。那么两者的主要区别是什么呢？

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

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

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

　　00-1010创建一个项目，一个SPI的服务提供者，一个SPI服务引入和扩展的测试。在这种情况下，构建最简单的Maven子-父项目，在spi-test项目中引入spi-provider的依赖关系。

　　spi-test添加依赖

　　依赖性依赖性groupIdorg.example/groupId artifactId SPI-提供程序/artifactId版本1.0-快照/版本/依赖性/依赖性在spi-provider中，提供接口和一个默认的实现类

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

　　在spi-test中构建一个可执行的测试方法，直接执行，就会得到默认的实现。

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

　　这个时候我们的延期就不能生效了。我们仍然需要为资源文件下的接口指定扩展的实现类。此时，我们可以通过运行上面的测试方法来获得我们的扩展的结果，这就是SPI机制。

　　公共类服务加载器实现iterables {//扫描路径前缀私有静态最终字符串前缀= meta-INF/services/；//加载的类或接口私有最终类服务；//私有final ClassLoader，用于定位、加载、实例化要加载的类；//上下文对象private final AccessControlContext ACC；//按照实例化的顺序缓存实例化的类privatelinkedhashmapstring，sp providers=newlinkdhashmap()；//懒惰

　　查找迭代器 private 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); } private int parseLine(Class<?> service, URL u, BufferedReader r, int lc, List<String> 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<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 class LazyIterator implements Iterator<S> { Class<S> service; ClassLoader loader; 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 { 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<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 cl = Thread.currentThread().getContextClassLoader(); return ServiceLoader.load(service, cl); } 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() + "]"; }}从上面的源码中，我们不难发现ServiceLoader并没有额外的加锁机制，所以会存在并发问题，再就是获取对应的实现类不够灵活，需要使用迭代器的方式获取已知接口的所有具体实现类，所以每次都要加载和实例化所有的实现类，扩展如果依赖了其它的扩展，做不到自动注入和装配，扩展很难和其它框架集成。

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

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

　　到此这篇关于Java中的SPI机制案例分享的文章就介绍到这了,更多相关Java中的SPI机制内容请搜索盛行IT以前的文章或继续浏览下面的相关文章希望大家以后多多支持盛行IT！

郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。

Java的spi,java中spi有什么作用

目录

相关文章阅读