双亲委派模型通过类加载器的层级结构工作,具体做法是当一个类加载器收到类加载请求时,它不会自己去尝试加载这个类,而是把这个请求委派给父类加载器去完成,每一层的类加载器都是如此,因此所有的加载请求最终都应该传送到顶层的启动类加载器中,只有当父加载器反馈自己无法完成这个加载请求(它的搜索范围中没有找到所需的类)时,子加载器才会尝试自己去加载。

自定义类加载器如何打破双亲委派
要打破双亲委派模型,最直接的做法是继承 java.lang.ClassLoader 并重写其 loadClass 方法。默认情况下,loadClass 内部实现了双亲委派的逻辑,即先调用父加载器的 loadClass,失败后才执行自己的 findClass。如果我们直接重写 loadClass 并跳过父加载器的调用,或者在 findClass 中实现特定的加载逻辑,就可以实现自定义的加载行为,例如热部署或隔离不同版本的库。

import java.io.ByteArrayOutputStream;
import java.io.FileInputStream;
import java.io.IOException;
public class CustomClassLoader extends ClassLoader {
private String classPath;
public CustomClassLoader(String classPath) {
this.classPath = classPath;
}
@Override
protected Class<?> findClass(String name) throws ClassNotFoundException {
byte[] data = loadClassData(name);
return defineClass(name, data, 0, data.length);
}
private byte[] loadClassData(String name) {
try {
String filePath = classPath + name.replace('.', '/') + ".class";
FileInputStream fis = new FileInputStream(filePath);
ByteArrayOutputStream baos = new ByteArrayOutputStream();
int ch;
while ((ch = fis.read()) != -1) {
baos.write(ch);
}
return baos.toByteArray();
} catch (IOException e) {
throw new RuntimeException("Loading class failed", e);
}
}
public static void main(String[] args) {
CustomClassLoader loader = new CustomClassLoader("/path/to/classes/");
try {
Class<?> clazz = loader.loadClass("com.example.MyClass");
System.out.println(clazz.getClassLoader());
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
}运行上述代码,如果 /path/to/classes/ 下存在 com/example/MyClass.class,程序将成功加载该类并打印出 CustomClassLoader 的实例,表明该类是由自定义加载器加载的,而非父加载器。
立即学习“Java免费学习笔记(深入)”;
Tomcat 如何实现 Web 应用的类隔离
Tomcat 为了实现不同 Web 应用之间的类隔离,采用了破坏双亲委派模型的变体方案。每个 Web 应用都有自己的 WebappClassLoader,该加载器在加载类时,首先会检查当前 Web 应用是否已经加载过该类,如果没有,则尝试从本地目录加载。如果本地没有,再委派给父加载器(通常是 CommonClassLoader)。这种设计允许每个 Web 应用拥有独立的类路径,从而避免不同应用使用不同版本的同一类库时产生冲突。

// Tomcat 中的 WebappClassLoader 核心逻辑示意
public class WebappClassLoader extends URLClassLoader {
@Override
protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
synchronized (getClassLoadingLock(name)) {
// 1. 检查是否已加载
Class<?> loadedClass = findLoadedClass(name);
if (loadedClass != null) {
return loadedClass;
}
// 2. 优先从 Web 应用自身加载
try {
Class<?> c = findClass(name);
if (c != null) {
return c;
}
} catch (ClassNotFoundException e) {
// 忽略,继续向下委派
}
// 3. 委派给父加载器
return super.loadClass(name, resolve);
}
}
}在上述代码中,findClass 方法会优先在当前 Web 应用的类路径中查找类。如果找到,则直接返回;如果未找到,才调用 super.loadClass 将请求委派给父加载器。这种“先本地后父”的策略确保了 Web 应用的私有类库优先被加载,实现了有效的类隔离。
SPI 机制中为何需要破坏双亲委派
Java SPI(Service Provider Interface)机制要求服务提供者接口由启动类加载器加载,而服务提供者实现类由应用程序类加载器加载。由于双亲委派模型是自上而下的,启动类加载器无法看到应用程序类加载器加载的类,这导致 SPI 无法正常工作。为了解决这个问题,JDK 引入了线程上下文类加载器(Thread Context ClassLoader),它默认是应用程序类加载器。在 SPI 加载实现类时,使用线程上下文类加载器来加载,从而打破了双亲委派的顺序,使得父加载器能够请求子加载器加载类。


















