Tomcat隔离web原理和热加载热部署-CSDN博客

Tomcat 如何打破双亲委派机制

Tomcat 的自定义类加载器 WebAppClassLoader 打破了双亲委派机制它首先自己尝试去加载某个类如果找不到再代理给父类加载器其目的是优先加载 Web 应用自己定义的类。具体实现就是重写 ClassLoader 的两个方法findClass 和 loadClass。

findClass方法

public Class<?> findClass(String name) throws ClassNotFoundException {

    Class<?> clazz = null;

    try {
        //1. 先在 Web 应用目录下查找类
        clazz = findClassInternal(name);
    } catch (RuntimeException e) {
        throw e;
    }
 

    if (clazz == null) {
        try {
            //2. 如果在本地目录没有找到交给父加载器去查找
            clazz = super.findClass(name);
        } catch (RuntimeException e) {
            throw e;
        }
 
        //3. 如果父类也没找到抛出 ClassNotFoundException
        if (clazz == null) {
            throw new ClassNotFoundException(name);
        }
        return clazz;
    }

在 findClass 方法里主要有三个步骤

1先在 Web 应用本地目录下查找要加载的类。

2如果没有找到交给父加载器去查找它的父加载器就是上面提到的系统类加载器AppClassLoader。

3如何父加载器也没找到这个类抛出 ClassNotFound 异常。

---

loadClass 方法

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 类加载器类加载为什么
        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); 
}

loadClass 方法稍微复杂一点主要有六个步骤

1先在本地 Cache 查找该类是否已经加载过也就是说 Tomcat 的类加载器是否已经加载过这个

类。

2如果 Tomcat 类加载器没有加载过这个类再看看系统类加载器是否加载过。

3如果都没有就让ExtClassLoader去加载这一步比较关键目的防止 Web 应用自己的类覆盖

JRE 的核心类。因为 Tomcat 需要打破双亲委派机制假如 Web 应用里自定义了一个叫 Object 的

类如果先加载这个 Object 类就会覆盖 JRE 里面的那个 Object 类这就是为什么 Tomcat 的类加

载器会优先尝试用 ExtClassLoader 去加载因为 ExtClassLoader 会委托给 BootstrapClassLoader

去加载BootstrapClassLoader 发现自己已经加载了 Object 类直接返回给 Tomcat 的类加载器

这样 Tomcat 的类加载器就不会去加载 Web 应用下的 Object 类了也就避免了覆盖 JRE 核心类的问

题。

4如果 ExtClassLoader 加载器加载失败也就是说 JRE 核心类中没有这类那么就在本地 Web 应

用目录下查找并加载。

5如果本地目录下没有这个类说明不是 Web 应用自己定义的类那么由系统类加载器去加载。这

里请你注意Web 应用是通过Class.forName调用交给系统类加载器的因为Class.forName的默认

加载器就是系统类加载器。

6如果上述加载过程全部失败抛出 ClassNotFound 异常。

从上面的过程我们可以看到Tomcat 的类加载器打破了双亲委派机制没有一上来就直接委托给父加

载器而是先在本地目录下加载为了避免本地目录下的类覆盖 JRE 的核心类先尝试用 JVM 扩展类

加载器 ExtClassLoader 去加载。那为什么不先用系统类加载器 AppClassLoader 去加载很显然

如果是这样的话那就变成双亲委派机制了这就是 Tomcat 类加载器的巧妙之处。

Tomcat如何隔离Web应用

Tomcat 作为 Servlet 容器它负责加载我们的 Servlet 类此外它还负责加载 Servlet 所依赖的 JAR

包。并且 Tomcat 本身也是也是一个 Java 程序因此它需要加载自己的类和依赖的 JAR 包。首先让

我们思考这一下这几个问题

1假如我们在 Tomcat 中运行了两个 Web 应用程序两个 Web 应用中有同名的 Servlet但是功能

不同Tomcat 需要同时加载和管理这两个同名的 Servlet 类保证它们不会冲突因此 Web 应用之

间的类需要隔离。

2假如两个 Web 应用都依赖同一个第三方的 JAR 包比如 Spring那 Spring 的 JAR 包被加载到

内存后Tomcat 要保证这两个 Web 应用能够共享也就是说 Spring 的 JAR 包只被加载一次否则

随着依赖的第三方 JAR 包增多JVM 的内存会膨胀。

3跟 JVM 一样我们需要隔离 Tomcat 本身的类和 Web 应用的类。

---

Tomcat类加载器的层次结构

为了解决这些问题Tomcat 设计了类加载器的层次结构它们的关系如下图所示

commonLoaderTomcat最基本的类加载器加载路径中的class可以被Tomcat容器本身以及各个Webapp访

问

catalinaLoaderTomcat容器私有的类加载器加载路径中的class对于Webapp不可见

sharedLoader各个Webapp共享的类加载器加载路径中的class对于所有Webapp可见但是对于Tomcat容

器不可见

WebappClassLoader各个Webapp私有的类加载器加载路径中的class只对当前Webapp可见比如加载

war包里相关的类每个war包应用都有自己的WebappClassLoader实现相互隔离比如不同war包应用引入

