死磕Tomcat系列（3）——Tomcat如何做到一键式启停的

缺乏、安全感 2021-09-01 08:07 390阅读 0赞

# 死磕Tomcat系列（3）——Tomcat如何做到一键式启停的 #

在没有SpringBoot内嵌有Tomcat之前，我们都是将项目打为War包放在Tomcat的webapp目录下面，然后如果是Linux系统，运行命令start.sh、如果是Windows系统，运行命令start.bat以后就能启动起来并访问到页面。如果是想要停止运行只需要运行shutdown.sh或者shutdown.bat就能将程序停止起来，那么Tomcat是如何做到只需要一个命令就将所有容器启动起来呢？

## 脚本分析 ##

os400=false
    case "`uname`" in
    OS400*) os400=true;;
    esac
    # resolve links - $0 may be a softlink
    #PRG为脚本路径，如果当前脚本文件为软连接，则会解析出PRG真正的文件所在路径
    PRG="$0"
    while [ -h "$PRG" ] ; do  #判断是否为软连接
      ls=`ls -ld "$PRG"`	  #如果是软连接，则输入含有lin ->source的字符串
      link=`expr "$ls" : '.*-> $.*$$'`  #模式匹配出原文件路径
      if expr "$link" : '/.*' > /dev/null; then #正则匹配 /.*这里expr会输出匹配个数，如果不为0，则说明$link包含目录
        PRG="$link"
      else
        PRG=`dirname "$PRG"`/"$link" #当不包含目录说明软连接和原文件在同一目录
      fi
    done
    #获取脚本目录路径
    PRGDIR=`dirname "$PRG"`
    EXECUTABLE=catalina.sh
    # Check that target executable exists
    if $os400; then
      # -x will Only work on the os400 if the files are:
      # 1. owned by the user
      # 2. owned by the PRIMARY group of the user
      # this will not work if the user belongs in secondary groups
      eval
    else
      if [ ! -x "$PRGDIR"/"$EXECUTABLE" ]; then
        echo "Cannot find $PRGDIR/$EXECUTABLE"
        echo "The file is absent or does not have execute permission"
        echo "This file is needed to run this program"
        exit 1
      fi
    fi
    #执行catalina.sh的start命令
    exec "$PRGDIR"/"$EXECUTABLE" start "$@"

其实上面简单来说就做了两件事

1.  拿到脚本的真正路径
2.  执行catalina.sh的start命令  
    而shutdown.sh和start.sh命令一样，只不过后面是执行catalina.sh的stop命令

## Catalina.sh分析 ##

脚本中重要的步骤有几个：

1.  设置两个重要的环境变量 CATALINA\_HOME CATALINA\_BASE

# Get standard environment variables
    PRGDIR=`dirname "$PRG"`
    # Only set CATALINA_HOME if not already set
    [ -z "$CATALINA_HOME" ] && CATALINA_HOME=`cd "$PRGDIR/.." >/dev/null; pwd`
    # Copy CATALINA_BASE from CATALINA_HOME if not already set
    [ -z "$CATALINA_BASE" ] && CATALINA_BASE="$CATALINA_HOME"

1.  设置CLASSPATH变量，这里注意，默认是没有setenv.sh文件的，可以自己新建一个并添加参数

CLASSPATH=
    
    if [ -r "$CATALINA_BASE/bin/setenv.sh" ]; then
      . "$CATALINA_BASE/bin/setenv.sh"
    elif [ -r "$CATALINA_HOME/bin/setenv.sh" ]; then
      . "$CATALINA_HOME/bin/setenv.sh"
    fi

1.  将bootstrap.jar作为CLASSPATH变量传进去

# Add on extra jar files to CLASSPATH
    if [ ! -z "$CLASSPATH" ] ; then
      CLASSPATH="$CLASSPATH":
    fi
    CLASSPATH="$CLASSPATH""$CATALINA_HOME"/bin/bootstrap.jar
    if [ -z "$CATALINA_OUT" ] ; then
      CATALINA_OUT="$CATALINA_BASE"/logs/catalina.out
    fi

1.  执行脚本参数，执行bootstrap.jar中的Bootstrap类中main方法，并传入参数start

