前言：
双亲委派机制对于面试这块来说非常重要，在实际开发中也是经常遇见需要打破双亲委派的需求，今天我们一起来探索一下什么是双亲委派机制，在此之前我们先介绍一下类的加载器。
目录
编辑
前言：
类加载器
1. 启动类加载器（Bootstrap Class Loader）
2. 扩展类加载器（Extension Class Loader）
3. 应用类加载器（Application Class Loader）
4. 自定义类加载器（Custom Class Loader）
双亲委派机制
1. 基本概念
（1）避免类重复加载
（2）保护核心 API
（3）实现类的隔离与模块化
工作流程
双亲委派机制源码解读：
ClassLoader 的四个核心方法
核心问题
总结
类加载器
由于在jdk8以及之前没有模块化这个概念，所以jkd8之前和jdk9之后加载器有些变化，在这里介绍的是jdk8及之前的加载器。
在 Java 中，类加载器（Class Loader）负责将类的字节码（.class 文件）加载到 JVM 中。根据层级和职责，主要分为以下几类：
1. 启动类加载器（Bootstrap Class Loader）
- 职责：加载 JVM 核心类库（如
java.lang.*、java.util.*），路径通常为$JAVA_HOME/jre/lib。 - 特点：
- 由 JVM 底层实现（C++ 编写），在 Java 代码中无法直接引用。
- 加载最基础的类，确保 JVM 运行环境。
2. 扩展类加载器（Extension Class Loader）
- 职责：加载 Java 扩展库（如
javax.*包），路径为$JAVA_HOME/jre/lib/ext。 - 特点：
- 是
java.lang.ClassLoader的子类（Java 实现）。 - 负责加载标准库之外的扩展功能。
- 是
3. 应用类加载器（Application Class Loader）
- 职责：加载用户类路径（
classpath）下的类，即开发者编写的代码。 - 特点：
- 是
ClassLoader的子类，也称为系统类加载器。 - 是
ClassLoader.getSystemClassLoader()的返回值。
- 是
4. 自定义类加载器（Custom Class Loader）
- 职责：通过继承
java.lang.ClassLoader实现，用于加载特殊来源的类（如网络、加密文件）。 - 常见场景：
- 热部署（动态加载类）。
- 加载自定义格式的字节码（如加密类）。
- 实现类的隔离（如 OSGi 框架）。
注意点：不能认为一个加载器与其父类加载器的关系是继承，虽然有“父”。
需要注意的是如果我们尝试获取扩展类加载器的parent对象，得到的结果是null。并不是说其父类不是启动类加载器，只是因为启动类加载器属于JVM的一部分，使用C++实现，无法被获取到！
双亲委派机制
1. 基本概念
双亲委派指的是：当一个类加载器收到类加载请求时，它首先会将请求委派给父类加载器去尝试加载，而非立即自己加载。只有当父类加载器无法加载该类时，子类加载器才会尝试自己加载。
设计目的
（1）避免类重复加载
若多个类加载器都尝试加载同一个类，会导致内存中存在多个相同类的实例，破坏类型唯一性。双亲委派确保类只被加载一次。
（2）保护核心 API
例如，用户自定义的
java.lang.String类不会被加载，因为String由启动类加载器加载。这防止恶意或错误代码覆盖 JVM 核心类，保障系统安全。（3）实现类的隔离与模块化
不同类加载器可加载同名但不同路径的类（如插件系统），实现隔离性。例如，Web 容器（如 Tomcat）使用自定义类加载器实现多个应用的隔离。
核心原则：
- 向上委派：先让父类加载器尝试加载。
- 向下查找：父类无法加载时，子类再尝试。
工作流程
当类加载器（如 AppClassLoader）收到类加载请求时：
- 检查缓存：首先检查该类是否已被加载。
- 委派父类：若未加载，则将请求委派给父类加载器（如
ExtClassLoader）。- 递归委派：父类加载器重复步骤 1 和 2，直到到达启动类加载器。
- 尝试加载：
- 启动类加载器尝试加载该类，若成功则返回
Class对象。- 若失败，则由扩展类加载器尝试，依此类推，直到子类加载器（如
AppClassLoader）。- 抛出异常：若所有类加载器都无法加载，则抛出
ClassNotFoundException。
双亲委派机制源码解读：
ClassLoader 的四个核心方法
loadClass：负责整体调度，按层级查找类。findClass：具体去哪里找类（子类必须实现）。defineClass：把类文件的二进制内容变成 JVM 能懂的Class对象。resolveClass：解析类的内部结构，确保类能正常工作。
在加载类的时候会调用它，第一个参数是加载的类名，第二个参数是否需要解析类
protected Class<?> loadClass(String name, boolean resolve)
throws ClassNotFoundException
{
synchronized (getClassLoadingLock(name)) {
// First, check if the class has already been loaded
Class<?> c = findLoadedClass(name);
if (c == null) {
long t0 = System.nanoTime();
try {
if (parent != null) {
c = parent.loadClass(name, false);
} else {
c = findBootstrapClassOrNull(name);
}
} catch (ClassNotFoundException e) {
// ClassNotFoundException thrown if class not found
// from the non-null parent class loader
}
if (c == null) {
// If still not found, then invoke findClass in order
// to find the class.
long t1 = System.nanoTime();
c = findClass(name);
// this is the defining class loader; record the stats
PerfCounter.getParentDelegationTime().addTime(t1 - t0);
PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
PerfCounter.getFindClasses().increment();
}
}
if (resolve) {
resolveClass(c);
}
return c;
}
}代码流程：
- 获取加载的类，如果为空说明没有加载。
- 进入第一个if，判断有无父类加载器，有就调用父类加载器加载。
- 没有父类加载器说明需要用启动类加载器加载。
- 第二个if表示父类加载器加载失败，则调用此时的子类加载器加载。
我们来看看findclass方法的源码
protected Class<?> findClass(String name) throws ClassNotFoundException {
int index = name.indexOf(';');
String cookie = "";
if(index != -1) {
cookie = name.substring(index, name.length());
name = name.substring(0, index);
}
// check loaded JAR files
try {
return super.findClass(name);
} catch (ClassNotFoundException e) {
}
// Otherwise, try loading the class from the code base URL
// 4668479: Option to turn off codebase lookup in AppletClassLoader
// during resource requests. [stanley.ho]
if (codebaseLookup == false)
throw new ClassNotFoundException(name);
// final String path = name.replace('.', '/').concat(".class").concat(cookie);
String encodedName = ParseUtil.encodePath(name.replace('.', '/'), false);
final String path = (new StringBuffer(encodedName)).append(".class").append(cookie).toString();
try {
byte[] b = AccessController.doPrivileged(
new PrivilegedExceptionAction<byte[]>() {
public byte[] run() throws IOException {
try {
URL finalURL = new URL(base, path);
// Make sure the codebase won't be modified
if (base.getProtocol().equals(finalURL.getProtocol()) &&
base.getHost().equals(finalURL.getHost()) &&
base.getPort() == finalURL.getPort()) {
return getBytes(finalURL);
}
else {
return null;
}
} catch (Exception e) {
return null;
}
}
}, acc);
if (b != null) {
return defineClass(name, b, 0, b.length, codesource);
} else {
throw new ClassNotFoundException(name);
}
} catch (PrivilegedActionException e) {
throw new ClassNotFoundException(name, e.getException());
}
}核心问题
什么是双亲委派机制?
1.在一个类加载器去加载一个类的时候，会自下而上去查找这个类有没有被加载过，如果都没有加载，就会自上而下去加载这个类，如果都无法加载就会抛出异常。
2.应用类加载器的父类是扩展类加载器，扩展类加载器的父类是启动类加载器。
3.双亲委派机制的核心是第一个确保类不会被重复加载，第二个避免恶意代码替换JDK的核心类库，保证核心类库的安全和完整。
总结
双亲委派机制是 Java 安全模型的基石，它通过层级委派和缓存机制确保类的唯一性和安全性。理解该机制有助于排查类加载异常（如 NoClassDefFoundError），并设计出更健壮的框架和应用。
我在学到defineClass的时候有一点疑问，在源代码执行过程中就已经编译成为了class文件，为什么还需要defineClass后来我发现，编译后的是class文件是二进制形式的，而defineClass是把它转换为JVM能识别的class对象。虽然都是class但是内容形式并不一样。
这也体现了写博客的好处，方便查漏补缺，感谢你们的阅读，你的阅读和点赞是我最大的动力。
