Tomcat的启动与关闭：详解启动类Bootstrap和Catalina，彻底搞懂catalina.home和catalina.base的区别和作用范围

逃离我推掉我的手 2022-10-06 09:59 352阅读 0赞

### 文章目录 ###

*   *  一、前言
     *  二、设置catalina.home和catalina.base
     *   *  1、二者区别和作用范围
         *  2、bin/catalina.sh中设置catalina.home和catalina.base
         *  3、Bootstrap中确定catalina.home和catalina.base
     *  三、Bootstrap.main详解
     *   *  1、Bootstrap的初始化
         *  2、Bootstrap对Catalina发号施令
     *  四、控制指令程序Catalina
     *   *  1、加载并解析参数
         *  2、启动和停止
     *  五、要点总结

## 一、前言 ##

Tomcat启动其实和普通的java程序一样，都是通过一个`main`方法运行起来的，然后起几个异步线程不断循环监听，保证main主线程一直运行不退出。`org.apache.catalina.startup.Bootstrap`是Tomcat的启动类，它有一个`main`方法，可以传入一些控制指令如`start`、`stop`等，还可以传一些指定配置路径的参数如`-config`等。也可以不传任何参数，默认`start`，配置信息默认就从`catalina.base`中获取，如`catalina.base/conf/server.xml`、`catalina.base/conf/context.xml`等。

## 二、设置catalina.home和catalina.base ##

### 1、二者区别和作用范围 ###

`catalina.home`和`catalina.base`是Tomcat的两个非常重要的路径：

*  `catalina.home`是Tomcat的安装目录，一般包含`bin`目录和`lib`目录，`bin`目录下有控制Tomcat的脚本，如`catalin.sh`等以及启动类jar包`Bootstrap.jar`；`lib`目录下是Tomcat启动运行需要的jar包（安装版的Tomcat是把源码打包成多个单独的jar）。
 *  `catalina.base`是`web`项目部署目录，也是工作目录，包含`conf`、`logs`、`webapps`等目录。`conf`中有一些默认配置如`server.xml`、`context.xml`、`logging.properties`以及全局`web.xml`等；`logs`就是web程序运行时产生的日志，可以在`server.xml`中配置生成日志的路径和文件名；`webapps`就是web项目部署的地方，可以在`server.xml`的`<Host>`节点配置`appBase`的路径，默认为`webapps`。`webapps`目录下的web项目就是一个个`context`，默认都是根据`conf/context.xml`解析`context`中的容器和组件，也可以单独指定，如web项目目录下可以包含`META-INF/context.xml`。
 *  Tomcat会想方设法设置`catalina.home`，如果没有在系统环境或者`vm options`指定就根据用户当前工作目录（`user.dir`）设置合适的路径，`catalina.base`也没有指定的话，就直接把`catalina.home`赋值给`catalina.base`。

### 2、bin/catalina.sh中设置catalina.home和catalina.base ###

启动Tomcat的方式有两种，一种用命令脚本启动（安装包方式），一种是直接运行`Bootstrap.main`（[源码方式][Link 1]）。不过这两种启动方式，原理是一样的，都是通过`vm options`、`Program arguments` 指定一些启动参数，然后调用`Bootstrap.main`。

`bin/catalina.sh`是控制Tomcat的脚本，可以传递一些`run`、`start`、`stop`、`debug`等指令控制Tomcat的启动过程。有两个便捷脚本`startup.sh` 和`shutdown.sh`，都是调用的`catalin.sh`脚本传递`start`和`stop`指令。

`catalina.sh`的最终目的就是生成一个包含各种`vm options`和`Program arguments` ，并将这些参数传递给启动类`Bootstrap`的命令。（因为脚本源码较多，只截取关键部分）

![catalina.sh Bootstrap start][]  
如何确定`catalina.home`和`catalina.base`的值呢？

*  如果没有在系统环境里设置Tomcat的安装目录即`CATALINA_HOME`，则设置为`catalina.sh`脚本当前目录（`/bin`）的上一级目录为`CATALINA_HOME`。
 *  如果没有在系统环境里设置工作目录即 `CATALINA_BASE`，则将 `CATALINA_HOME` 赋值给 `CATALINA_BASE`。  
    ![catalina.sh 如何确定catalina.home和catalina.base][catalina.sh _catalina.home_catalina.base]

