【双亲委派机制详解】


定义

  双亲委派机制是JDK1.2时引入的,主要是为了 避免重复加载安全性

  当一个类加载器需要加载类的时候,它会先检查是否已经加载过,如果没有的话,会直接交给父加载器去加载,而父加载器又委托给根加载器加载,当根加载器和父加载器都无法加载时,才会由自己去加载。其实本身使用了递归去做处理。

类加载器

  在Java中,提供了三种类加载器,分别加载不同路径的Class文件(我们也可以自定义类加载器,指定其加载路径):

  • BootstrapClassLoader:启动类加载器

主要加载核心的类库 [JAVA_HOME/jre/lib] (java.lang.*等),比如我们用的String、Object都是其加载的,以及构造ExtClassLoader和AppClassLoader。并且该类加载器是由C++写的。


  • ExtClassLoader:(ExtensionClassLoader) 扩展类加载器

主要负责加载 [JAVA_HOME/jre/lib/ext]目录下的一些扩展的jar包。


  • AppClassLoader:(ApplicationClassLoader) 应用类加载器

主要负责加载当前应用下的所有类以及引入的依赖包。


  先来看看是不是这样加载的:

在这里插入图片描述

  首先,我们可以看到:

  • 加载SpringApplication类的类加载器是AppClassLoader。(Spring是我们引入的依赖包

  • 加载EventQueueMonitor类的类加载器是ExtClassLoader。(EventQueueMonitor类存在于JAVA_HOME\jre\lib\ext的 jaccess.jar包内

  • 加载String类的类加载器是null,是因为BootstrapClassLoader是C++写的,在Java不是对象。(String类是属于JAVA_HOME\jre\lib的 rt.jar包内


  由此,可以看出,确实分工明确,各个加载器各自加载不同路径的class文件
  而我们回归主题,双亲委派在其中做了什么工作呢?我们接着看。

双亲委派

  双亲委派的定义在上文中已经简单赘述,它是如何实现的,我们看源码:

  1. 首先我们找到AppClassLoader和ExtClassLoader共同的基类ClassLoader,找到其中的核心方法loadClass()。
    在该方法的注释上,我们看到一段:
  1. Invoke findLoadedClass(String) to check if the class has already been loaded.
  2. Invoke the loadClass method on the parent class loader. If the parent is null the class loader built-in to the virtual machine is used, instead.
  3. Invoke the findClass(String) method to find the class.

大概意思是:

首先,调用findLoadedClass()来检查类是否已经加载。
接着,在父类加载器上调用loadClass方法。如果父类为空,则使用虚拟机内置的类装入器。
最后调用findClass(String)方法来查找类。

在这里插入图片描述

  图片引用自双亲委派机制

  什么意思呢?我们看源码就懂了:


1. 首先在第一行,判断类有没有被加载

Class<?> c = findLoadedClass(name);

2. 如果没有被加载,则表示先将其委托给父加载器加载。

3. 而父加载器若是不为空,则会调用父加载器的loadClass()方法。

if (parent != null) {
    c = parent.loadClass(name, false);
}

这不就是递归吗!而我们也可以查看下ExtClassLoader类,发现并没有重写loadClass()方法,所以,类加载器一直调用的都是同一个逻辑。


4. 而如果没有找到父加载器的话,说明已经到顶了,直接调用根加载器去加载

c = findBootstrapClassOrNull(name);

5. 最终,如果都没有加载成功的话,则递归结束,向下传递,通过下面的类加载器去加载

if (c == null) {
    // If still not found, then invoke findClass in order
    // to find the class.
    long t1 = System.nanoTime();
    c = findClass(name);
}

简单来说,逻辑大体如下:

  1. 首先AppClassLoader尝试加载,调用loadClass()方法。(++AppClassLoader重写了该方法,但是前面几乎都是在做校验。++

  2. 在方法中,首先查看该类是否已经加载。

  3. 如果未加载,则不会立即加载,而是委托给父类加载器ExtClassLoader去加载。

  4. 而ExtClassLoader也是一样,检查该类是否加载过,如果没有则委托父类加载器去加载。

  5. 但是对于ExtClassLoader来说,它没有父类加载器,parent为空,为空的话,则直接委托给BootstrapClassLoader去加载。所以也可以说BootstrapClassLoader是ExtClassLoader的父类加载器。

  6. 而如果BootstrapClassLoader加载不了,则会回到ExtClassLoader,由ExtClassLoader执行findClass()方法尝试加载。

  7. 而如果加载不了,则会继续回到AppClassLoader,调用其findClass()方法进行加载。

接着看看Debug模式下的:

  1. 首先,我们在AppClassLoader类的loadClass()方法下创建一个断点。

在这里插入图片描述


  1. 启动程序可以看到。

在这里插入图片描述


  1. 最终还是走回了父类的loadClass()方法。

  2. 接着走到父类加载器ExtClassLoader的loadClass()方法。

在这里插入图片描述


  1. 在ExtClassLoader中,parent不存在。

在这里插入图片描述


  1. 所以在没找到类和parent不存在的情况下,调用了BootstrapClassLoader进行加载。
    在这里插入图片描述

  1. 而 [java.lang.Integer] 本身就是属于BootstrapClassLoader加载的范围,所以直接加载成功。

在这里插入图片描述


  1. 一路返回即可。

优势

  1. 通过委托父类加载的方式,可以避免类的重复加载,因为每个类加载器加载前都会检查此类有没有加载过,如果父类加载过,子类就不会加载。

  2. 保证了安全性,比如说BootstrapClassLoader只会加载JAVA_HOME/jre/lib下的jar包,比如String类,这个类是不会被替换的,保证了安全性。

总结

  首先双亲委派机制一定程度上保证了类在JVM中只能存在一份,并且,也有效防止了危险代码的植入,因为该机制使BootstrapClassLoader总是在第一个尝试加载的,其它类加载器无法比它更优先。

  而如何破坏双亲委派机制,相信你已经懂了。






<think>好的,我现在需要解释Java双亲委派机制。首先,我要回忆一下相关的知识点。双亲委派模型是Java类加载器(ClassLoader)用来加载类的一种机制。它的核心思想是,当一个类加载器收到加载类的请求时,首先不会自己去尝试加载,而是把这个请求委派给父类加载器去完成。每一层的类加载器都是如此,因此所有的加载请求最终都应该传送到顶层的启动类加载器(Bootstrap ClassLoader)。只有当父类加载器反馈自己无法完成这个加载请求(也就是它没有找到所需的类)时,子加载器才会尝试自己去加载。 接下来,我需要确认双亲委派的具体流程。首先,用户自定义的类加载器(比如应用程序类加载器AppClassLoader)在加载一个类时,会先检查是否已经被加载过。如果没有,就委派给扩展类加载器(Extension ClassLoader)。扩展类加载器同样会先检查自己是否已经加载过该类,如果没有,继续委派给启动类加载器(Bootstrap ClassLoader)。如果启动类加载器无法加载(比如在它的路径下找不到该类),则扩展类加载器会尝试加载。如果扩展类加载器也加载不了,才会由应用程序类加载器尝试加载。如果应用程序类加载器也加载失败,就会抛出ClassNotFoundException。 然后,我需要思考双亲委派机制的好处。主要有两点:一是避免重复加载类,当父加载器已经加载了该类时,子加载器就不需要再加载一次,确保了类的唯一性;二是安全性,防止核心的Java类库被篡改,比如用户自定义了一个java.lang.String类,由于双亲委派机制的存在,这个类不会被加载,因为启动类加载器已经加载了核心的String类。 可能还要提到类加载器的层次结构。启动类加载器是最顶层的,负责加载JAVA_HOME/lib目录下的核心类库。扩展类加载器负责加载JAVA_HOME/lib/ext目录下的类。应用程序类加载器负责加载用户类路径(classpath)上的类。用户还可以自定义类加载器,继承自ClassLoader类,覆盖findClass方法来实现自己的加载逻辑。 需要注意的是,双亲委派模型并不是强制性的约束,而是Java设计者推荐的一种规范。用户可以通过重写loadClass方法来实现不同的加载逻辑,但这可能会破坏双亲委派机制。例如,Tomcat服务器为了支持Web应用的类隔离,就重写了类加载器的行为,优先加载自己目录下的类,而不是先委派给父加载器。 另外,Java模块化系统(如Java 9引入的JPMS)对类加载机制也有一定的影响,但双亲委派的基本原理仍然适用。在模块化系统中,类加载器可能需要考虑模块路径和模块间的依赖关系,但整体的委派机制没有根本性改变。 最后,应该举一个例子来说明双亲委派的流程。比如用户写了一个HelloWorld类,当运行这个程序时,应用程序类加载器会先委派给扩展类加载器,再委派给启动类加载器。启动类加载器在核心库中找不到HelloWorld类,于是扩展类加载器尝试在自己的路径下找,仍然找不到,最后应用程序类加载器在classpath中找到并加载这个类。 可能还需要提到破坏双亲委派的例子,比如JNDI服务使用线程上下文类加载器(TCCL)来实现逆向委派,因为JNDI的核心接口由启动类加载器加载,但具体的实现可能在应用类路径下,需要由应用类加载器加载。这种情况下,就需要打破双亲委派模型,通过TCCL来加载实现类。 总结一下,双亲委派机制Java类加载的重要机制,确保了类的安全性和唯一性,但也可以通过自定义类加载器来打破这种机制,满足特定的需求。</think>--- ### Java双亲委派机制详解 #### 一、核心概念 **双亲委派模型(Parent Delegation Model)** 是Java类加载器(`ClassLoader`)的核心工作机制,其核心规则为: - **向上委派**:当类加载器收到加载请求时,**优先将请求传递给父类加载器** - **向下阻断**:只有父加载器无法完成加载时,子加载器才会尝试自己加载 --- #### 二、类加载器层级结构 | 加载器类型 | 加载路径 | 实现语言 | 代码示例 | |-------------------------|-----------------------------------|----------|------------------------------| | **Bootstrap ClassLoader** | `JAVA_HOME/jre/lib` 核心库 | C++ | 无Java代码实现 | | **Extension ClassLoader** | `JAVA_HOME/jre/lib/ext` 扩展库 | Java | `sun.misc.Launcher$ExtClassLoader` | | **Application ClassLoader** | Classpath用户类 | Java | `sun.misc.Launcher$AppClassLoader` | --- #### 三、完整加载流程 ```mermaid sequenceDiagram participant 用户代码 participant AppClassLoader participant ExtClassLoader participant BootstrapClassLoader 用户代码->>AppClassLoader: 请求加载类X AppClassLoader->>ExtClassLoader: 父级能加载吗? ExtClassLoader->>BootstrapClassLoader: 父级能加载吗? BootstrapClassLoader-->>ExtClassLoader: 加载失败 ExtClassLoader-->>AppClassLoader: 加载失败 AppClassLoader->>AppClassLoader: 自己尝试加载 alt 加载成功 AppClassLoader-->>用户代码: 返回Class对象 else 加载失败 AppClassLoader-->>用户代码: ClassNotFoundException end ``` --- #### 四、关键源码解析(简化版) ```java // java.lang.ClassLoader 的 loadClass 方法 protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException { synchronized (getClassLoadingLock(name)) { // 1. 检查是否已加载 Class<?> c = findLoadedClass(name); if (c == null) { try { // 2. 优先委派给父加载器 if (parent != null) { c = parent.loadClass(name, false); } else { c = findBootstrapClassOrNull(name); } } catch (ClassNotFoundException e) {} if (c == null) { // 3. 父加载器无法加载时自行加载 c = findClass(name); } } return c; } } ``` --- #### 五、设计优势 1. **避免重复加载** - 通过层级校验确保每个类**全局唯一** - 示例:`java.lang.Object` 只会由Bootstrap加载器加载一次 2. **保护核心类库安全** - 防止用户伪造核心类(如自定义`java.lang.String`) - 尝试加载伪造类时会因父加载器已加载正版类而直接拒绝 3. **灵活扩展机制** - 允许通过自定义类加载器实现: - 热部署(如Tomcat重载Web应用) - 模块化隔离(如OSGi框架) --- #### 六、打破双亲委派的典型场景 | 场景 | 实现方式 | 应用案例 | |---------------------------|-----------------------------------|------------------------| | **JNDI服务发现** | 线程上下文类加载器(TCCL) | JDBC驱动加载 | | **OSGi模块化** | 网状类加载器结构 | Eclipse插件体系 | | **热部署** | 自定义类加载器+版本控制 | Tomcat Web应用重载 | **示例:Tomcat类加载器结构** ``` Bootstrap ↑ System ↑ Common ↗↖ WebApp1 WebApp2 ``` - **WebApp类加载器**:优先加载`/WEB-INF/classes`,未找到再委派给父加载器 --- #### 七、JDK 9+ 模块化系统的影响 1. **模块路径(Modulepath)** 替代类路径(Classpath) 2. **层级化模块依赖**:通过`module-info.java`声明依赖关系 3. **类加载优化**: - 启动类加载器可直接加载模块中的类 - 未导出的包即使通过反射也无法访问 --- #### 八、开发建议 1. **避免重写loadClass()**:如需自定义加载逻辑,应重写`findClass()` 2. **谨慎使用TCCL**:理解线程上下文类加载器的作用范围 3. **模块化开发**:JDK 9+项目推荐使用模块化封装 通过双亲委派机制Java实现了类加载的**安全性**与**高效性**的统一,成为Java生态稳定性的重要基石。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值