Tomcat 轻量级容器原理探秘一键停启篇

Tomcat 轻量级应用服务器原理探秘架构分析篇
Tomcat 轻量级应用服务器原理探秘一键停启篇
Tomcat 轻量级应用服务器原理探秘类加载器篇
Tomcat 轻量级应用服务器原理探秘异步通信篇

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

1. start.sh

start.sh 和 start.bat 里面的内容相同，所以这里就主要分析 start.sh 的内容：

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 "$@"

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

拿到脚本的真正路径；
执行 catalina.sh 的 start 命令；

而 shutdown.sh 和 start.sh 命令一样，只不过后面是执行 catalina.sh 的 stop 命令。

2. catalina.sh

catalina.sh 脚本中重要的步骤有以下几个:

设置两个重要的环境变量，CATALINA_HOME、CATALINA_BASE：

PRGDIR=`dirname "$PRG"`

[ -z "$CATALINA_HOME" ] && CATALINA_HOME=`cd "$PRGDIR/.." >/dev/null; pwd`

[ -z "$CATALINA_BASE" ] && CATALINA_BASE="$CATALINA_HOME"

设置 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

将 bootstrap.jar 作为 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

执行脚本参数，执行 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 类中看它到底做了什么。

3. Bootstrap

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

// 初始化类加载器并且将Catalina文件加载进内存中
bootstrap.init();
String command = "start";
if (args.length > 0) {
    command = args[args.length - 1];
}

if (command.equals("startd")) {
    args[args.length - 1] = "start";
    // 调用Catalina.java的load方法
    daemon.load(args);
    // 调用Catalina.java的start
    daemon.start();
} else if (command.equals("stopd")) {
    args[args.length - 1] = "stop";
    // 调用Catalina.java的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.");
}

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

在 Catalina 的 start() 方法中我们看到：

getServer().start();

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

public interface Lifecycle {

    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() 方法，这里我们如果对于设计模式了解的话，应该会想到这里运用了 模板设计模式，抽象出所有子类的公有的代码，然后重新定义一个内部抽象方法，其子类实现自己的定制化的操作。