### 3、Bootstrap中确定catalina.home和catalina.base ###

不管用`catalina.sh`脚本启动Tomcat还是直接运行`org.apache.catalina.startup.Bootstrap#main`，都是可以在`vm options`中设置`-Dcatalina.home`和`-Dcatalina.base`。

`Bootstrap`的`static`块里会对`catalinaBaseFile`和`catalinaHomeFile`进行赋值:

*  首先获取用户当前工作目录，一般就是项目的路径。
 *  获取`-Dcatalina.home`值，如果不为空，则new一个File，并调用`getCanonicalFile`获取抽象路径名的规范形式。（`getCanonicalFile`可以根据操作系统，解析得到规范的唯一路径名，如`../ ./`等`getCanonicalFile`可以正确解析，而`getAbsoluteFile`不会。）
 *  如果`-Dcatalina.home`为空，判断用户工作目录下是否有启动类`bootstrap.jar`，有则将用户工作目录的上一级目录设置为`catalina.home`。
 *  `-Dcatalina.home`为空，用户工作目录下也没有`bootstrap.jar`，则`catalina.home`设置为用户工作目录。
 *  获取`-Dcatalina.base`值设置`catalina.base`，如果为空，则将`catalina.home`赋值给`catalina.base`。

private static final File catalinaBaseFile;
    private static final File catalinaHomeFile;
    static { 
        // Will always be non-null
        // 获取用户当前工作目录，不知道是哪里的可以debug一下
        String userDir = System.getProperty("user.dir");
    
        // 1. 首先从vm options 的-Dcatalina.home中获取catalina.home的路径
        // Home first
        String home = System.getProperty(Constants.CATALINA_HOME_PROP);
        File homeFile = null;
    
        if (home != null) { 
            File f = new File(home);
            try { 
                // 获取抽象路径名的规范形式，可以根据操作系统，解析得到规范的唯一路径名
                // 如../ ./ 等getCanonicalFile可以正确解析，而getAbsoluteFile不会
                homeFile = f.getCanonicalFile();
            } catch (IOException ioe) { 
                homeFile = f.getAbsoluteFile();
            }
        }
        if (homeFile == null) { 
            // First fall-back. See if current directory is a bin directory
            // in a normal Tomcat install
            // 2. vm options没有指定catalina.home，且userDir目录下有启动类bootstrap.jar
            // 则userDir的上一级目录设置为 catalina.home
            File bootstrapJar = new File(userDir, "bootstrap.jar");
            if (bootstrapJar.exists()) { 
                File f = new File(userDir, "..");
                try { 
                    homeFile = f.getCanonicalFile();
                } catch (IOException ioe) { 
                    homeFile = f.getAbsoluteFile();
                }
            }
        }
    
        if (homeFile == null) { 
            // Second fall-back. Use current directory
            // 3. userDir下没有bootstrap.jar，且homeFile依然为null，
            // 则将catalina.home直接设置为userDir
            File f = new File(userDir);
            try { 
                homeFile = f.getCanonicalFile();
            } catch (IOException ioe) { 
                homeFile = f.getAbsoluteFile();
            }
        }
    
        catalinaHomeFile = homeFile;
        System.setProperty(
                Constants.CATALINA_HOME_PROP, catalinaHomeFile.getPath());
    
        // Then base
        // 4. 从 vm options 的-Dcatalina.base 获取catalina.base的路径
        String base = System.getProperty(Constants.CATALINA_BASE_PROP);
        if (base == null) { 
            // 没有指定-Dcatalina.base，则将catalina.home赋值给catalina.base
            catalinaBaseFile = catalinaHomeFile;
        } else { 
            File baseFile = new File(base);
            try { 
                baseFile = baseFile.getCanonicalFile();
            } catch (IOException ioe) { 
                baseFile = baseFile.getAbsoluteFile();
            }
            catalinaBaseFile = baseFile;
        }
        System.setProperty(
                Constants.CATALINA_BASE_PROP, catalinaBaseFile.getPath());
    }

