Tomcat运行脚本及启动过程分析--catalina.sh

你的名字 2022-05-12 06:48 704阅读 0赞

## 一、概述 ##

作为一个成熟的中间件产品，tomcat有很多值得我们学习的地方。下面我将从tomcat的运行脚本catalina.sh入手，分析tomcat的启动过程，以及tomcat脚本是如何实现停止tomcat服务的。

注意：此处分析的是linux环境下的脚本文件

## 二、tomcat目录结构 ##

tomcat目录结构如下：

![70][]

bin目录的内容如下：

*  可执行文件，包括startup.sh、shutdown.sh、catalina.sh
 *  tomcat启动所依赖的jar包，包括 bootstrap.jar、tomcat-juli.jar

## 三、脚本分析 ##

我会介绍每个脚本的主要逻辑，并对涉及到的linux命令做简要介绍。脚本中做了大部分的注释，请结合注释理解。毕竟是代码，干说是很难描述的，注释效果更好。

### startup.sh ###

#!/bin/sh
    
    # 1)检测是否为os400操作系统
    os400=false
    case "`uname`" in
    OS400*) os400=true;;
    esac
    
    # 2)PRG表示脚本路径，如果当前脚本文件为软链接，则会解析出PRG真正文件所在路径
    # resolve links - $0 may be a softlink
    PRG="$0"
    
    while [ -h "$PRG" ] ; do # -h 判断是否为软链接
      ls=`ls -ld "$PRG"` # 如果为软链接，输出中含有 link -> source 的字串
      link=`expr "$ls" : '.*-> $.*$$'` # 模式匹配出源文件的路径，对这里感觉模糊请搜索“expr模式匹配”
      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
    
    # 3)执行catalina.sh start
    exec "$PRGDIR"/"$EXECUTABLE" start "$@"

脚本主要逻辑如下：

1. 检测操作系统，以兼容特定操作系统的特性

*  uname 显示操作系统信息

2. 获取脚本路径

这段代码几乎在所有启动脚本、停止脚本的开头都会出现。为了防止获取到的路径是软链接的路径，需要对路径做解析。

*  expr命令解释

1）expr  string : regex

这种形式下，会用：后面的正则表达式匹配前面的字符串，输出匹配的个数

2）expr string : xxx\\（zzz\\ ）

这种形式下，\\（zzz\\）中，zzz匹配的字符串会被输出

3.执行catalina.sh start

总结：startup.sh 调用 catalina.sh start

### shutdown.sh ###

逻辑和startup.sh一样，最终调用 catalina.sh stop

## catalina.sh ##

从上面的分析我们知道，其他的脚本最终会以不同的参数调用catalina脚本，那么，catalina脚本的主要逻辑是什么呢？

由于catalina.sh脚本较长，截取一些片段来分析：

1.检测操作系统

2.获取脚本路径$PRG

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

一般情况下，这两个变量的值相同，都是tomcat根目录

# 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` # $CATALINA_HOME即tomcat根目录
    
    # Copy CATALINA_BASE from CATALINA_HOME if not already set
    [ -z "$CATALINA_BASE" ] && CATALINA_BASE="$CATALINA_HOME" # $CATALINA_BASE等同$CATALINA_HOME

4.设置CLASSPATH变量

#在当前shell环境执行setenv.sh，设置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

5.在CLASSPATH后追加Bootstrap.jar、Tomcat-juli.jar

# Add on extra jar files to CLASSPATH
    if [ ! -z "$CLASSPATH" ] ; then
      CLASSPATH="$CLASSPATH":
    fi
    CLASSPATH="$CLASSPATH""$CATALINA_HOME"/bin/bootstrap.jar #将bootstrap.jar作为CLASSPATH
    
    # Add tomcat-juli.jar to classpath
    # tomcat-juli.jar can be over-ridden per instance
    if [ -r "$CATALINA_BASE/bin/tomcat-juli.jar" ] ; then
      CLASSPATH=$CLASSPATH:$CATALINA_BASE/bin/tomcat-juli.jar #添加tomcat-juli.jar到classpath
    else
      CLASSPATH=$CLASSPATH:$CATALINA_HOME/bin/tomcat-juli.jar
    fi

6.解析脚本参数，执行Bootstrap类的main方法，并传入相应的参数

*  参数为start的情况下

java命令执行Bootstrap类的main方法，将start作为参数传入

eval $_NOHUP "\"$_RUNJAVA\"" "\"$LOGGING_CONFIG\"" $LOGGING_MANAGER $JAVA_OPTS $CATALINA_OPTS \
          -D$ENDORSED_PROP="\"$JAVA_ENDORSED_DIRS\"" \
          -classpath "\"$CLASSPATH\"" \
          -Dcatalina.base="\"$CATALINA_BASE\"" \
          -Dcatalina.home="\"$CATALINA_HOME\"" \
          -Djava.io.tmpdir="\"$CATALINA_TMPDIR\"" \
          org.apache.catalina.startup.Bootstrap "$@" start \
          >> "$CATALINA_OUT" 2>&1 "&"

*  参数为stop的情况下

java命令执行Bootstrap类的main方法，将stop作为参数传入

至此，整个过程结束。

脚本中多次出现对$CATALINA\_PID这个文件的操作，这里简单介绍一下这个文件的作用：

