• 极客专栏正式上线!欢迎访问 https://www.jikewenku.com/topic.html
  • 极客专栏正式上线!欢迎访问 https://www.jikewenku.com/topic.html

最通俗易懂的Tomcat源码分析——初始化与启动

技术杂谈 勤劳的小蚂蚁 2个月前 (02-08) 62次浏览 已收录 0个评论 扫描二维码

一 前言

1.1、 问题思考

在阅读tomcat源码前,我们一般都会有如下几个疑问:
  • web容器和servlet容器的区别是什么;
  • 在springMVC中的web.xml是什么时候加载到tomcat中的;
  • tomcat是怎么加载我们的web服务的;
  • tomcat是怎么实现的热部署;
  • 一个http请求是怎么被tomcat监听到的,会有哪些处理;
  • 为什么请求可以有需要通过nginx的,也可以不需要nginx的直接请求到tomcat上? ……
如果你想知道答案,那么接下来的文章会告诉你。

1.2、 基本姿势

问题先放在一边,我们都知道Tomcat是一种web容器,用来接收http请求,并将请求得到的结果返回。那么如果要我们设计一个web容器,该怎么做?
很自然的会想到,要有一个网络连接通信维护者和一个请求处理者。通信维护者能够监听到请求并返回数据;请求处理者能够将请求进行分解处理,得到请求应该返回的数据。 如果你的思路是这样的,那么恭喜你,你看源码会简单很多,因为 Tomcat 的设计核心就是这样的,由两大组件组成:Connector 和 Container。Connector负责的是底层的网络通信的实现,而Container负责的是上层servlet业务的实现。
阅读源码前的准备工作:tomcat源码下载,http://tomcat.apache.org/download-70.cgi
下载好源码后导入eclipse。Tomcat7.0工程是用 ant 构建的,在导入eclipse的时候可以选择 file-new-project-java project from existing ant buildfile 导入即可。
也许你会猴急,希望快点知道 Connector 和 Container 是怎么设计和实现的,不过我要掉你胃口了,先得给你讲讲 Tomcat 启动过程,因为只有知道了 Tomcat 启动过程,才能对 Connector 和 Container 是怎么初始化的了然于胸,知道了 Connector 和 Container 的初始化才能准确的把握其结构。

Tomcat 启动

2.1、 从main看起

我们从main入手看看到底做了什么
  1. publicstaticvoid main(String args[]){
  2.    if(daemon ==null){
  3.        // Don't set daemon until init() has completed
  4.        Bootstrap bootstrap =newBootstrap();                               // 1.创建当前的 Bootstrap 类型的对象
  5.        try{
  6.            bootstrap.init();                                            // 2. 初始化整个系统中用到的几个 classLoader, 并设置父子关系, 创建 org.apache.catalina.startup.Catalina 对象, 设置其 parentClassLoader 为shareClassLoader, 为创建 WebappClassLoader 做准备
  7.        }catch(Throwable t){
  8.            handleThrowable(t);
  9.            t.printStackTrace();
  10.            return;
  11.        }
  12.        daemon = bootstrap;                                         // 3. 保存当前引用到静态变量
  13.    }else{
  14.        // When running as a service the call to stop will be on a new
  15.        // thread so make sure the correct class loader is used to prevent
  16.        // a range of class not found exceptions.
  17.        Thread.currentThread().setContextClassLoader(daemon.catalinaLoader);
  18.    }
  19.                                                                   // 4. 程序运行到这边时 Thread.currentThread().contextClassLoader 就是 catalinaClassLoader 了(在 bootstrap.init() 里面进行了设置), 下面的所有加载 class操作, 都是由这个 classloader 来进行加载 (PS: 则在 Tomcat 8.0.x 里面, 这里的 catalinaClassLoader 其实就是 commonClassLoader)
  20.    try{
  21.        String command ="start";                                  // 5. 默认命令参数
  22.        if(args.length >0){                                     // 6. 这里可能是其他的参数, 但默认命令就是 start
  23.            command = args[args.length -1];
  24.        }
  25.        if(command.equals("startd")){                            // 7. 启动 Tomcat (PS: 这种方式, Tomcat 启动过后会立刻 关闭, 主要是 Catalina 里面的 await = false )
  26.            args[args.length -1]="start";
  27.            daemon.load(args);
  28.            daemon.start();
  29.        }elseif(command.equals("stopd")){                      // 8. 停止 Tomcat
  30.            args[args.length -1]="stop";
  31.            daemon.stop();
  32.        }elseif(command.equals("start")){
  33.            daemon.setAwait(true);                                 // 9. 通过更改 Catalina 里面的 await 值, 在 Tomcat start 执行时, 程序会 hold 住, 直到有向 Tomcat 发送 stop 命令, 程序才会停止 (详情见 Catalina.start() 方法最后那部分)
  34.            daemon.load(args);                                     // 10. 直接调用 Catalina.load 方法, 进行初始化 各个文件, 命名服务, 用 Digester 来解析 XML 文件, 并且  init Tomcat 容器里面的各个组件
  35.            daemon.start();                                        // 11. 启动当前 bootstrap 对象, 其实主要是通过反射调用前面生成的 org.apache.catalina.startup.Catalina 的 start 方法
  36.        }elseif(command.equals("stop")){                       // 12. 停止 Tomcat (最终还是调用 StandardServer.stop())
  37.            daemon.stopServer(args);
  38.        }elseif(command.equals("configtest")){                 // 13. 这个只是 将 Tomcat 的配置文件加载进来, 通过反射调用 Catalina.init, 从而检测 程序对应的配置文件是否正确
  39.            daemon.load(args);
  40.            if(null==daemon.getServer()){
  41.                System.exit(1);
  42.            }
  43.            System.exit(0);
  44.        }else{
  45.            log.warn("Bootstrap: command ""+ command +"" does not exist.");
  46.        }
  47.    }catch(Throwable t){                                     // 抛出异常一直退出
  48.        // Unwrap the Exception for clearer error reporting
  49.        if(t instanceofInvocationTargetException&&
  50.                t.getCause()!=null){
  51.            t = t.getCause();
  52.        }
  53.        handleThrowable(t);
  54.        t.printStackTrace();
  55.        System.exit(1);
  56.    }
  57. }
