Tomcat 的类加载机制

柔光的暖阳◎ 2023-10-02 11:57 79阅读 0赞

在前面 Java虚拟机：对象创建过程与类加载机制、双亲委派模型 文章中，我们介绍了 JVM 的类加载机制以及双亲委派模型，双亲委派模型的类加载过程主要分为以下几个步骤：

  • （1）初始化 ClassLoader 时需要指定自己的 parent 是谁
  • （2）先检查类是否已经被加载过，如果类已经被加载了，直接返回
  • （3）若没有加载则调用父加载器 parent 的 loadClass() 方法进行加载
  • （4）若父加载器为空则默认使用启动类加载器 bootstrap ClassLoader 进行加载
  • （5）如果父类加载失败，抛出 ClassNotFoundException 异常后，再调用自己的 findClass() 方法进行加载。

前面文章也提到，如果想要破坏这种机制，那么就自定义一个类加载器（继承自 ClassLoader），并重写其中的 loadClass() 方法，使其不进行双亲委派即可。最经典例子就是 Tomcat 容器的类加载机制了，它实现了自己的类加载器 WebApp ClassLoader，并且打破了双亲委派模型，在每个应用在部署后，都会创建一个唯一的类加载器。

1、Tomcat 的类加载器结构图：

watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5byg57u06bmP_size_20_color_FFFFFF_t_70_g_se_x_16

（1）Common ClassLoader：加载 common.loader 属性下的 jar，一般是 CATALINA_HOME/lib 目录下，主要是 tomcat 使用以及应用通用的一些类

（2）Catalina ClassLoader：加载 server.loader 属性下的 jar，默认未配置路径，返回其父加载器即 Common ClassLoader，主要是加载服务器内部可⻅类，这些类应⽤程序不能访问；

（3）Shared Classloader：加载 share.loader 属性下的jar，默认未配置路径，返回其父加载器即 Common ClassLoader，主要是加载应⽤程序共享类，这些类对 Tomcat 自己不可见；

只有指定了 tomcat/conf/catalina.properties 配置文件的 server.loader 和 share.loader 项后，才会真正建立 Catalina ClassLoader 和 Shared ClassLoader 的实例，否则在用到这两个类加载器的地方都会用 Common ClassLoader 的实例代替，而默认的配置文件中是没有设置这两个 loader 项的

（4）WebApp ClassLoader：Tomcat 可以存在多个 WebApp ClassLoader 实例，每个应⽤程序都会有⼀个独⼀⽆⼆的 WebApp ClassLoader，⽤来加载本应⽤程序 /WEB-INF/classes 和 /WEB-INF/lib 下的类。

2、Tomcat 的类加载流程说明：

当 Tomcat 使用 WebAppClassLoader 进行类加载时，具体过程如下：

（1）先在本地 cache 缓存中查找该类是否已经加载过，看看 Tomcat 有没有加载过这个类

（2）如果 Tomcat 没有加载过这个类，则从系统类加载器的 cache 缓存中查找是否加载过

（3）如果没有，则使用 ExtClassLoader 类加载器类加载，重点来了，Tomcat 的 WebAppClassLoader 并没有先使用 AppClassLoader 来加载类，而是直接使用了 ExtClassLoader 来加载类。不过 ExtClassLoader 依然遵循双亲委派，它会使用 Bootstrap ClassLoader 来对类进行加载，保证了 Jre 里面的核心类不会被重复加载。

比如在 Web 中加载一个 Object 类。WebAppClassLoader → ExtClassLoader → Bootstrap ClassLoader，这个加载链，就保证了 Object 不会被重复加载。

（4）如果没有加载成功，WebAppClassLoader 就会调用自己的 findClass() 方法由自己来对类进行加载，先在 WEB-INF/classes 中加载，再从 WEB-INF/lib 中加载。

（5）如果仍然未加载成功，WebAppclassLoader 会委派给 SharedClassLoader，SharedClassLoad 再委派给 CommonClassLoader，CommonClassLoader 委派给 AppClassLoader，直到最终委派给 BootstrapClassLoader，最后再一层一层地在自己目录下对类进行加载。

（6）都没有加载成功的话，抛出异常。

3、源码解析：

（1）WebAppClassLoader 的 loadClass() 方法源码：