elif [ "$1" = "start" ] ; then
    
      if [ ! -z "$CATALINA_PID" ]; then
        if [ -f "$CATALINA_PID" ]; then
          if [ -s "$CATALINA_PID" ]; then
            echo "Existing PID file found during start."
            if [ -r "$CATALINA_PID" ]; then
              PID=`cat "$CATALINA_PID"`
              ps -p $PID >/dev/null 2>&1
              if [ $? -eq 0 ] ; then
                echo "Tomcat appears to still be running with PID $PID. Start aborted."
                echo "If the following process is not a Tomcat process, remove the PID file and try again:"
                ps -f -p $PID
                exit 1
              else
                echo "Removing/clearing stale PID file."
                rm -f "$CATALINA_PID" >/dev/null 2>&1
                if [ $? != 0 ]; then
                  if [ -w "$CATALINA_PID" ]; then
                    cat /dev/null > "$CATALINA_PID"
                  else
                    echo "Unable to remove or clear stale PID file. Start aborted."
                    exit 1
                  fi
                fi
              fi
            else
              echo "Unable to read PID file. Start aborted."
              exit 1
            fi
          else
            rm -f "$CATALINA_PID" >/dev/null 2>&1
            if [ $? != 0 ]; then
              if [ ! -w "$CATALINA_PID" ]; then
                echo "Unable to remove or write to empty PID file. Start aborted."
                exit 1
              fi
            fi
          fi
        fi
      fi

1.$CATALINA变量默认tomcat没有启用，用户如果要用，就要在脚本中自己定义该变量，他表示的记录tomcat进程id的文件路径

2.start时，会先检测$CATALINA文件是否存在，如果存在并且内容不为空，说明tomcat进程已经启动，则启动失败

3.start成功，如果定义了$CATALINA变量，则将进程id写入该文件

4.stop时，先执行 Bootstrap.main stop，如果不成功并且$CATALINA存在，则尝试使用kill命令杀死进程

5.stop成功，如果定义了$CATALINA变量，则删除$CATALINA文件

## 四、tomcat源码之Bootstrap与Catalina分析 ##

由catalina.sh我们知道，启动和停止tomcat都是以Bootstrap类作为主类运行。

这里，我们主要关注一个问题：

执行Bootstrap stop，为何可以停止另一个进程中的tomcat呢？要知道每次执行脚本中的java命令，我们都启动了一个新的进程。我们下面源码的分析只关注这个问题。

### Bootstrap main方法 ###

以下是main方法代码片段：

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();
                } 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);
            }

主要注意“start”和“stop"的部分，在Bootstrap中对daemon变量的操作，最终都变为对Catalina的操作，方法名映射是一致的。那么我们主要关注的是Catalina.start()和Catalina.stopServer()方法了。

### Catalina.start ###

这里主要是调用了Server.start，其中我们要注意的片段是：

if (await) {
                await();
                stop();
            }

我们可以大致猜到代码的意思：等待，等待结束则执行stop()。

到底在等待什么呢？看StandardServer.await，谜团解开了：

// Set up a server socket to wait on
            try {
                awaitSocket = new ServerSocket(port, 1,
                        InetAddress.getByName(address));
            } catch (IOException e) {
                log.error("StandardServer.await: create[" + address
                                   + ":" + port
                                   + "]: ", e);
                return;
            }

此处建立了ServerSocket，监听的端口是 conf/server.xml中配置的shutdown端口，默认是8005，当该端口接收到"SHUTDOWN"请求，await()结束，进而执行stop()方法。

server.xml中shutdown端口：

通过网络通信的方式，tomcat实现了从一个Java进程关闭另一个Java进程。

### Catalina.stopServer ###

从对Catalina.start的分析，我们知道这个方法会向另一个Java进程发送shutdown命令，验证我们的假设：

Catalina.stopServer代码片段：

// Stop the existing server
            s = getServer();
            if (s.getPort()>0) {
                Socket socket = null;
                OutputStream stream = null;
                try {
                    socket = new Socket(s.getAddress(), s.getPort());
                    stream = socket.getOutputStream();
                    String shutdown = s.getShutdown();
                    for (int i = 0; i < shutdown.length(); i++) {
                        stream.write(shutdown.charAt(i));
                    }
                    stream.flush();
                } catch (ConnectException ce) {
                    log.error(sm.getString("catalina.stopServer.connectException",
                                           s.getAddress(),
                                           String.valueOf(s.getPort())));
                    log.error("Catalina.stop: ", ce);
                    System.exit(1);
                } catch (IOException e) {
                    log.error("Catalina.stop: ", e);
                    System.exit(1);
                } finally {
                    if (stream != null) {
                        try {
                            stream.close();
                        } catch (IOException e) {
                            // Ignore
                        }
                    }
                    if (socket != null) {
                        try {
                            socket.close();
                        } catch (IOException e) {
                            // Ignore
                        }
                    }
                }

### 五、总结 ###

我们分析了tomcat是如何通过catalina.sh脚本启动和停止tomcat进程的，而catalina.sh的逻辑基本上适用任何的Java程序。

Java程序的脚本，最终的逻辑基本上是调用java命令执行Java程序，总结几个注意的点：

1.脚本路径的获取

2.CLASSPATH的获取

3.PID文件记录启动的Java进程id

4.如何停止Java进程

*  通过网络通信，如Socket向正在运行的进程发送shutdown命令，Java进程根据收到的消息决定是否关闭进程。
 *  通过kill命令，强制杀死进程

注意：通过Runtime.getRuntime().addShutdownHook设置钩子线程，可相应kill命令，从而在关闭进程前执行有效的清理工作。

[70]: /images/20220512/09836c7dd23b4d939bca85d2ac19fb0d.png