热加载和热部署,没听过?看看 Tomcat 是怎么实现的

本文涉及的产品
可观测可视化 Grafana 版,10个用户账号 1个月
性能测试 PTS,5000VUM额度
可观测监控 Prometheus 版,每月50GB免费额度
简介: 热部署就是在服务器运行时重新部署项目,热加载即在在运行时重新加载class,从而升级应用。通常情况下在开发环境中我们使用的是热加载,因为热加载的实现的方式在Web容器中启动一个后台线程,定期检测相关文件的变化,如果有变化就重新加载类,这个过程不会清空Session。而在生产环境我们一般应用的是热部署,热部署也是在Web应用后台线程定期检测,发现有变化就会重新加载整个Web应用,这种方式更加彻底会清空Session。

热部署就是在服务器运行时重新部署项目,热加载即在在运行时重新加载class,从而升级应用。

通常情况下在开发环境中我们使用的是热加载,因为热加载的实现的方式在Web容器中启动一个后台线程,定期检测相关文件的变化,如果有变化就重新加载类,这个过程不会清空Session。而在生产环境我们一般应用的是热部署,热部署也是在Web应用后台线程定期检测,发现有变化就会重新加载整个Web应用,这种方式更加彻底会清空Session。

热加载

热加载其实我们在开发过程中经常使用,例如我们使用Idea开发时,我们在设置页面可以进行设置,当修改文件时,我们可以选择不重启项目,选择重新加载此文件。而在Tomcat中也能设置,Tomcat默认情况下是不开启热加载的。需要在Tomcat路径下的Context.xml中配置reloadable参数来开启这个功能。

<Context reloadable="true"/>
复制代码

我们演示一下Tomcat是如何热加载的。在webapp下我们新建了一个项目,里面的Servlet文件如下

public class MyServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        System.out.println("MyServlet 在处理 get()请求...");
        PrintWriter out = response.getWriter();
        response.setContentType("text/html;charset=utf-8");
        out.println("<strong>>My Servlet Version1!</strong><br>");
    }
    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        System.out.println("MyServlet 在处理 post()请求...");
        PrintWriter out = response.getWriter();
        response.setContentType("text/html;charset=utf-8");
        out.println("<strong>>My Servlet Version1!</strong><br>");
    }
}
复制代码

目录结构如下

-webapp
  -- mywebapp
    -- WEB-INF
      -- web.xml
      -- classes
        -- MyServlet.class
复制代码

为了演示Tomcat运行时能修改class文件能够动态加载。我们分为以下三步

  1. 正常启动Tomcat。输入http://localhost:8080/mywebapp/myservlet,观察页面输出
  2. 在Tomcat启动的情况下修改MyServlet文件后覆盖原来的class文件
  3. 再次观察页面情况。观察页面输出是否修改

下面直接用动态图演示效果,更直观一些。

我们可以看到在Tomcat运行的情况下,直接替换class文件是能够直接生效的。那么Tomcat是如何做到的呢?其实我们可以自己推导一下。

  1. 所有的class文件都是交由类加载来管理的
  2. 如果换了class文件是不是只需要更换相应的类加载器重新加载就行

那么接下来我们来验证我们的结论,看一下在Tomcat中是如何实现热加载的。Tomcat要监听class文件是否变化应该是新起了一个线程来观测。那么看到在Context的启动方法中,看到调用了threadStart的方法。

protected void threadStart() {
        backgroundProcessorFuture = Container.getService(this).getServer().getUtilityExecutor()
                .scheduleWithFixedDelay(new ContainerBackgroundProcessor(),//要执行的Runnable
                        backgroundProcessorDelay, //第一次执行延迟多久
                        backgroundProcessorDelay, //之后每次隔多久执行一次
                        TimeUnit.SECONDS); //时间单位
    }
}
复制代码

其中在后台开启周期性的任务,使用了Java提供的
ScheduledThreadPoolExecutor。除了能周期性执行任务以外还有线程池的功能。上面代码中调用了scheduleWithFixedDelay方法,第一个传入的参数就是要执行的任务。我们接下来看任务类ContainerBackgroundProcessor是如何实现的。

