tomcat work 启动过程一

最新推荐文章于 2023-05-09 18:15:21 发布
最新推荐文章于 2023-05-09 18:15:21 发布
阅读量853 收藏 1
点赞数
文章标签： tomcat jmx command j2se java exception
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/frank3g/article/details/5668865
版权

一般，我们直接运行startup.sh 来启动Tomcat 。最终执行的命令是：

Java代码 复制代码
  1. java [options] org.apache.catalina.startup.Bootstrap start   
java [options] org.apache.catalina.startup.Bootstrap start

main方法

可见，Tomcat 的启动类是org.apache.catalina.startup.Bootstrap ，启动参数是start 。我们从该类的main 方法看起。

Java代码 复制代码
  1. public static void main(String args[]) {   
  2.   
  3.     try {   
  4.         // Attempt to load JMX class   
  5.         new ObjectName("test:foo=bar");   
  6.     } catch (Throwable t) {   
  7.         System.out.println(JMX_ERROR_MESSAGE);   
  8.         try {   
  9.             // Give users some time to read the message before exiting   
  10.             Thread.sleep(5000);   
  11.         } catch (Exception ex) {   
  12.         }   
  13.         return;   
  14.     }   
  15.   
  16.     if (daemon == null) {   
  17.         daemon = new Bootstrap();   
  18.         try {   
  19.             daemon.init();   
  20.         } catch (Throwable t) {   
  21.             t.printStackTrace();   
  22.             return;   
  23.         }   
  24.     }   
  25.   
  26.     try {   
  27.         String command = "start";   
  28.         if (args.length > 0) {   
  29.             command = args[args.length - 1];   
  30.         }   
  31.         if (command.equals("startd")) {   
  32.             args[0] = "start";   
  33.             daemon.load(args);   
  34.             daemon.start();   
  35.         } else if (command.equals("stopd")) {   
  36.             args[0] = "stop";   
  37.             daemon.stop();   
  38.         } else if (command.equals("start")) {   
  39.             daemon.setAwait(true);   
  40.             daemon.load(args);   
  41.             daemon.start();   
  42.         } else if (command.equals("stop")) {   
  43.             daemon.stopServer(args);   
  44.         } else {   
  45.             log.warn("Bootstrap: command /"" + command + "/" does not exist.");   
  46.         }   
  47.     } catch (Throwable t) {   
  48.         t.printStackTrace();   
  49.     }   
  50. }  
public static void main(String args[]) {

    try {
        // Attempt to load JMX class
        new ObjectName("test:foo=bar");
    } catch (Throwable t) {
        System.out.println(JMX_ERROR_MESSAGE);
        try {
            // Give users some time to read the message before exiting
            Thread.sleep(5000);
        } catch (Exception ex) {
        }
        return;
    }

    if (daemon == null) {
        daemon = new Bootstrap();
        try {
            daemon.init();
        } catch (Throwable t) {
            t.printStackTrace();
            return;
        }
    }

    try {
        String command = "start";
        if (args.length > 0) {
            command = args[args.length - 1];
        }
        if (command.equals("startd")) {
            args[0] = "start";
            daemon.load(args);
            daemon.start();
        } else if (command.equals("stopd")) {
            args[0] = "stop";
            daemon.stop();
        } else if (command.equals("start")) {
            daemon.setAwait(true);
            daemon.load(args);
            daemon.start();
        } else if (command.equals("stop")) {
            daemon.stopServer(args);
        } else {
            log.warn("Bootstrap: command /"" + command + "/" does not exist.");
        }
    } catch (Throwable t) {
        t.printStackTrace();
    }
}


上述代码主要分为三段：

  1. 第一段是检查JMX 支持
  2. 第二段创建Boostrap 实例并初始化
  3. 第三段根据启动参数，执行进一步操作

第一阶段

乍一看，第一段似乎可有可无。它只是创建了一个不被使用的ObjectName 对象，如果创建失败，就打印一条错误信息。而且在Tomcat 6 中，已经移除了这段代码。