WebappClassLoader 应用类加载器的 loadClass 在他的父类 WebappClassLoaderBase 中

  1. public Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
  2.     synchronized (getClassLoadingLock(name)) {
  3.         Class<?> clazz = null;
  4.         //1. 先在本地cache查找该类是否已经加载过
  5.         clazz = findLoadedClass0(name);
  6.         if (clazz != null) {
  7.             if (resolve)
  8.                 resolveClass(clazz);
  9.             return clazz;
  10.         }
  11.         //2. 从系统类加载器的cache中查找是否加载过
  12.         clazz = findLoadedClass(name);
  13.         if (clazz != null) {
  14.             if (resolve)
  15.                 resolveClass(clazz);
  16.             return clazz;
  17.         }
  18.         // 3. 尝试用ExtClassLoader类加载器类加载(ExtClassLoader 遵守双亲委派，ExtClassLoader 会使用 Bootstrap ClassLoader 对类进行加载)
  19.         ClassLoader javaseLoader = getJavaseClassLoader();
  20.         try {
  21.             clazz = javaseLoader.loadClass(name);
  22.             if (clazz != null) {
  23.                 if (resolve)
  24.                     resolveClass(clazz);
  25.                 return clazz;
  26.             }
  27.         } catch (ClassNotFoundException e) {
  28.             // Ignore
  29.         }
  30.         // 4. 尝试在本地目录搜索class并加载
  31.         try {
  32.             clazz = findClass(name);
  33.             if (clazz != null) {
  34.                 if (resolve)
  35.                     resolveClass(clazz);
  36.                 return clazz;
  37.             }
  38.         } catch (ClassNotFoundException e) {
  39.             // Ignore
  40.         }
  41.         // 5. 尝试用系统类加载器(AppClassLoader)来加载
  42.         try {
  43.             clazz = Class.forName(name, false, parent);
  44.             if (clazz != null) {
  45.                 if (resolve)
  46.                     resolveClass(clazz);
  47.                 return clazz;
  48.             }
  49.         } catch (ClassNotFoundException e) {
  50.             // Ignore
  51.         }
  52.      }
  53.     //6. 上述过程都加载失败，抛出异常
  54.     throw new ClassNotFoundException(name);
  55. }

（2）WebAppClassLoader 的 findClass() 方法源码：

  1. public Class<?> findClass(String name) throws ClassNotFoundException {
  2.     // Ask our superclass to locate this class, if possible
  3.     // (throws ClassNotFoundException if it is not found)
  4.     Class<?> clazz = null;
  6.     // 先在自己的 Web 应用目录下查找 class
  7.     clazz = findClassInternal(name);
  9.     // 找不到 在交由父类来处理
  10.     if ((clazz == null) && hasExternalRepositories) {  
  11.         clazz = super.findClass(name);
  12.     }
  13.     if (clazz == null) {
  14.          throw new ClassNotFoundException(name);
  15.     }
  16.     return clazz;
  17. }

4、为什么tomcat要实现自己的类加载机制：

WebAppClassLoader 加载类的时候，故意打破了JVM 双亲委派机制，绕开了 AppClassLoader，直接先使用 ExtClassLoader 来加载类。最主要原因是保证部署在同一个 Web 容器上的不同 Web 应用程序所使用的类库可以实现相互隔离，避免不同项目的相互影响。当然还有其他原因，如：

（1）保证 Web 容器自身的安全不受部署的 Web 应用程序影响，所以 Tomcat 使用的类库要与部署的应用的类库相互独立

（2）保证部分基础类不会被同时加载，有些类库 Tomcat 与部署的应用可以共享，比如说 servlet-api

（3）保证部署在同一个 Web 容器的应用之间的类库可以共享，这听起来好像主要原因相互矛盾，但其实这很合理，类被类加载器加载到虚拟机后，会存放在方法区的永久代中，如果类库不能共享，虚拟机的方法区就会很容易出现过度膨胀的风险。比如这时候如果有大量的应用使用 spring 来管理，如果 spring 类库不能共享，那每个应用的 spring 类库都会被加载一次，将会是很大的资源浪费。

小结：Tomcat 实际上只有 WebAppClassLoader 加载器中打破了双亲委派，其他类加载器还是遵循双亲委派的。 这样做最主要原因是保证同个 Web 容器中的不同 Web 应用程序所使用的类库相互独立，避免相互影响

参考文章：https://mp.weixin.qq.com/s/OwWUDxHY4Th6decmJeMTgA

发表评论

表情：
评论列表 （有 0 条评论，79人围观）

还没有评论，来说两句吧...

相关阅读

    相关 Tomcat 的类加载机制

    在前面 [Java虚拟机：对象创建过程与类加载机制、双亲委派模型][Java] 文章中，我们介绍了 JVM 的类加载机制以及双亲委派模型，双亲委派模型的类加载过程主要分为以下几

    柔光的暖阳◎柔光的暖阳◎/ 0 赞/ 80 阅读

    相关 Tomcat类加载机制

    一：双亲委派模型 双亲委派模型要求除了顶层的启动类加载器之外，其余的类加载器都应当由自己的父类加载器加载。 ![3859a4d3c80a51c151a92aa3f

    梦里梦外;梦里梦外;/ 0 赞/ 373 阅读

    相关 图解Tomcat类加载机制

           之前学习javaMelody的源码，但是它是一个Maven的项目，与我们自己的web项目整合后无法直接断点调试。后来同事指导，说是直接把java类复制到src下就

    矫情吗；*矫情吗；*/ 0 赞/ 373 阅读