阅读 12

详解Java—ServiceLoader之源码分析

ServiceLoader主要的功能是用来完成对SPI的provider的加载。

先看下它的成员:

public final class ServiceLoader<S>
     implements Iterable<S> {
	private static final String PREFIX = "META-INF/services/";
	// The class or interface representing the service being loaded
	private final Class<S> service;
	// The class loader used to locate, load, and instantiate providers
	private final ClassLoader loader;
	// The access control context taken when the ServiceLoader is created
	private final AccessControlContext acc;
	// Cached providers, in instantiation order
	private LinkedHashMap<String,S> providers = new LinkedHashMap<>();
	// The current lazy-lookup iterator
	private LazyIterator lookupIterator;
	......
}
复制代码

可以看到他首先是实现了Iterable接口,可以迭代。

  • PREFIX:指明了路径是在"META-INF/services/"下。
  • service:表示正在加载的服务的类或接口。
  • loader:使用的类加载器。
  • acc:创建ServiceLoader时获取的访问控制上下文。
  • providers:缓存的服务提供集合。
  • lookupIterator:是其内部使用的迭代器,用于类的懒加载,只有在迭代时加载。

其构造方法是一个private方法,不对外提供,在使用时我们需要调用其静态的load方法,由其自身产生ServiceLoader对象:

public static <S> ServiceLoader<S> load(Class<S> service) {
	ClassLoader cl = Thread.currentThread().getContextClassLoader();
	return ServiceLoader.load(service, cl);
}
public static <S> ServiceLoader<S> load(Class<S> service,
                                             ClassLoader loader) {
	return new ServiceLoader<>(service, loader);
}
复制代码

可以看到对load方法进行了重载,其中参数service是要加载的类;单参方法没有类加载器,使用的是当前线程的类加载器;最后调用的是双参的load方法;而双参的load方法也很简单,只是直接调用ServiceLoader的构造方法,实例化了一个对象。

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();
复制代码

可以看到其构造方法逻辑依旧很简单,首先是判断传入的svc(即传入的service)是否为空,若是为空直接报异常,否则给service 成员赋值:

public static <T> T requireNonNull(T obj, String message) {
	if (obj == null)
	             throw new NullPointerException(message);
	return obj;
}
复制代码

然后给进行cl的非空判断,给loader 成员赋值;接着给acc 成员赋值,其根据是否设置了安全管理器SecurityManager来赋值;最后调用reload方法。

public void reload() {
	providers.clear();
	lookupIterator = new LazyIterator(service, loader);
}
复制代码

可以看到reload方法是一个public方法,那么在每次调用reload时就需要将之前加载的清空掉,所以直接使用providers这个map的clear方法清空掉缓存;接着使用刚才赋值后的service和loader产生一个LazyIterator对象赋值给lookupIterator成员。

LazyIterator是ServiceLoader的内部类,其定义如下:

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;
	}
	......
}
复制代码

这里就可以看到ServiceLoader的实际加载过程就交给了LazyIterator来做,将ServiceLoader的service和loader成员分别赋值给了LazyIterator的service和loader成员。 configs是服务的URL枚举; pending是保存要加载的服务的名称集合; nextName是下一个要加载的服务名称;

ServiceLoader实现了Iterable接口,其实现的iterator方法如下:

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();
		}
	}
	;
}
复制代码

可以看到它是直接创建了一个Iterator对象返回;其knownProviders成员直接获取providers的entrySet集合的迭代器;在hasNext和next方法中我们可以看到,它是先通过判断knownProviders里有没有(即providers),若没有再去lookupIterator中找; 前面我们可以看到providers里并没用put任何东西,那么就说明put操作也是在lookupIterator中完成的。

先看到lookupIterator的next方法:

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);
	}
}
复制代码

首先根据判断acc是否为空,若为空则说明没有设置安全策略直接调用nextService方法,否则以特权方式调用nextService方法。

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
}
复制代码

首先根据hasNextService方法判断,若为false直接抛出NoSuchElementException异常,否则继续执行。

hasNextService方法:

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;
}
复制代码

hasNextService方法首先根据nextName成员是否为空判断,若不为空,则说明已经初始化过了,直接返回true,否则继续执行。接着configs成员是否为空,configs 是一个URL的枚举,若是configs 没有初始化,就需要对configs初始化。 configs初始化逻辑也很简单,首先根据PREFIX前缀加上PREFIX的全名得到完整路径,再根据loader的有无,获取URL的枚举。其中fail方法时ServiceLoader的静态方法,用于异常的处理,后面给出。 在configs初始化完成后,还需要完成pending的初始化或者添加。 可以看到只有当pending为null,或者没有元素时才进行循环。循环时若是configs里没有元素,则直接返回false;否则调用ServiceLoader的parse方法,通过service和URL给pending赋值;

parse方法:

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();
}
复制代码

可以看到parse方法直接通过URL打开输入流,通过parseLine一行一行地读取将结果保存在names数组里。

parseLine方法:

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;
 }
复制代码

parseLine方法就是读该URL对应地文件地一行,可以看到通过对“#”的位置判断,忽略注释,并且剔除空格,接着是一系列的参数合法检验,然后判断providers和names里是否都没包含这个服务名称,若都没包含names直接add,最后返回下一行的行标;

当parse将所有内容读取完毕,返回names.iterator()赋值给hasNextService中的pending。循环结束,获取pending中的第一个元素赋值给nextName,返回true,hasNextService方法结束。

在nextService方法往下执行时,先用cn保存nextName的值,再让nextName=null,为下一次的遍历做准备;接着通过类加载,加载名为cn的类,再通过该类实例化对象,并用providers缓存起来,最后返回该实例对象。

其中cast方法是判断对象是否合法:

public T cast(Object obj) {
	if (obj != null && !isInstance(obj))
	         throw new ClassCastException(cannotCastMsg(obj));
	return (T) obj;
}
复制代码

至此ServiceLoader的迭代器的next方法结束。其hasNext方法与其类似,就不详细分析了。

而其remove方法就更直接,直接抛出异常来避免可能出现的危险情况:

public void remove() {
	throw new UnsupportedOperationException();
}
复制代码

其中使用到的静态fail方法只是抛出异常:

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);
}
复制代码

ServiceLoader除了load的两个方法外还有个loadInstalled方法:

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);
}
复制代码

该方法与load方法不同在于loadInstalled使用的是扩展类加载器,而load使用的是传入进来的或者是线程的上下文类加载器,其他都一样。

ServiceLoader源码分析到此全部结束。

写在最后

最后,欢迎做Java的工程师朋友们加入Java高级架构进阶Qqun:963944895

群内有技术大咖指点难题,还提供免费的Java架构学习资料(里面有高可用、高并发、高性能及分布式、Jvm性能调优、Spring源码,MyBatis,Netty,Redis,Kafka,Mysql,Zookeeper,Tomcat,Docker,Dubbo,Nginx等多个知识点的架构资料)

比你优秀的对手在学习,你的仇人在磨刀,你的闺蜜在减肥,隔壁老王在练腰, 我们必须不断学习,否则我们将被学习者超越!

趁年轻,使劲拼,给未来的自己一个交代!

关注下面的标签,发现更多相似文章
评论