Java代码 复制代码
  1. try {   
  2.     // Attempt to load JMX class   
  3.     new ObjectName("test:foo=bar");   
  4. } catch (Throwable t) {   
  5.     System.out.println(JMX_ERROR_MESSAGE);   
  6.     try {   
  7.         // Give users some time to read the message before exiting   
  8.         Thread.sleep(5000);   
  9.     } catch (Exception ex) {   
  10.     }   
  11.     return;   
  12. }  
    try {
        // Attempt to load JMX class
        new ObjectName("test:foo=bar");
    } catch (Throwable t) {
        System.out.println(JMX_ERROR_MESSAGE);
        try {
            // Give users some time to read the message before exiting
            Thread.sleep(5000);
        } catch (Exception ex) {
        }
        return;
    }


这段代码的作用是什么呢？这其实和J2SE 1.4 的兼容性有关。Tomcat 5 使用JMX 作为管理和监控机制，但是J2SE 1.4 本身并不支持JMX ，像ObjectName 这些JMX 类并不包括J2SE 1.4 的API 中。因此，Tomcat 5 不能直接运行在J2SE 1.4 及之前版本上。

但是Tomcat 5 的设计目标是支持运行在J2SE 1.4 上的。因此，要达到这个目标，Tomcat 5 须将JMX 类作为兼容包（compatibility package ）额外添加到Tomcat 启动类路径中。
我们有两种方法获得兼容包：

  1. 从Tomcat 的官方下载页面下载兼容包，参见http://tomcat.apache.org/download-55.cgi
  2. 从Tomcat 的源代码构建兼容包，参见http://jarfield.javaeye.com/blog/604198


不管怎样，Tomcat 5 不能保证用户安装了兼容包，因此在启动时，它首先检查能够加载ObjectName 类，以此判断兼容包是否安装。如果没有安装，则向标准输出打印一条错误信息：
This release of Apache Tomcat was packaged to run on J2SE 5.0 or later. It can be run on earlier JVMs by downloading and installing a compatibility package from the Apache Tomcat binary download page.

这条信息也就是第一段代码中JMX_ERROR_MESSAGE 变量的值。下面是Bootstrap 类声明该变量的代码：

Java代码 复制代码
  1. private static final String JMX_ERROR_MESSAGE =   
  2.         "This release of Apache Tomcat was packaged to run on J2SE 5.0 /n"  
  3.         + "or later. It can be run on earlier JVMs by downloading and /n"  
  4.         + "installing a compatibility package from the Apache Tomcat /n"  
  5.         + "binary download page.";  
private static final String JMX_ERROR_MESSAGE =
        "This release of Apache Tomcat was packaged to run on J2SE 5.0 /n"
        + "or later. It can be run on earlier JVMs by downloading and /n"
        + "installing a compatibility package from the Apache Tomcat /n"
        + "binary download page.";

 
那为什么Tomcat 6中移除了第一段代码，不检查兼容包是否安装了呢？原因很简单，Tomcat 6的设计目标并不包括J2SE 1.4及之前版本。

OK ，看完了第一段，我们进入正题，看看第二段代码。

 

第二阶段

Java代码 复制代码
  1. if (daemon == null) {   
  2.     daemon = new Bootstrap();   
  3.     try {   
  4.         daemon.init();   
  5.     } catch (Throwable t) {   
  6.         t.printStackTrace();   
  7.         return;   
  8.     }   
  9. }  
    if (daemon == null) {
        daemon = new Bootstrap();
        try {
            daemon.init();
        } catch (Throwable t) {
            t.printStackTrace();
            return;
        }
    }


可见，这段代码的主要逻辑在Bootstrap 的init 方法。该方法的工作包括：

  1. 设置Catalina （Tomcat Servlet 容器的代号）的路径：CATALINA_HOME 和CATALINA_BASE
  2. 初始化Tomcat 的类加载器体系
  3. 创建org.apache.catalina.startup.Catalina 对象（启动阶段剩余的工作由Catalina类 完成）