## 三、Bootstrap.main详解 ##

`org.apache.catalina.startup.Bootstrap`是一个启动引导类，本身没有太多启动关闭细节的实现，而是通过加载`org.apache.catalina.startup.Catalina`，对`Catalina`发号施令。需要注意的是，`Caralina`是Tomcat自定义的类加载器加载实例化的，`Bootstrap`通过反射调用`Catalina`的`start`、`stop`等方法。这样的组合目的，官方的意思是：

> The purpose of this roundabout approach is to keep the Catalina internal classes (and any other classes they depend on, such as an XML parser) out of the system class path and therefore not visible to application level classes.
> 
> 这种迂回方法的目的是将Catalina内部类（以及它们所依赖的任何其他类，如XML解析器）排除在系统类路径之外，因此对应用程序级类不可见。

个人理解：首先保证了`Catalina`和`Bootstrap`的隔离和实现细节不可见，其次二者可以单独打包，像组件一样进行组装和拆除。

![Bootstrap.main][]

public static void main(String args[]) { 
        // Tomcat8.5.9还没有加锁的
        // 这里加锁 应该是为了防止多次初始化吧
        synchronized (daemonLock) { 
            if (daemon == null) { 
                // Don't set daemon until init() has completed
                Bootstrap bootstrap = new Bootstrap();
                try { 
                    // 1、初始化类加载器，并初始化calatina
                    bootstrap.init();
                } catch (Throwable t) { 
                    handleThrowable(t);
                    t.printStackTrace();
                    return;
                }
                daemon = bootstrap;
            } else { 
                // 设置当前线程的ContextClassLoader为catalinaLoader，
                // 确保后续一些类使用正确的类加载加载，破坏双亲委派的一贯做法。
                Thread.currentThread().setContextClassLoader(daemon.catalinaLoader);
            }
        }
    
        try { 
            String command = "start";
            // 默认command=start，如果args有参数，必须把start放在最后
            // 如 -config xxx start
            if (args.length > 0) { 
                command = args[args.length - 1];
            }
            // 省略了不太重要的startd、stopd、configtest指令
           if (command.equals("start")) { 
                // 以下三个方法都是反射调用calatina的方法
                daemon.setAwait(true);
                daemon.load(args);
                daemon.start();
                if (null == daemon.getServer()) { 
                    System.exit(1);
                }
            } else if (command.equals("stop")) { 
                daemon.stopServer(args);
            } else { 
                log.warn("Bootstrap: command \"" + command + "\" does not exist.");
            }
        } catch (Throwable t) { 
            // 省略异常处理
        }
    }

### 1、Bootstrap的初始化 ###

`main`方法中首先对`Bootstrap`进行实例化，主要初始化了三个自定义类加载器和用`catalinaLoader`加载并实例化`Calatina`。

*  三个类自定义类加载很重要，分别为`commonLoader`、`catalinaLoader`以及`sharedLoader`，都是由`org.apache.catalina.startup.ClassLoaderFactory`创建的`URLClassLoader`。区别是加载类的路径不同，每种类加载都有自己的职责范围，其加载路径配置默认在`conf/catalina.properties`。（涉及到Tomcat的类加载机制，较为复杂，后续会单独拿出来讨论）

common.loader="${catalina.base}/lib","${catalina.base}/lib/*.jar","${catalina.home}/lib","${catalina.home}/lib/*.jar"
    server.loader=
    shared.loader=

*  初始化好类加载器，立刻就设置当前线程的`ContextClassLoader`为`catalinaLoader`，确保后续一些Tomcat的类能够使用正确的类加载器加载，这是破坏双亲委派的一贯做法啊。
 *  最后使用`catalinaLoader`加载和实例化`org.apache.catalina.startup.Catalina`

