Tomcat架构中各个组件及组件间关系

前言
借着上次对Tomcat类加载机制的分析，就想着看都看了，何不再看看Tomcat内部的实现原理和架构设计，向优秀的源码学习。Tomcat相较于其他的web容器，比如Jetty，要更加的复杂，内部应用了很多优秀的设计模式和思想，一上来就一头扎进源码进行分析并不是特别好的学习方式，因此，本文在借鉴其他文章、书籍的基础上，从大家都熟悉的server.xml配置文件入手，循序渐进的分析。文章主要的篇章布局是：

• 分析server.xml配置文件中的常用标签，引出Tomcat中的对应组件
• 给出比较全面的Tomcat架构图，和上面的分析相互印证
• 从源码的角度分析组件是如何被Tomcat所加载的
  由于Tomcat相关的内容比较繁杂，很难在一篇文章内讲清楚所有重要的内容，因此，本文重点在于核心组件的“静态”分析，在代码层面类与类之间是如何组合的。本文依然依赖于Tomcat7版本的源码，读者需要先搭建对应的测试环境

1. Tomcat配置文件server.xml标签解析

相信大部分Javaer都用过Tomcat作为web容器，那么对于其中的server.xml肯定也不陌生，其中配置了Tomcat启动要加载的各种组件

从上面标准的server.xml中可以看出，作为顶层标签，下面的子标签有、、三个，我们猜测Tomcat中必定有一种类对应标签，同时也会存在三种类 (为什么不说三个类，因为可能存在一对多的关系) 对应下面的子标签，而父子之间的关系可能通过组合的关系联系在一起。同样的，也可以推理出存在、、、、、、、这几个标签对应的类，他们之间的关系也可以根据标签之间的“父子”关系推断出来

2. Tomcat整体架构图

我找了一张比较完整的Tomcat架构图，通过真正的抽象化架构来评判上面我们推断的合理性，有什么遗漏的地方，或错误的地方

图1. Tomcat架构

从图中可以看到，大部分的组件都与 server.xml中标签有着对应关系，比如 对应图中的Server组件，该组件是Tomcat的顶层组件，其中包含一个或者多个Service组件，正如 中包含一个或多个 子标签一样，但即便如此，我们仍需要着重看一下代码层面的实现，毕竟这才是验证理论最可靠的途径

3. 代码层面实现

首先我们要看一下server.xml是如何被加载进Tomcat容器中，在违反ClassLoader双亲委派机制三部曲第二部——Tomcat类加载机制中，我们知道了Tomcat的是通过Bootstrap.java的main(String args[])启动的，代码清单1

public static void main(String args[]) {

        if (daemon == null) {
            // Don't set daemon until init() has completed
            Bootstrap bootstrap = new Bootstrap();
            try {

                //     (1)
                bootstrap.init();
            } catch (Throwable t) {
                handleThrowable(t);
                t.printStackTrace();
                return;
            }
            //      (2)
            daemon = bootstrap;
        } else {
            // When running as a service the call to stop will be on a new
            // thread so make sure the correct class loader is used to prevent
            // a range of class not found exceptions.
            Thread.currentThread().setContextClassLoader(daemon.catalinaLoader);
        }

        try {
            String command = "start";
            if (args.length > 0) {
                command = args[args.length - 1];
            }

            if (command.equals("startd")) {
                args[args.length - 1] = "start";
                daemon.load(args);
                daemon.start();
            } else if (command.equals("stopd")) {
                args[args.length - 1] = "stop";
                daemon.stop();
            } 
            //      (3)
            else if (command.equals("start")) {
                daemon.setAwait(true);
                daemon.load(args);
                daemon.start();
            } else if (command.equals("stop")) {
                daemon.stopServer(args);
            } else if (command.equals("configtest")) {
                daemon.load(args);
                if (null==daemon.getServer()) {
                    System.exit(1);
                }
                System.exit(0);
            } else {
                log.warn("Bootstrap: command \"" + command + "\" does not exist.");
            }
        } catch (Throwable t) {
            // Unwrap the Exception for clearer error reporting
            if (t instanceof InvocationTargetException &&
                    t.getCause() != null) {
                t = t.getCause();
            }
            handleThrowable(t);
            t.printStackTrace();
            System.exit(1);
        }

    }