protected class ContainerBackgroundProcessor implements Runnable {
    @Override
    public void run() {
        // 请注意这里传入的参数是 " 宿主类 " 的实例
        processChildren(ContainerBase.this);
    }
    protected void processChildren(Container container) {
        try {
            //1. 调用当前容器的 backgroundProcess 方法。
            container.backgroundProcess();
            //2. 遍历所有的子容器,递归调用 processChildren,
            // 这样当前容器的子孙都会被处理            
            Container[] children = container.findChildren();
            for (int i = 0; i < children.length; i++) {
            // 这里会判断子容器如果已经启动了后台线程,那么这里就不会启动了
                if (children[i].getBackgroundProcessorDelay() <= 0) {
                    processChildren(children[i]);
                }
            }
        } catch (Throwable t) { ... }
复制代码

上面代码中我们可以知道具体的后台监听代码是在backgroundProcess方法中实现的。那么我们看Context容器的backgroundProcess方法是如何实现的。

public void backgroundProcess() {
    //WebappLoader 周期性的检查 WEB-INF/classes 和 WEB-INF/lib 目录下的类文件
    Loader loader = getLoader();
    if (loader != null) {
        loader.backgroundProcess();        
    }
    ............省略
}

进去loader.backgroundProcess();中我们可以看到

public void backgroundProcess() {
    //此处判断热加载开关是否开启和监控的文件夹中文件是否有修改
    if (reloadable && modified()) {
        try {
            Thread.currentThread().setContextClassLoader
                (WebappLoader.class.getClassLoader());
            if (context != null) {
                //Context重启
                context.reload();
            }
        } finally {
            if (context != null && context.getLoader() != null) {
                Thread.currentThread().setContextClassLoader
                    (context.getLoader().getClassLoader());
            }
        }
    }
}

我们可以发现Tomcat热加载的步骤

  1. 如果发现有文件发生变化,热加载开关开启
  2. 关闭Context容器
  3. 重启Context容器

在这个过程中,最重要的部分其实就是类加载器了。因为一个Context容器对应一个类加载器。所以在销毁Context容器的时候也连带着将其类加载器一并销毁了。Context在重启的过程中也会创建新的类加载器来加载我们新建的文件。

热部署

如果还是不懂热部署是什么的,下面演示一遍应该就明白了。Tomcat在启动的时候会将其目录下webapp中war包解压后然后封装为一个Context供外部访问。那么热部署就是在程序运行时,如果我们修改了War包中的东西。那么Tomcat就会删除之前的War包解压的文件夹,重新解压新的War包。

我们发现上面动图中在Tomcat运行时,我们修改了War包的信息,它就会将原来的删除然后重新生成一份。

我们从上面的动图中其实就看出了热部署和热加载的区别了。热部署是将文件夹删除然后重新解压包。那么热加载是由Context容器负责的。那么热部署又是由哪个容器负责呢?因为一个文件夹对应一个Context。既然文件夹都删除了,那么肯定不是由Context容器负责了。那么应该就是Context的父容器Host来负责。

我们可以看到Host容器并没有实现自己的backgroundProcess方法。那么它是如何监听的呢?既然它没有实现方法,肯定是调用了父类的backgroundProcess方法。我们可以看到在父类的backgroundProcess中

@Override
    public void backgroundProcess() {
      . ...........省略
        fireLifecycleEvent(Lifecycle.PERIODIC_EVENT, null);
    }

可以看到周期事件的监听器。而Host的事件监听器是HostConfig类的lifecycleEvent方法

@Override
    public void lifecycleEvent(LifecycleEvent event) {
        if (event.getType().equals(Lifecycle.PERIODIC_EVENT)) {// 周期事件
            check();
        } else if (event.getType().equals(Lifecycle.BEFORE_START_EVENT)) {// 开始之前事件
            beforeStart();
        } else if (event.getType().equals(Lifecycle.START_EVENT)) { // 开始事件
            start();
        } else if (event.getType().equals(Lifecycle.STOP_EVENT)) { // 结束事件
            stop();
        }
    }

我们可以看check方法

protected void check() {
    if (host.getAutoDeploy()) {
        // 检查Host下所有已经部署的web应用
        DeployedApplication[] apps =
            deployed.values().toArray(new DeployedApplication[0]);
        for (int i = 0; i < apps.length; i++) {
            if (!isServiced(apps[i].name))
                checkResources(apps[i], false);
        }
        // 检查Web应用是否有变化
        if (host.getUndeployOldVersions()) {
            checkUndeploy();
        }
        // 执行部署
        deployApps();
    }
}
复制代码

热部署的步骤其实也可以简化为三步骤

  1. 检查Host管理下的所有web应用
  2. 如果原来的Web应用被删除,就将相应Context容器删除
  3. 如果有新War包放进来,就部署相应的War包

本文就是愿天堂没有BUG给大家分享的内容,大家有收获的话可以分享下,想学习更多的话可以到微信公众号里找我,我等你哦。

相关文章
|
JSON Java 应用服务中间件
Maven集成Tomcat插件+远程热部署项目
插件和依赖的区别: 依赖:运行时开发时都需要用到的jar包,比如项目中需要一个Json的jar包,就要添加一个依赖,这个依赖在项目运行时也需要,因此在项目打包时需要把这些依赖也打包进项目里; 插件:在项目开的发时需要,但是在项目运行后就不再需要,因此在项目开发完成后不需要把插件打包进项目中,例如接下来演示的Tomcat插件就是用来部署Web项目的,部署成功
|
IDE Java 应用服务中间件
IDEA/Tomcat 原理:如何将 Tomcat 集成到 IDEA?实现由传统部署延伸到热部署 Java EE 项目?
IDEA/Tomcat 原理:如何将 Tomcat 集成到 IDEA?实现由传统部署延伸到热部署 Java EE 项目?
152 0
IDEA/Tomcat 原理:如何将 Tomcat 集成到 IDEA?实现由传统部署延伸到热部署 Java EE 项目?
|
应用服务中间件
Intellij IDEA配置tomcat热部署
idea2017+tomcat8为本文的实验环境 1.打开tomcat的edit configuration,一定要选择war exploded    在idea tomcat 中server的配置里,有个on frame deactivation,选择update classes and resources。
1668 0
|
前端开发 应用服务中间件
IDEA实现热部署前端界面(Tomcat、IDEA)
IDEA实现热部署前端界面(Tomcat、IDEA)
427 0
IDEA实现热部署前端界面(Tomcat、IDEA)
|
前端开发 JavaScript Java
IntelliJ IDEA - 热部署(更新HTML/JSP/JS/CSS代码、不用重启Tomcat)
IntelliJ IDEA - 热部署(更新HTML/JSP/JS/CSS代码、不用重启Tomcat)
1637 0
IntelliJ IDEA - 热部署(更新HTML/JSP/JS/CSS代码、不用重启Tomcat)
|
Java 应用服务中间件 Android开发
tomcat 热部署的实现
tomcat 热部署的实现
187 0
tomcat 热部署的实现
|
Java 应用服务中间件 Android开发
IDEA 出现问题:tomcat热部署没反应解决方案(JAVA 小虚竹,建议收藏)
IDEA 出现问题:tomcat热部署没反应解决方案(JAVA 小虚竹,建议收藏)
712 0
IDEA 出现问题:tomcat热部署没反应解决方案(JAVA 小虚竹,建议收藏)
|
应用服务中间件 容器
Tomcat实现热部署、热加载原理解析(下)
Tomcat实现热部署、热加载原理解析
446 0
|
应用服务中间件 Spring Java
Idea开发Tomcat应用的热部署配置
早先的时候提到过Spring Boot的静态资源文件热加载,有时一些早期的项目采用的是Tomcat进行开发,如果没有热部署,开发效率真的大打折扣。 这次说说在Idea开发Tomcat的时候如何实现热部署 步骤 步骤1 步骤2 就这样,想想就这几个基本的步骤,没有任何难度,然而这多掌握的一点点知识就能比不会的人省下很多时间。
|
Java 应用服务中间件
intellij idea tomcat热部署配置
1.设置Debugger-HotSwap 在setting界面,打开Debugger-HotSwap选项,确保勾选了Build project before reloading classes,同时选择Reload classes after compilation为Always。
2220 0