public void init() throws Exception { 
    
        // 初始化三个classLoader：
        // commonLoader、catalinaLoader、sharedLoader
        initClassLoaders();
        // 设置当前线程的ContextClassLoader为catalinaLoader
        Thread.currentThread().setContextClassLoader(catalinaLoader);
    
        SecurityClassLoad.securityClassLoad(catalinaLoader);
    
        // Load our startup class and call its process() method
        if (log.isDebugEnabled())
            log.debug("Loading startup class");
        // 用 catalinaLoader加载并实例化Catalina
        Class<?> startupClass = catalinaLoader.loadClass("org.apache.catalina.startup.Catalina");
        Object startupInstance = startupClass.getConstructor().newInstance();
    
        // Set the shared extensions class loader
        if (log.isDebugEnabled())
            log.debug("Setting startup class properties");
        // 调用 catalina 的方法setParentClassLoader，
        // 设置catalina的parentClassLoader 为 sharedLoader
        String methodName = "setParentClassLoader";
        Class<?> paramTypes[] = new Class[1];
        paramTypes[0] = Class.forName("java.lang.ClassLoader");
        Object paramValues[] = new Object[1];
        paramValues[0] = sharedLoader;
        Method method =
            startupInstance.getClass().getMethod(methodName, paramTypes);
        method.invoke(startupInstance, paramValues);
    
        catalinaDaemon = startupInstance;
    }

### 2、Bootstrap对Catalina发号施令 ###

`Bootstrap`解析指令，反射调用对应`Catalina`的方法。如`start`指令，会顺序调用`Catalina`的`setAwait`、`load`、`start`，可以大概看出首先解析参数，然后启动Tomcat，至于`setAwait`是做什么的，以及如何解析参数，启动的细节还要看`Catalina`。

## 四、控制指令程序Catalina ##

### 1、加载并解析参数 ###

`load`的主要作用就是解析`args`，获取配置文件路径（`arguments`），默认是`catalina.base/conf/server.xml`，然后解析配置并初始化`Server`容器。

public void load(String args[]) { 
    
        try { 
            // 处理命令参数 如-config，获取config文件路径
            if (arguments(args)) { 
                load();
            }
        } catch (Exception e) { 
            e.printStackTrace(System.out);
        }
    }

（1）`arguments`解析`args`，首先找到`-config`，然后找到后面的配置文件路径，如果没有设置`-config`，则默认为`conf/server.xml`

protected String configFile = SERVER_XML;
    public static final String SERVER_XML = "conf/server.xml";
    protected boolean arguments(String args[]) { 
        boolean isConfig = false;
        if (args.length < 1) { 
            usage();
            return false;
        }
        // -config C:/study/tomcat/conf/example1.conf start
        // ["-config", "C:/study/tomcat/conf/example1.conf", "start"]
        // 获取config的文件路径
        for (String arg : args) { 
            if (isConfig) { 
                configFile = arg;
                isConfig = false;
            } else if (arg.equals("-config")) { 
                isConfig = true;
            } else { 
               // 省略部分不常用的参数解析。。。
                usage();
                return false;
            }
        }
        return true;
    }

（2）解析`server.xml`并初始化`Server`。（解析`server.xml`较为复杂，后续会单独拿出来研究）

public void load() { 
    
        if (loaded) { 
            return;
        }
        loaded = true;
    
        long t1 = System.nanoTime();
    
        // Before digester - it may be needed
        initNaming();
        // Parse main server.xml
        // 解析server.xml
        parseServerXml(true);
        Server s = getServer();
        if (s == null) { 
            return;
        }
        // 设置Server的Catalina、CatalinaHome、CatalinaBase
        getServer().setCatalina(this);
        getServer().setCatalinaHome(Bootstrap.getCatalinaHomeFile());
        getServer().setCatalinaBase(Bootstrap.getCatalinaBaseFile());
    
        // Stream redirection
        // 重定向标准输出流和异常输出流
        initStreams();
    
        // Start the new server
        try { 
            getServer().init();
        } catch (LifecycleException e) { 
            if (throwOnInitFailure) { 
                throw new java.lang.Error(e);
            } else { 
                log.error(sm.getString("catalina.initError"), e);
            }
        }
    }

`load`里有一个操作比较有意思，就是重定向标准输出流和异常流到内存流`ByteArrayOutputStream`中，使用的方式是先调用`SystemLogHandler.startCapture()`开启捕获，最后调用`SystemLogHandler.stopCapture()`停止并获取捕获到的流内容。在没有调用`stopCapture`之前，`System.out`和异常抛出都会被重定向到`ByteArrayOutputStream`。