注释1处，main方法内首先调用了init()方法，在该方法中使用反射创建了org.apache.catalina.startup.Catalina类的实例，并将该实例赋值给了Bootstrap类中的catalinaDaemon实例，默认启动Tomcat容器流程会走到注释3处，调用daemon.load(args)方法，这里的daemon实例其实就是注释2处的Bootstrap自己的实例，我们接着看load(String[])方法

图2. Bootstrap类的load(String[])方法

该方法的主要逻辑就是通过反射调用了成员变量 catalinaDaemon的 load(String args[])方法，上面说过， catalinaDaemon实际上就是 Catalina.class的实例对象，因此，最终调用了 Catalina类的 load()方法， 代码清单2

public void load() {

        long t1 = System.nanoTime();

        initDirs();

        // Before digester - it may be needed

        initNaming();

        //         (1)
        // Create and execute our Digester
        Digester digester = createStartDigester();

        InputSource inputSource = null;
        InputStream inputStream = null;
        File file = null;
        try {
            try {
                file = configFile();
                inputStream = new FileInputStream(file);
                inputSource = new InputSource(file.toURI().toURL().toString());
            } catch (Exception e) {
                if (log.isDebugEnabled()) {
                    log.debug(sm.getString("catalina.configFail", file), e);
                }
            }
            //    省略其他代码.....
            try {
                inputSource.setByteStream(inputStream);
                 //         (2)
                digester.push(this);
                //          (3)
                digester.parse(inputSource);

            } catch (SAXParseException spe) {
                log.warn("Catalina.start using " + getConfigFile() + ": " +
                        spe.getMessage());
                return;
            } catch (Exception e) {
                log.warn("Catalina.start using " + getConfigFile() + ": " , e);
                return;
            }
        } finally {
            if (inputStream != null) {
                try {
                    inputStream.close();
                } catch (IOException e) {
                    // Ignore
                }
            }
        }

        getServer().setCatalina(this);

        // Stream redirection
        initStreams();

        // Start the new server
        try {

            //             (4)
            getServer().init();
        } catch (LifecycleException e) {
            if (Boolean.getBoolean("org.apache.catalina.startup.EXIT_ON_INIT_FAILURE")) {
                throw new java.lang.Error(e);
            } else {
                log.error("Catalina.start", e);
            }

        }

        long t2 = System.nanoTime();
        if(log.isInfoEnabled()) {
            log.info("Initialization processed in " + ((t2 - t1) / 1000000) + " ms");
        }

    }

Tomcat底层使用SAX来对xml文件进行解析，具体来说，注释1处createStartDigester()方法的目的是为解析server.xml创建特定的“摘要”，Tomcat采用Digester.java来封装对server.xml文件中所有标签的解析规则，每一种规则都是Rule接口的实现，Digester.java中的startDocument()、startElement(String,String,String,Attributes)、endDocument()、endElment(String,String,String)等方法都是标准的SAX解析模块，分别用于文档的开始结束、元素的开始结束。为了突出重点，该流程我们采用一个为标签设置解析规则的例子说明

图3. createStartDigester方法节选

红框内的代码实际上为解析标签创建了三个规则ObjectCreateRule、SetPropertiesRule和SetNextRule，并指明了对应对象的实例为org.apache.catalina.core.StandardServer，这三个规则最终会被放在规则父类RuleBase类的缓存HashMap> cache中，而Digester又持有该类的实例，也就是说Digester最终会装载解析xml文件所需的所有规则
我们回到代码清单2中的注释2，Digester做了一个类似压栈的操作，将当前的Catalina对象压入Catalina类中的ArrayStack