JDK的SPI用法

1，创建com.test.Log接口，创建实现类com.test.impl.Log4j，com.test.impl.Logback

2，在 Classpath 下的 META-INF/services/ 目录里创建一个以服务接口命名的文件。比如com.test.Log

3，文件内容：

com.test.impl.Log4j com.test.impl.Logback

4，JDK的spi在查找扩展实现类的过程中，需要遍历 SPI 配置文件中定义的所有实现类，该过程中会将这些实现类全部实例化。

5，用法：

# 创建服务加载器 ServiceLoader<Log> serviceLoader = ServiceLoader.load(Log.class); Iterator<Log> iterator = serviceLoader.iterator(); while (iterator.hasNext()){ System.out.println(iterator.next()); }

jdk11下源码解析

1，创建服务加载器

ServiceLoader<Log> serviceLoader = ServiceLoader.load(Log.class);

2，执行serviceLoader.iterator();

public Iterator<S> iterator() { // create lookup iterator if needed if (lookupIterator1 == null) { lookupIterator1 = newLookupIterator(); } # 创建一个迭代器匿名实现类 return new Iterator<S>() { // record reload count final int expectedReloadCount = ServiceLoader.this.reloadCount; // index into the cached providers list int index; /** * Throws ConcurrentModificationException if the list of cached * providers has been cleared by reload. */ private void checkReloadCount() { if (ServiceLoader.this.reloadCount != expectedReloadCount) throw new ConcurrentModificationException(); } @Override public boolean hasNext() { checkReloadCount(); if (index < instantiatedProviders.size()) return true; return lookupIterator1.hasNext(); } @Override public S next() { checkReloadCount(); S next; if (index < instantiatedProviders.size()) { next = instantiatedProviders.get(index); } else { next = lookupIterator1.next().get(); instantiatedProviders.add(next); } index++; return next; } }; }

一 执行serviceLoader.iterator()->hasNext()->lookupIterator1.hasNext();

二 执行LazyClassPathLookupIterator#hasNext()->hasNextService();

->nextProviderClass()

1 Enumeration<URL> configs = loader.getResources(fullName); 加载资源

fullName="META-INF/services/com.study.utils.spi.demo.KeyGenerator"

2 遍历configs ，解析url 资源

pending = parse(configs.nextElement());

private Iterator<String> parse(URL u) { Set<String> names = new LinkedHashSet<>(); // preserve insertion order try { # 打开连接 URLConnection uc = u.openConnection(); uc.setUseCaches(false); try (InputStream in = uc.getInputStream(); BufferedReader r = new BufferedReader(new InputStreamReader(in, "utf-8"))) { int lc = 1; while ((lc = parseLine(u, r, lc, names)) >= 0); } } catch (IOException x) { fail(service, "Error accessing configuration file", x); } return names.iterator(); }

解析url 资源，读取每一行，放入Set集合。返回Set#iteator()

部分源码：

while ((pending == null) || !pending.hasNext()) { if (!configs.hasMoreElements()) { return null; } # 解析url 资源，读取每一行，放入Set集合。返回Set#iteator() pending = parse(configs.nextElement()); } String cn = pending.next(); try { # 得到 Class对象。 return Class.forName(cn, false, loader); } catch (ClassNotFoundException x) { fail(service, "Provider " + cn + " not found"); return null; }

也就是说：

执行LazyClassPathLookupIterator#hasNext()->hasNextService()->nextProviderClass()

得到了META-INF/services/目录下以com.test.Log为文件名，解析其内容得到了Class对象。

扩展

class1.isAssignableFrom(class2) 判定此 Class 对象所表示的类或接口与指定的 Class 参数所表示的类或接口是否相同，或是否是其超类或超接口。如果是则返回 true；否则返回 false。

hasNextService()部分源码

Class<?> clazz = nextProviderClass(); if (clazz == null) return false; if (clazz.getModule().isNamed()) { // ignore class if in named module continue; } if (service.isAssignableFrom(clazz)) { Class<? extends S> type = (Class<? extends S>) clazz; Constructor<? extends S> ctor = (Constructor<? extends S>)getConstructor(clazz); ProviderImpl<S> p = new ProviderImpl<S>(service, type, ctor, acc); nextProvider = (ProviderImpl<T>) p; } else { fail(service, clazz.getName() + " not a subtype"); }

将Class的构造器对象封装到Provider<T> nextProvider 对象中了。也就是说调用hasNext()方法，得到了nextProvider 对象。（相当于得到了Class的构造器对象）

调用next()方法

->LazyClassPathLookupIterator#next()

源码解析：next = lookupIterator1.next().get();

public S next() { checkReloadCount(); S next; if (index < instantiatedProviders.size()) { next = instantiatedProviders.get(index); } else { # 第一次遍历进入这里 next = lookupIterator1.next().get(); # 缓存对象 instantiatedProviders.add(next); } index++; return next; } # lookupIterator1.next()下 Provider<T> provider = nextProvider; if (provider != null) { nextProvider = null; return provider; } # lookupIterator1.next().get() # provider#get public S get() { if (factoryMethod != null) { return invokeFactoryMethod(); } else { # 创建对象 return newInstance(); } }

总结：

1，调用hasNext(） 会读配置文件内容，创建构造器对象，放入一个临时provider对象中

2，调用next()方法，会从临时provider对象中，取出构造器对象，创建配置文件内容中的对象实例。

3，ServiceLoader一旦load了某个接口，然后next() 取出了某个对象实例，那么就会缓存起来。缓存到instantiatedProviders对象中。

// The lazy-lookup iterator for iterator operations private Iterator<Provider<S>> lookupIterator1; // 缓存已经加载的对象。 private final List<S> instantiatedProviders = new ArrayList<>();

思路：读取classPath下配置文件中内容，反射生成类。根据不同的class对象，获取不同的类。