为了节省篇幅，init 方法的代码另文表述。下面我们看看第三段代码。

 

第三阶段

Java代码 复制代码
  1. try {   
  2.         String command = "start";   
  3.         if (args.length > 0) {   
  4.             command = args[args.length - 1];   
  5.         }   
  6.         if (command.equals("startd")) {   
  7.             args[0] = "start";   
  8.             daemon.load(args);   
  9.             daemon.start();   
  10.         } else if (command.equals("stopd")) {   
  11.             args[0] = "stop";   
  12.             daemon.stop();   
  13.         } else if (command.equals("start")) {   
  14.             daemon.setAwait(true);   
  15.             daemon.load(args);   
  16.             daemon.start();   
  17.         } else if (command.equals("stop")) {   
  18.             daemon.stopServer(args);   
  19.         } else {   
  20.             log.warn("Bootstrap: command /"" + command + "/" does not exist.");   
  21.         }   
  22.     } catch (Throwable t) {   
  23.         t.printStackTrace();   
  24.     }  
try {
        String command = "start";
        if (args.length > 0) {
            command = args[args.length - 1];
        }
        if (command.equals("startd")) {
            args[0] = "start";
            daemon.load(args);
            daemon.start();
        } else if (command.equals("stopd")) {
            args[0] = "stop";
            daemon.stop();
        } else if (command.equals("start")) {
            daemon.setAwait(true);
            daemon.load(args);
            daemon.start();
        } else if (command.equals("stop")) {
            daemon.stopServer(args);
        } else {
            log.warn("Bootstrap: command /"" + command + "/" does not exist.");
        }
    } catch (Throwable t) {
        t.printStackTrace();
    }


容易看出，这段代码的主要逻辑就是根据不同的启动参数，执行不同的工作。可以接受的启动参数包括4 种：startd stopd start stop 。

启动参数决定了启动还是停止Tomcat 。如何启动，如何停止，另文表述。本文问想讨论的问题是：除了start 和stop ，为什么还有startd 和stopd ？它们有什么区别呢？

 

启动参数的区别

我们先看看start 和startd 。处理start 的代码比startd 仅多了一行：

Java代码 复制代码
  1. daemon.setAwait(true);  
daemon.setAwait(true);

 

这行代码执行后，主线程（即main 函数所在的线程）在Tomcat 启动过程结束时并不会退出，而是监听SHUTDOWN 端口（默认端口是8005 ）。该端口如果接收SHUTDOWN 命令，就停止Tomcat ；如果收到的是其他命令，则忽略，继续监听。这样，我们就可以在Tomcat 进程之外通过网络停止Tomcat 。

如果以startd 参数启动Tomcat ，主线程会在启动结束时退出，只剩下主线程创建的其他线程（HTTP 监听线程、HTTP 请求线程、Tomcat 后台线程等）。这样，我们并不能通过网络停止Tomcat 。

如果启动参数是stop ，那么将调用Bootstrap类的stopServer 方法。该方法通过SHUTDOWN 端口向Tomcat 发送SHUTDOWN 命令，从而停止Tomcat 。shutdown.bat 就是通过这种方式关闭Tomcat ，它最终执行的命令是：
java [options] org.apache.catalina.startup.Bootstrap stop

如果启动参数是stopd，那么 Bootstrap将直接调用Catalina的stop方法，直接停止Tomcat。

综上所述，以start 启动，就以stop 停止；以startd 启动，就以stopd 停止。

如果将Tomcat 作为独立的进程运行，那么应该使用start 和stop ，这样我们就可以通过网络停止Tomcat 。

如果将Tomcat 以嵌入到应用进程的方式运行（例如Eclipse 中运行Tomcat ），那么应该使用startd 和stopd 。这样，宿主程序通过普通的方法调用，来启动和停止Tomcat 。

 

一个Bug