上面的 main 主要strong text做了3件事情:
  1. 创建 Bootstrap 对象
  2. 调用bootstrap做一些初始化的操作(主要是 classloader 的创建)
  3. 更具命令行传来的参数start -> 先后通过反射来调用 Catalina 类的 load, 与 start 方法.

2.2、实例化Boostrap对象

调用Boostrap的init方法主要完成三件事:
(1)初始化路径:设置HOME和Base路径,其中HOME是tomcat安装目录,Base是tomcat工作目录;如果我们想要运行Tomcat 的 多个实例,但是不想安装多个Tomcat软件副本。那么我们可以配置多个工作 目录,每个运行实例独占一个工作目录,但是共享同一个安装目录。
(2)初始化类加载器:初始化Tomcat类加载器:catalinaLoader、sharedLoader commonLoader无父加载器,catalinaLoader和sharedLoader的父加载器都是commonLoader,commonLoader的父加载器就是系统类加载器。其中若tomcat的配置文件没有配置:server.loader则catalinaLoader=commonLoader,同理,没配置shared.loader……,这三种都是URLClassLoader,使用Java 中的安全模型。 Tomcat 的类加载器体系如下结构所示:
(3)初始化Boostrap的Catalina对象:通过反射生成Catalina对象,并通过反射调用setParentClassLoader方法设置其父 ClassLoader为sharedLoader。为什么要用反射,不直接在声明的时候生成对象?使用反射来生成实例的原因是因为在tomcat的发展历史中可以不止Catalina一种启动方式,现在看代码已经没必要了。
(4)其他:主线程的classLoader设置为catalinaLoader,安全管理的classLoad设置为catalineLoader。
  1. publicvoid init()
  2.        throwsException
  3.    {
  4.        //设置系统变量CATALINA_HOME和CATALINA_BASE
  5.        setCatalinaHome();
  6.        setCatalinaBase();
  7.        //初始化classLoader
  8.        initClassLoaders();
  9.        Thread.currentThread().setContextClassLoader(catalinaLoader);//主线程的classLoader
  10.        SecurityClassLoad.securityClassLoad(catalinaLoader);
  11.        // Load our startup class and call its process() method
  12.        if(log.isDebugEnabled())
  13.            log.debug("Loading startup class");
  14.        Class<?> startupClass =
  15.            catalinaLoader.loadClass
  16.            ("org.apache.catalina.startup.Catalina");
  17.        Object startupInstance = startupClass.newInstance();
  18.        //TODO:使用反射来生成实例的原因是因为在tomcat的发展历史中可以不止Catalina一种启动方式,现在看代码已经没必要了
  19.        // Set the shared extensions class loader
  20.        if(log.isDebugEnabled())
  21.            log.debug("Setting startup class properties");
  22.        String methodName ="setParentClassLoader";
  23.        Class<?> paramTypes[]=newClass[1];
  24.        paramTypes[0]=Class.forName("java.lang.ClassLoader");
  25.        Object paramValues[]=newObject[1];
  26.        paramValues[0]= sharedLoader;
  27.        Method method =
  28.            startupInstance.getClass().getMethod(methodName, paramTypes);
  29.        method.invoke(startupInstance, paramValues);
  30.        //TODO:设置catalina的父classLoader为sharedLoader        
  31.        catalinaDaemon = startupInstance;
  32.    }