了不同的spring版本这样实现就能加载各自的spring版本

---

WebAppClassLoader

我们先来看第 1 个问题假如我们使用 JVM 默认 AppClassLoader 来加载 Web 应用 AppClassLoader 只能加载一个 Servlet 类在加载第二个同名 Servlet 类时AppClassLoader 会返 回第一个 Servlet 类的 Class 实例这是因为在 AppClassLoader 看来同名的 Servlet 类只被加载 一次。

因此 Tomcat 的解决方案是自定义一个类加载器 WebAppClassLoader 并且给每个 Web 应用创建 一个类加载器实例。我们知道Context 容器组件对应一个 Web 应用因此每个 Context 容器负 责创建和维护一个 WebAppClassLoader 加载器实例。这背后的原理是不同的加载器实例加载的类 被认为是不同的类即使它们的类名相同。

SharedClassLoader我们再来看第 2 个问题本质需求是两个 Web 应用之间怎么共享库类并且不能重复加载相同的 类。Tomcat 的设计者又加了一个类加载器 SharedClassLoader作为 WebAppClassLoader 的父加 载器专门来加载 Web 应用之间共享的类。如果 WebAppClassLoader 自己没有加载到某个类就 会委托父加载器 SharedClassLoader 去加载这个类SharedClassLoader 会在指定目录下加载共享 类之后返回给 WebAppClassLoader这样共享的问题就解决了。

CatalinaClassloader

我们来看第 3 个问题如何隔离 Tomcat 本身的类和 Web 应用的类我们知道要共享可以通过父 子关系要隔离那就需要兄弟关系了。兄弟关系就是指两个类加载器是平行的它们可能拥有同一个 父加载器但是两个兄弟类加载器加载的类是隔离的。基于此 Tomcat 又设计一个类加载器 CatalinaClassloader专门来加载 Tomcat 自身的类。这样设计有个问题那 Tomcat 和各 Web 应用之间需要共享一些类时该怎么办呢

CommonClassLoader

老办法还是再增加一个 CommonClassLoader作为 CatalinaClassloader 和 SharedClassLoader 的父加载器。CommonClassLoader 能加载的类都可以被 CatalinaClassLoader 和 SharedClassLoader 使用而 CatalinaClassLoader 和 SharedClassLoader 能加载的类则与对方相 互隔离。WebAppClassLoader 可以使用 SharedClassLoader 加载到的类但各个 WebAppClassLoader 实例之间相互隔离。

Spring 的加载问题

全盘负责委托机制

“全盘负责”是指当一个ClassLoder装载一个类时除非显示的使用另外一个ClassLoder该类所依 赖及引用的类也由这个ClassLoder载入。 比如 Spring 作为一个 Bean 工厂它需要创建业务类的实例并且在创建业务类实例之前需要加载这 些类。Spring 是通过调用Class.forName来加载业务类的

---

我们在前面提到Web 应用之间共享的 JAR 包可以交给 SharedClassLoader 来加载从而避免重复 加载。Spring 作为共享的第三方 JAR 包它本身是由 SharedClassLoader 来加载的Spring 又要去 加载业务类按照前面那条规则加载 Spring 的类加载器也会用来加载业务类但是业务类在 Web 应用目录下不在 SharedClassLoader 的加载路径下这该怎么办呢

线程上下文加载器

于是线程上下文加载器登场了它其实是一种类加载器传递机制。为什么叫作“线程上下文加载器” 呢因为这个类加载器保存在线程私有数据里只要是同一个线程一旦设置了线程上下文加载器 在线程后续执行过程中就能把这个类加载器取出来用。因此 Tomcat 为每个 Web 应用创建一个 WebAppClassLoarder 类加载器并在启动 Web 应用的线程里设置线程上下文加载器这样 Spring 在启动时就将线程上下文加载器取出来用来加载 Bean。

cl = Thread.currentThread().getContextClassLoader();

线程上下文加载器不仅仅可以用在 Tomcat 和 Spring 类加载的场景里核心框架类需要加载具体 实现类时都可以用到它比如我们熟悉的 JDBC 就是通过上下文类加载器来加载不同的数据库驱动的

Tomcat热加载和热部署

在项目开发过程中经常要改动Java/JSP 文件但是又不想重新启动Tomcat有两种方式:热加载和热部署。热部署表示重新部署应⽤它的执行主体是Host。 热加载表示重新加载class它的执行主体是Context。

热加载在server.xml -> context 标签中 设置 reloadable=“true”

<Context docBase="D:\mvc" path="/mvc" reloadable="true" /> 

热部署在server.xml -> Host标签中 设置 autoDeploy=“true”

<Host name="localhost" appBase="webapps" unpackWARs="true" autoDeploy="true"> 

它们的区别是

热加载的实现方式是 Web 容器启动一个后台线程定期检测类文件的变化如果有变化就重新加载类在这个过程中不会清空 Session 一般用在开发环境。

热部署原理类似也是由后台线程定时检测 Web 应用的变化但它会重新加载整个 Web 应用。这种方式会清空 Session比热加载更加干净、彻底一般用在生产环境。