protected void initStreams() { 
        // Replace System.out and System.err with a custom PrintStream
        // 可通过如下两个方法使用
        // SystemLogHandler.startCapture(); 开始捕获标准流
        // SystemLogHandler.stopCapture(); 停止并获取捕获的流内容
        System.setOut(new SystemLogHandler(System.out));
        System.setErr(new SystemLogHandler(System.err));
    }

### 2、启动和停止 ###

调用`Server`的一键启动方法`start`，可以循序渐进的启动`Server`容器下的所有子容器和组件。（Tomcat如何做到的一键启停，较为复杂，涉及到Tomcat的生命周期设计，后续会单独拿出来研究）

还记得`setAwait`设置`await=true`，其目的就是调用`Server`的`await()`开启一个线程，循环监听网络（默认端口8005）中是否传来`SHUTDOWN`指令，如果接收到`SHUTDOWN`指令就退出循环，并调用`Server`的`stop`和`destroy`，停止并销毁`Server`下的所有子容器和组件。

public void start() { 
        // 省略getServer()判空
    
        // Start the new server
        try { 
            // 一键启动
            getServer().start();
        } catch (LifecycleException e) { 
            log.fatal(sm.getString("catalina.serverStartFail"), e);
            try { 
                getServer().destroy();
            } catch (LifecycleException e1) { 
                log.debug("destroy() failed for failed Server ", e1);
            }
            return;
        }
    
        if (generateCode) { 
            // Generate loader which will load all generated classes
            generateLoader();
        }
    
        // Register shutdown hook
        if (useShutdownHook) { 
            // 注册 shutdown hook
            if (shutdownHook == null) { 
                shutdownHook = new CatalinaShutdownHook();
            }
            Runtime.getRuntime().addShutdownHook(shutdownHook);
    
            // If JULI is being used, disable JULI's shutdown hook since
            // shutdown hooks run in parallel and log messages may be lost
            // if JULI's hook completes before the CatalinaShutdownHook()
            LogManager logManager = LogManager.getLogManager();
            if (logManager instanceof ClassLoaderLogManager) { 
                ((ClassLoaderLogManager) logManager).setUseShutdownHook(
                        false);
            }
        }
    
        if (await) { 
            // 调用Server的await，循环等待shutdown指令
            await();
            // 如果接收到shutdown，就结束await()，调用stop停止Tomcat
            stop();
        }
    }

## 五、要点总结 ##

1.  `Bootstrap`作为一个启动引导类，通过加载`org.apache.catalina.startup.Catalina`，对`Catalina`发号施令，其目的是保证`Catalina`和`Bootstrap`的隔离和实现细节不可见，其次二者可以单独打包，像组件一样进行组装和拆除。
2.  `catalina.home`是Tomcat安装目录，包含Tomcat必有的`bin`目录和`lib`目录；`catalina.base`是`web`项目部署目录，包含跟`web`相关的`conf`，`webapps`等。如果`catalina.base`没有指定，则和`catalina.home`相同。
3.  在Tomcat初始化，启动的过程中涉及到很多知识点，如自定义类加载器机制，`server.xml`的解析，`Server`的一键初始化，一键启停涉及到Tomcat的生命周期管理，都可以写出几篇文章来单独研究。
4.  本篇较为基础，源码也很简单，主要了解Tomcat是如何启动，如何获取默认配置的。

Tomcat源码详细注释链接（非推广，持续更新）：[https://gitee.com/stefanpy/tomcat-source-code-learning][https_gitee.com_stefanpy_tomcat-source-code-learning]

[Link 1]: https://stefan.blog.csdn.net/article/details/117620726
[catalina.sh Bootstrap start]: /images/20221005/6830f737cf7543b99892c96111530257.png
[catalina.sh _catalina.home_catalina.base]: /images/20221005/4de8d7bb8a5c46dea465c782f8d705da.png
[Bootstrap.main]: /images/20221005/2c62a22573b04a8bab33b76221db2870.png
[https_gitee.com_stefanpy_tomcat-source-code-learning]: https://gitee.com/stefanpy/tomcat-source-code-learning