本文详细解析了Hotspot类加载器的应用，包括Thread的contextClassLoader、Java SPI机制、自定义类加载器以及Tomcat类加载器的使用。介绍了SPI的约定与实现，如JDBC驱动加载，探讨了自定义类加载器的场景和实现，并深入到Tomcat的类加载器层次，解析了其类隔离和热部署机制。
目录
在前面两篇《Hotspot 类文件加载、链接和初始化》和《Hotspot 类加载器Java源码解析》分别讲了类加载的相关概念和具体过程以及Java的类加载器的实现，那么类加载器在编码中应该如何应用了？在JDK源码中最典型的应用Java SPI服务发现机制，业务代码中的应用就是自定义类加载器，典型的如Tomcat的类加载器体系，下面逐一讲解。
一、Thread contextClassLoader
contextClassLoader是Thread类的一个私有属性，并不是一个单独的ClassLoader子类，可通过getContextClassLoader方法获取或者通过setContextClassLoader方法修改，主线程在启动的时候默认设置成AppClassLoader，子线程初始化时默认继承父线程的类加载器。这个类加载器有啥用了？这个主要是为Servlet容器如Tomcat服务的，因为Servlet容器都是一个线程处理一个http请求，不同的http请求可能请求完全独立的不同的应用。为了保证不同应用间的类隔离，单个线程在处理针对某个应用的http请求时需要使用针对该应用的类加载器而不能是容器主线程使用的类加载器，即需要通过Thread对象来传递和保存目标类加载器的引用。在创建子线程的init方法中contextClassLoader的设置代码如下：
其中parent就是通过currentThread()方法获取的父线程对象，其get和set方法的源码如下：
public ClassLoader getContextClassLoader() {
if (contextClassLoader == null)
return null;
SecurityManager sm = System.getSecurityManager();
if (sm != null) {
ClassLoader.checkClassLoaderPermission(contextClassLoader,
Reflection.getCallerClass());
}
return contextClassLoader;
}
public void setContextClassLoader(ClassLoader cl) {
SecurityManager sm = System.getSecurityManager();
if (sm != null) {
sm.checkPermission(new RuntimePermission("setContextClassLoader"));
}
contextClassLoader = cl;
}跟一般的get和set方法实现一样，在此基础上增加了安全校验相关。contextClassLoader是在代码中应用类加载器加载目标类的正确选择，不建议使用SystemClassLoader，因为SystemClassLoader是全局共享的，默认是AppClassLoader实例，而contextClassLoader是线程相关的，提供了更大的灵活性。
二、Java SPI机制
1、SPI机制约定与实现
Java SPI全称是Service Provider Interface，即服务提供接口，目的是接口与实现分离，可以灵活方便的替换具体的实现类，接口由Java定义，如JDBC、JCE、JNDI、JAXP 和 JBI等标准接口，具体的实现由开发商提供，如Mysql的JDBC接口实现就是常用的mysql-connector驱动包。在JAVA SPI机制中约定，当服务的提供者（如某个新的日志组件），实现了某个服务接口之后，需要在jar包的META-INF/services目录中同时创建一个以该服务接口命名的文件，文件中只有一行字符串记录该服务接口对应的具体实现类的全限定类名，以mysql-connector驱动包为例说明，如下图：
文件内容是：
那么Java是如何定位找到某个接口的实现类了？Java提供了一个工具类ServiceLoader，通过读取jar包中配置文件的内容得到具体的实现类，在通过反射构造具体的实例。
ServiceLoader的实现如下：
public static <S> ServiceLoader<S> load(Class<S> service) {
//使用当前线程的ContextClassLoader，主要为了兼容Servlet容器
ClassLoader cl = Thread.currentThread().getContextClassLoader();
//load方法实际是构造了一个新的ServiceLoader
return ServiceLoader.load(service, cl);
}
public static <S> ServiceLoader<S> load(Class<S> service,
ClassLoader loader)
{
return new ServiceLoader<>(service, loader);
}
public void reload() {
//providers是ServiceLoader的私有属性，LinkedHashMap类，用于按照初始化顺序保存已经初始化的类
providers.clear();
//lookupIterator是ServiceLoader的私有属性，私有的内部类LazyIterator，用于实现惰性加载
lookupIterator = new LazyIterator(service, loader);
}
private ServiceLoader(Class<S> svc, ClassLoader cl) {
service = Objects.requireNonNull(svc, "Service interface cannot be null");
//未指定类加载器，默认使用getSystemClassLoader()返回的系统类加载器，即AppClassLoader
loader = (cl == null) ? ClassLoader.getSystemClassLoader() : cl;
acc = (System.getSecurityManager() != null) ? AccessController.getContext() : null;
reload();
}
//DriverManager调用此方法完成驱动类加载
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() {
//如果链表中还有下一个则返回链表中的元素，否则调用lookupIterator查找下一个
if (knownProviders.hasNext())
return knownProviders.next().getValue();
return lookupIterator.next();
}
public void remove() {
throw new UnsupportedOperationException();
}
};
}
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 {
//PREFIX是字符串常量，"META-INF/services/"，此处是拼出来完整的service文件名
String fullName = PREFIX + service.getName();
//查找service文件
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;
}
//读取并解析service文件中实现类的类名，hasNext为false即当前配置文件读取完成会进入循环重新解析下一个配置文件
pending = parse(service, configs.nextElement());
}
//nextName即实现类的类名
nextName = pending.next();
return true;
}
private S nextService() {
if (!hasNextService())
throw new NoSuchElementException();
String cn = nextName;
nextName = null;
Class<?> c = null;
try {
//通过ClassLoader加载目标类
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 T cast(Object obj) {
if (obj != null && !isInstance(obj))
throw new ClassCastException(cannotCastMsg(obj));
return (T) obj;
}用于解析配置文件的parseLine方法的实现如下：
private Iterator<String> parse(Class<?> service, URL u)
throws ServiceConfigurationError
{
InputStream in = null;
BufferedReader r = null;
ArrayList<String> names = new ArrayList<>();
try {
//u是目标配置文件的资源地址
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 int parseLine(Class<?> service, URL u, BufferedReader r, int lc,
List<String> names)
throws IOException, ServiceConfigurationError
{
String ln = r.re
最低0.47元/天 解锁文章
扫一扫
468
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