shift
        eval exec "\"$_RUNJAVA\"" "\"$LOGGING_CONFIG\"" $LOGGING_MANAGER "$JAVA_OPTS" "$CATALINA_OPTS" \
          -D$ENDORSED_PROP="\"$JAVA_ENDORSED_DIRS\"" \
          -classpath "\"$CLASSPATH\"" \
          -Djava.security.manager \
          -Djava.security.policy=="\"$CATALINA_BASE/conf/catalina.policy\"" \
          -Dcatalina.base="\"$CATALINA_BASE\"" \
          -Dcatalina.home="\"$CATALINA_HOME\"" \
          -Djava.io.tmpdir="\"$CATALINA_TMPDIR\"" \
          org.apache.catalina.startup.Bootstrap "$@" start

在上面脚本中我们可以看出最后执行的都是从Bootstrap的main方法作为入口的，所以我们打开Tomcat源码进去Bootstrap类中看它到底做了什么

## 启动类分析 ##

作为Tomcat的入口类，我们先看看Bootstrap中做了什么。这里只贴出main方法中重要的代码

//package org.apache.catalina.startup
    
        public static void main(String args[]) {
            synchronized (daemonLock) {
                if (daemon == null) {
                    // Don't set daemon until init() has completed
                    Bootstrap bootstrap = new Bootstrap();
                    try {
                        bootstrap.init();
                    } catch (Throwable t) {
                        handleThrowable(t);
                        t.printStackTrace();
                        return;
                    }
                    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();
                } else if (command.equals("start")) {
                    daemon.setAwait(true);
                    daemon.load(args);
                    daemon.start();
                    if (null == daemon.getServer()) {
                        System.exit(1);
                    }
                } 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);
            }
        }

这里是根据脚本中传入的不同命令，调用Catalina不同的方法。由于我们主要分析的Tomcat如何做到一键式启停的，所以我们主要分析Catalina的start方法

getServer().start();

随后经过Debug都是经过了Lifecycle的start方法，我们把Lifecycle的方法列出来

public interface Lifecycle {
        public static final String BEFORE_INIT_EVENT = "before_init";
        public static final String AFTER_INIT_EVENT = "after_init";
        public static final String START_EVENT = "start";
        public static final String BEFORE_START_EVENT = "before_start";
        public static final String AFTER_START_EVENT = "after_start";
        public static final String STOP_EVENT = "stop";
        public static final String BEFORE_STOP_EVENT = "before_stop";
        public static final String AFTER_STOP_EVENT = "after_stop";
        public static final String AFTER_DESTROY_EVENT = "after_destroy";
        public static final String BEFORE_DESTROY_EVENT = "before_destroy";
        public static final String PERIODIC_EVENT = "periodic";
        public static final String CONFIGURE_START_EVENT = "configure_start";
        public static final String CONFIGURE_STOP_EVENT = "configure_stop";
        public void addLifecycleListener(LifecycleListener listener);
        public LifecycleListener[] findLifecycleListeners();
        public void removeLifecycleListener(LifecycleListener listener);
        public void init() throws LifecycleException;
        public void start() throws LifecycleException;
        public void stop() throws LifecycleException;
        public void destroy() throws LifecycleException;
        public LifecycleState getState();
        public String getStateName();
        public interface SingleUse {
        }
    }

然后再看它的实现类，我们发现我们前面所讲的整体架构中的组件都实现了此类。而在它的子类LifecycleBase实现了start、init、stop等方法，并且里面都相应调用了startInternal、initInternal、stopInternal方法，这里我们如果对于设计模式了解的话，应该会想到这里运用了模板设计模式，抽象出所有子类的公有的代码，然后重新定义一个内部抽象方法，其子类实现自己的定制化的操作。  
在Server.xml中我们发现第一个层级也是Server，然后Catalina的satrt方法中第一个启动的也是Server  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNDE5MTA1_size_16_color_FFFFFF_t_70]  
上面表示了Tomcat所有模块的层级结构，只要是带有层级的结构，我们应该能够立马想到组合设计模式，从这个层级结构中我们能够得到模块之间的关系，有大有小，有内有外。

*  有大有小：大组件管理小组件，例如Server管理Service，Service管理连接器和容器
 *  有内有外：连接器控制对外的连接，而外层组件调用内层组件完成业务功能。即请求处理的过程是由外层组件驱动的。  
    那么根据上面的两条，我们知道，有小才有大，有内才有外。这也就是整个层级的加载顺序，先加载小组件再加载大组件，先加载内层组件再加载外层组件。此时我们应该就明白了Tomcat是如何做到一键式启停的了。通过层级结构，加载的优先级。层层迭代进行启动。而停止和启动差不多。也是层层迭代进行停止

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzNDE5MTA1_size_16_color_FFFFFF_t_70]: /images/20210901/1a0d6e2753be49c4b31d9fba9ec8a785.png