Tomcat的类加载机制流程及源码解析

前言

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

（1）初始化 classloader 时需要指定自己的 parent 是谁

（2）先检查类是否已经被加载过，如果类已经被加载了，直接返回

（3）若没有加载则调用父加载器 parent 的 loadclass() 方法进行加载

（4）若父加载器为空则默认使用启动类加载器 bootstrap classloader 进行加载

（5）如果父类加载失败，抛出 classnotfoundexception 异常后，再调用自己的 findclass() 方法进行加载。

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

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

（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 中

public class<?> loadclass(string name, boolean resolve) throws classnotfoundexception {
    synchronized (getclassloadinglock(name)) {
        class<?> clazz = null;
        //1. 先在本地cache查找该类是否已经加载过
        clazz = findloadedclass0(name);
        if (clazz != null) {
            if (resolve)
                resolveclass(clazz);
            return clazz;
        }
        //2. 从系统类加载器的cache中查找是否加载过
        clazz = findloadedclass(name);
        if (clazz != null) {
            if (resolve)
                resolveclass(clazz);
            return clazz;
        }
        // 3. 尝试用extclassloader类加载器类加载(extclassloader 遵守双亲委派，extclassloader 会使用 bootstrap classloader 对类进行加载)
        classloader javaseloader = getjavaseclassloader();
        try {
            clazz = javaseloader.loadclass(name);
            if (clazz != null) {
                if (resolve)
                    resolveclass(clazz);
                return clazz;
            }
        } catch (classnotfoundexception e) {
            // ignore
        }
        // 4. 尝试在本地目录搜索class并加载
        try {
            clazz = findclass(name);
            if (clazz != null) {
                if (resolve)
                    resolveclass(clazz);
                return clazz;
            }
        } catch (classnotfoundexception e) {
            // ignore
        }
        // 5. 尝试用系统类加载器(appclassloader)来加载
        try {
            clazz = class.forname(name, false, parent);
            if (clazz != null) {
                if (resolve)
                    resolveclass(clazz);
                return clazz;
            }
        } catch (classnotfoundexception e) {
            // ignore
        }
     }
    //6. 上述过程都加载失败，抛出异常
    throw new classnotfoundexception(name);
}

（2）webappclassloader 的 findclass() 方法源码：

public class<?> findclass(string name) throws classnotfoundexception {
    // ask our superclass to locate this class, if possible
    // (throws classnotfoundexception if it is not found)
    class<?> clazz = null;
 
    // 先在自己的 web 应用目录下查找 class
    clazz = findclassinternal(name);
 
    // 找不到 在交由父类来处理
    if ((clazz == null) && hasexternalrepositories) {  
        clazz = super.findclass(name);
    }
    if (clazz == null) {
         throw new classnotfoundexception(name);
    }
    return clazz;
}

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 应用程序所使用的类库相互独立，避免相互影响

参考文章：

到此这篇关于tomcat的类加载机制流程及源码解析的文章就介绍到这了,更多相关tomcat类加载机制内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！