关于这4 个启动参数的讨论，可以参见Bug 47881 。这个Bug 的本意是要指出第三段代码的一个问题 ，不过恰好讨论了各种启动参数的区别。

至于这个Bug ，也比较明显：

  1. args[0] = "start"; 应该是 args[args.length - 1 ] = "start";
  2. args[0] = "stop"; 应该是 args[args.length - 1 ] = "stop";

这个Bug 已经在Tomcat 6 中解决了。

frank3G
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
tomcat服务器work文件夹说明
朱锡铭的博客
12-30 7230
问题 有些人把tomcat的work目录里的东西叫做缓存，其实那不是很恰当，work目录只是tomcat的工作目录，也就是tomcat把jsp转换为class文件的工作目录，这也正是为什么它叫work目录而不是cache目录的原因。 客户端访问jsp的流程： 当客户端第一次访问jsp时tomcat会在work目录里把这个jsp页面转换成.java文件，比如将index.jsp转换为i
how tomcat work
12-28
2. **启动过程**： Tomcat启动时，会读取`server.xml`配置文件，解析服务器的全局配置，如端口设置、连接器配置、Context定义等。然后初始化各个组件，建立监听套接字，等待客户端请求。 3. **请求处理**： - **...
tomcat的work目录
热门推荐
冯索的专栏
10-14 2万+
1    用tomcat作web服务器的时候，部署的程序在webApps下，这些程序都是编译后的程序（发布到tomcat的项目里含的类，会被编译成.class后才发布过来，源文件没有发布过来，但这里的jsp没有经编译的）。tomcat有一个work目录，里面存放了页面的缓存，访问的jsp都会编译（从 work里进入Catalina后的如localhost站点文件夹下的项目，我们可以看到那些js
tomcat下的work目录
数据库天地
06-30 123
最近发现，很多网友喜欢把tomcat的work目录里的东西叫做缓存，其实那不是很恰当，work目录只是tomcat的工作目录，也就是tomcat把jsp转换为class文件的工作目录，这也正是为什么它叫work目录而不是cache目录的原因。 　　 tomcat的工作原理是当浏览器访问某个jsp页面时，tomcat会在work目录里把这个jsp页面转换成.java文件，比如将index.j...
浅析tomcat中的work目录
辛星，前进的路上.
06-23 721
用tomcat作web服务器的时候，部署的程序在webapps下。 这些程序都是编译后的程序（发布到tomcat的项目里含的类，会被编译成.class，但这里的jsp没有经编译的）。 tomcat有一个work目录，里面存放了页面的缓存。 访问的jsp都会编译，那些jsp页面会被编译成应该是servlet文件。 下次再来 访问时，就直接运行servlet类就可以向客户端反应响应页面了。
tomcat启动闪退
12-19
在使用Tomcat过程中，经常遇到的一个问题是“启动闪退”。所谓“启动闪退”，通常指的是在尝试启动Tomcat时，双击`startup.bat`后，启动窗口快速出现然后立即关闭，且通过检查可以发现Tomcat服务并未正常启动。这种...
HowTomcatWork 源代码
08-18
1. **Tomcat架构概述** Tomcat的架构主要包括四个主要部分：Catalina（核心处理引擎）、 Jasper（JSP编译器）、Juli（日志系统）和 Coyote（HTTP/1.1连接器）。Catalina负责管理Servlet容器，Jasper处理JSP文件的...
How Tomcat Work 电子书+源码
03-28
1. **启动过程**：Tomcat在启动时会加载服务器配置文件（如server.xml），解析并构建服务器的内部结构，包括Connector、Executor、Engine、Host和Context等组件。 2. **HTTP连接器**：Tomcat通过Connector接收HTTP...
Tomcat启动时报错：java.lang.UnsatisfiedLinkError的解决
08-30
在日常开发和运维过程中，遇到Tomcat启动时报错“java.lang.UnsatisfiedLinkError”可能会让开发者感到困扰，尽管这种错误并不直接影响项目的正常运行，但对于追求完美和代码健康的程序员来说，这无疑是一种无法忽视...
清空Tomcat中的work目录并重启Tomcat.bat
08-15
清空Tomcat中的work目录并重启Tomcat.bat，为java开发提供方便！！！ 注意修改work目录
Tomcat根目录下work文件夹的作用
技术黑板
09-19 937
work目录只是tomcat的工作目录，也就是tomcat把jsp转换为class文件的工作目录     jsp，tomcat的工作原理：     当浏览器访问某个jsp页面时，tomcat会在work目录里把这个jsp页面转换成.java文件，比如将index.jsp转换为index_jsp.java文件，而后编译为index_jsp.class文件，最后tomcat容器通过Clas
Tomcat的server.xml中Host、Context的关系，以及work文件夹作用
fight_zzc的博客
12-18 1345
Tomcat的server.xml中Host、Context的关系，以及work文件夹作用
tomcat\work\下Catalina是干什么用的？
小宇宙的博客
12-15 2580
Tomcat Catalina下的文件 是tomcat编译你的项目后，产生的文件， 也就是你的项目的class文件（如果不是java文件，则直接复制，比如jsp等） 也就是说，你把项目的原文件放入webapps，当tomcat启动的时候，就会把 这个文件夹下的项目，进行编译，然后存放到Catalina目录下， 当别人访问的时候，就是访问这里的文件 当用户第一次访问一个jsp页面...
Tomcat的介绍与使用
最新发布
qq_51764257的博客
05-09 193
成为目前比较流行的Web 应用服务器。实际上Tomcat是Apache 服务器的扩展，但运行时它是独立运行的，所以当你运行tomcat 时，它实际上作为一个与Apache 独立的进程单独运行的。
清除Tomcat项目缓存
m0_54850825的博客
08-30 4284
（3）找到tomcat下的temp目录，进入temp目录，将temp目录下的对应项目文件夹删掉；（2）进入tomcat目录下的work文件夹，删掉Catalina目录及其目录下所有文件；（2）找到tomcat安装目录，进入work目录，将work目录下的所有东西都删掉；（4）清除浏览器缓存，重启tomcat，运行startup.sh文件，运行项目。（3）进入tomcat目录下的temp目录，同理，将对应项目文件夹递归删除；（4）清除浏览器缓存，重启tomcat，运行项目。（1）先关闭tomcat；...
Tomcat下work目录的作用
MazenChan的博客
09-14 1585
1.work目录的作用 work目录是tomcat的工作目录。对于jsp来说，tomcat的工作原理是当浏览器访问某个jsp页面时，tomcat会在work目录里把这个jsp页面转换成.java文件，比如将index.jsp转换为index_jsp.java文件，而后编译为index_jsp.class文件，最后tomcat容器通过ClassLoader类把这个index_jsp.class类装...
tomcat中的work目录
乱七八糟
08-16 405
问题：本地测试查看页面和现网查看的页面不一致，删除现网tomcat中work目录下的相应jsp的.class/.java后缀文件，恢复正常。         发现，很多网友喜欢把tomcat的work目录里的东西叫做缓存，其实那不是很恰当，work目录只是tomcat的工作目录，也就是tomcat把jsp转换为class文件的工作目录，这也正是为什么它叫work目录而不是cache目录的原因。...
Tomcat webapps与work的区别
每天进步一点点 时间会让你成为巨人
08-20 5907
webapps:是部署web应用的目录,是web applications的缩写.可以在conf目录下server.xml中进行配置,这样就不必将web应用部署在webapps目录下. work:是web应用发布后,经过第一次运行将你的文件进行编译,不管你的web应用放在哪个目录,经过编译后的文件都会放在这个目录下.
Tomcat安装配置全攻略
"这篇教程将指导你如何安装和配置Tomcat，Tomcat是一个开源的Servlet容器，由Apache基金会的Jakarta项目维护，...以上就是安装和配置Tomcat的基本步骤，通过这个过程，你可以搭建起一个本地的Servlet和JSP开发环境。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值