2.3、Boostrap的load方法

调用Catalina的load方法。通过参数判断设置一些条件并判断是否立即加载,加载调用load方法主要做了4件事:
  1. 判断系统变量catalina设置HOME和Base路径是否设置,没有的话则设置一下(感觉像是烂代码啊,在Boostrap初始化的时候不是已经设置过一次吗?为什么不写在一起?)
  2. 初始化命名服务的基本配置
  3. Digester类,默认将conf/server.xml解析成相应的对象,这个解析很重要,因为是他完成了Connector和Container的初始化工作。先mark下,接下来会详细的介绍Digester是怎么完成Connector和Container的初始化,现在我们只要知道是这里完成的就可以了。
  4. Server调用init初始化声明周期,其父类LifecycleMBeanBase实现

  1. //去掉了一些无用的代码
  2. publicvoid load(){
  3.        long t1 =System.nanoTime();
  4.        // CATALINA_BASE和CATALINA_HOME设置
  5.        initDirs();
  6.        // 初始化命名服务的基本配置
  7.        initNaming();
  8.        //Digester类,主要用于处理xml配置文件,将xml文件转换成对应的java对象(默认为conf/server.xml)  
  9.        Digester digester = createStartDigester();
  10.        InputSource inputSource =null;
  11.        InputStream inputStream =null;
  12.        File file =null;
  13.        try{
  14.            try{
  15.                // 配置文件,由命令行参数-config指定,否则取默认值conf/server.xml  
  16.                file = configFile();
  17.                inputStream =newFileInputStream(file);
  18.                inputSource =newInputSource(file.toURI().toURL().toString());
  19.            }
  20.            try{
  21.                inputSource.setByteStream(inputStream);
  22.                //将cataline对象压栈,如果栈为空,则设置root为cataline对象
  23.                digester.push(this);
  24.                //遇到相应的应用对对象赋值,相应的调用则调用
  25.                digester.parse(inputSource);
  26.            }
  27.        }
  28.        getServer().setCatalina(this);
  29.        // Stream redirection
  30.        initStreams();
  31.        // Start the new server
  32.        try{
  33.            getServer().init();
  34.        }
  35.        ……
  36.    }

2.4、 Boostrap的start方法

调用Catalina的start方法:
  1. Server加载:Server才是正真的tomcat服务执行者,包括Connector和Container。调用load方法;
  2. 调用Server的start方法,最终调用的是StandardServer的startInternal方法,调用自己所有的Service的start方法,启动connector和container、excutor的start方法,后文会继续扩展。
  3. 注册钩子
  1. publicvoid start(){
  2.        try{
  3.            //服务启动
  4.            getServer().start();
  5.        }
  6.        ……
  7.        // Register shutdown hook
  8.        if(useShutdownHook){
  9.            if(shutdownHook ==null){
  10.                shutdownHook =newCatalinaShutdownHook();
  11.            }
  12.            Runtime.getRuntime().addShutdownHook(shutdownHook);
  13.            LogManager logManager =LogManager.getLogManager();
  14.            if(logManager instanceofClassLoaderLogManager){
  15.                ((ClassLoaderLogManager) logManager).setUseShutdownHook(
  16.                        false);
  17.            }
  18.        }
  19.        if(await){
  20.            await();
  21.            stop();
  22.        }
  23.    }
可以看到,Boostrap调用Catalina的方法时,全部都用的是反射,包括生成Catalina对象。而tomcat的启动说白了其实就是初始化并启动Connector和Container。


丨极客文库, 版权所有丨如未注明 , 均为原创丨
本网站采用知识共享署名-非商业性使用-相同方式共享 3.0 中国大陆许可协议进行授权
转载请注明原文链接:最通俗易懂的Tomcat源码分析——初始化与启动
喜欢 (0)
[247507792@qq.com]
分享 (0)
勤劳的小蚂蚁
关于作者:
温馨提示:本文来源于网络,转载文章皆标明了出处,如果您发现侵权文章,请及时向站长反馈删除。

您必须 登录 才能发表评论!

  • 精品技术教程
  • 编程资源分享
  • 问答交流社区
  • 极客文库知识库

客服QQ


QQ:2248886839


工作时间:09:00-23:00