Tomcat探秘（4）：tomcat启动过程详述

谁借莪１个温暖的怀抱￠ 2022-08-23 05:53 358阅读 0赞

熟悉Tomcat的工程师们，或者从事Java开发的，肯定都知道Tomcat是如何启动和停止的。在Tomcat源码包里面有个bin目录，该目录下放置了一些很重要的脚本，Tomcat启动和停止的脚本程序就放在这里，分别是startup.bat、shutdown.bat（Windows环境）和start.sh、shutdown.sh（Linux、Unix环境）。大家一定都知道如何使用它们，接下来就是研究一下它们是如何实现启动和停止服务的。

在实际的生产环境下，绝大多数的Tomcat都是部署在Linux环境下的，在这片文章中，我们以startup.sh和shutdown.sh为例简单说说启动和停止过程。（Tomcat版本7.0.69）

启动过程分析：

进入到Tomcat的bin目录，启动startup.sh的命令如下：

./startup.sh

该脚本里面都做了什么呢？这里贴出启动脚本：

#!/bin/sh
    
    # Licensed to the Apache Software Foundation (ASF) under one or more
    # contributor license agreements.  See the NOTICE file distributed with
    # this work for additional information regarding copyright ownership.
    # The ASF licenses this file to You under the Apache License, Version 2.0
    # (the "License"); you may not use this file except in compliance with
    # the License.  You may obtain a copy of the License at
    #
    #     http://www.apache.org/licenses/LICENSE-2.0
    #
    # Unless required by applicable law or agreed to in writing, software
    # distributed under the License is distributed on an "AS IS" BASIS,
    # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    # See the License for the specific language governing permissions and
    # limitations under the License.
    
    # -----------------------------------------------------------------------------
    # Start Script for the CATALINA Server
    # -----------------------------------------------------------------------------
    
    # Better OS/400 detection: see Bugzilla 31132
    os400=false
    case "`uname`" in
    OS400*) os400=true;;
    esac
    
    # resolve links - $0 may be a softlink
    PRG="$0"
    
    while [ -h "$PRG" ] ; do
      ls=`ls -ld "$PRG"`
      link=`expr "$ls" : '.*-> $.*$$'`
      if expr "$link" : '/.*' > /dev/null; then
        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
    
    exec "$PRGDIR"/"$EXECUTABLE" start "$@"

下面简单看看这个脚本，前面几行：

os400=false
    case "`uname`" in
    OS400*) os400=true;;
    esac

使用uname查看当前操作系统的名称，然后判断是否符合模式OS400\*，如果是则进行标记，设置os400=true，用于控制后面的逻辑。

在后面的脚本命令中，涉及到的两个比较重要的变量就是PRGDIR（当前startup.sh脚本的上一级目录，即bin目录）和EXECUTABLE（设置了脚本名称catalina.sh），然后最后通过执行

exec "$PRGDIR"/"$EXECUTABLE" start "$@"

来启动执行catalina.sh脚本并将start参数传递给脚本用于控制是进行启动操作的。因为catelina.sh脚本的代码较长，这里只贴出跟启动相关的部分指令：

...........
 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
 
 shift
 touch "$CATALINA_OUT"
 if [ "$1" = "-security" ] ; then
 if [ $have_tty -eq 1 ]; then
 echo "Using Security Manager"
 fi
 shift
 eval "\"$_RUNJAVA\"" "\"$LOGGING_CONFIG\"" $LOGGING_MANAGER $JAVA_OPTS $CATALINA_OPTS \
 -Djava.endorsed.dirs="\"$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 \
 >> "$CATALINA_OUT" 2>&1 "&"
 
 else
 eval "\"$_RUNJAVA\"" "\"$LOGGING_CONFIG\"" $LOGGING_MANAGER $JAVA_OPTS $CATALINA_OPTS \
 -Djava.endorsed.dirs="\"$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 "&"
 
 fi
 
 if [ ! -z "$CATALINA_PID" ]; then
 echo $! > "$CATALINA_PID"
 fi
 
 echo "Tomcat started."
 
 elif [ "$1" = "stop" ] ; then
 .................

catalina.sh脚本是所有其他脚本最终实际执行操作的脚本，不管是启动还是停止脚本，执行startup.sh和shutdown.sh最终都会转换为执行catalina.sh，只是在执行catalina.sh时传递的参数不一样。

上面的红色部分就是判断是启动还是停止服务，而蓝色部分是对一些参数的校验工作，而从紫色部分可以看出，最终启动的时候是执行了org.apache.catalina.startup.Bootstrap这个类，同时传递了参数"start"。在之前的文章<Tomcat探秘（2）：如何在Eclipse中导入和运行tomcat源代码？>中我们已经把Tomcat源码导入到了Eclipse中，这时候我们可以根据类包名路径找到相应的类Bootstrap，并且找到其main()，这里贴出main方法实现，如下所示：

/**
 * Main method and entry point when starting Tomcat via the provided
 * scripts.
 *
 * @param args Command line arguments to be processed
 */
 public static void main(String args[]) {
 
 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();
 } 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”参数来确定的分支逻辑。

从上面的main方法可以看出，整个启动过程大概分为三个步骤，如上面蓝色标记的部分：

（1）判断bootstrap是否已经初始化了？如果没有则进行初始化；

（2）调用Bootstrap类的load()来加载server.xml配置文件（这是一个很重要的配置文件）；

（3）调用Bootstrap类的start()方法启动Tomcat；

下面对这三个步骤进行简单的描述。

第一步：判断bootstrap是否已经初始化了？如果没有则进行初始化；

通过上面的代码可以知道实际是通过调用bootstrap.init();来进行初始化的，那么具体又做了什么呢？我们看看init()方法是怎么实现的：

/**
 * Initialize daemon.
 */
 public void init()
 throws Exception
 {
 
 // Set Catalina path
 setCatalinaHome();
 setCatalinaBase();
 
 initClassLoaders();
 
 Thread.currentThread().setContextClassLoader(catalinaLoader);
 
 SecurityClassLoad.securityClassLoad(catalinaLoader);
 
 // Load our startup class and call its process() method
 if (log.isDebugEnabled())
 log.debug("Loading startup class");
 Class<?> startupClass =
 catalinaLoader.loadClass
 ("org.apache.catalina.startup.Catalina");
 Object startupInstance = startupClass.newInstance();
 
 // Set the shared extensions class loader
 if (log.isDebugEnabled())
 log.debug("Setting startup class properties");
 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;
 
 }

从代码里可以看出，主要做了三件事：

（1）设置了catalina.base和catalina.home路径；

（2）初始化了需要的类加载器；

（3）利用Java中的反射机制，通过执行setParentClassLoader方法来设置Tomcat类加载体系的顶级类加载器；

第二步：调用Bootstrap类的load()来加载server.xml配置文件

我们打开Bootstrap类的load方法，如下所示：

/**
 * Load daemon.
 */
 private void load(String[] arguments)
 throws Exception {
 
 // Call the load() method
 String methodName = "load";
 Object param[];
 Class<?> paramTypes[];
 if (arguments==null || arguments.length==0) {
 paramTypes = null;
 param = null;
 } else {
 paramTypes = new Class[1];
 paramTypes[0] = arguments.getClass();
 param = new Object[1];
 param[0] = arguments;
 }
 Method method =
 catalinaDaemon.getClass().getMethod(methodName, paramTypes);
 if (log.isDebugEnabled())
 log.debug("Calling startup class " + method);
 method.invoke(catalinaDaemon, param);
 
 }

从代码可以看出最终还是执行的是org.apache.catalina.startup.Catalina类的load方法，加载server.xml文件，如下所示，至于具体的解析过程我们这里就不详述了，后面讲使用专门的一篇文章进行讲解，如果想知道可以继续关注我的博客或者自己去看源码学习^\_^：

/**
         * Start a new server instance.
         */
        public void load() {
    
            long t1 = System.nanoTime();
    
            initDirs();
    
            // Before digester - it may be needed
    
            initNaming();
    
            // 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);
                    }
                }
                if (inputStream == null) {
                    try {
                        inputStream = getClass().getClassLoader()
                            .getResourceAsStream(getConfigFile());
                        inputSource = new InputSource
                            (getClass().getClassLoader()
                             .getResource(getConfigFile()).toString());
                    } catch (Exception e) {
                        if (log.isDebugEnabled()) {
                            log.debug(sm.getString("catalina.configFail",
                                    getConfigFile()), e);
                        }
                    }
                }
    
                // This should be included in catalina.jar
                // Alternative: don't bother with xml, just create it manually.
                if( inputStream==null ) {
                    try {
                        inputStream = getClass().getClassLoader()
                                .getResourceAsStream("server-embed.xml");
                        inputSource = new InputSource
                        (getClass().getClassLoader()
                                .getResource("server-embed.xml").toString());
                    } catch (Exception e) {
                        if (log.isDebugEnabled()) {
                            log.debug(sm.getString("catalina.configFail",
                                    "server-embed.xml"), e);
                        }
                    }
                }
    
    
                if (inputStream == null || inputSource == null) {
                    if  (file == null) {
                        log.warn(sm.getString("catalina.configFail",
                                getConfigFile() + "] or [server-embed.xml]"));
                    } else {
                        log.warn(sm.getString("catalina.configFail",
                                file.getAbsolutePath()));
                        if (file.exists() && !file.canRead()) {
                            log.warn("Permissions incorrect, read permission is not allowed on the file.");
                        }
                    }
                    return;
                }
    
                try {
                    inputSource.setByteStream(inputStream);
                    digester.push(this);
                    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 {
                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");
            }
    
        }

第三步：调用Bootstrap类的start()方法启动Tomcat

我们打开start()方法的实现，如下所示：

/**
         * Start the Catalina daemon.
         */
        public void start()
            throws Exception {
            if( catalinaDaemon==null ) init();
    
            Method method = catalinaDaemon.getClass().getMethod("start", (Class [] )null);
            method.invoke(catalinaDaemon, (Object [])null);
    
        }

从代码看，其实最终执行的是org.apache.catalina.startup.Catalina类的start方法，那么org.apache.catalina.startup.Catalina类的start方法是怎么实现的呢？如下所示：

/**
         * Start a new server instance.
         */
        public void start() {
    
            if (getServer() == null) {
                load();
            }
    
            if (getServer() == null) {
                log.fatal("Cannot start server. Server instance is not configured.");
                return;
            }
    
            long t1 = System.nanoTime();
    
            // 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;
            }
    
            long t2 = System.nanoTime();
            if(log.isInfoEnabled()) {
                log.info("Server startup in " + ((t2 - t1) / 1000000) + " ms");
            }
    
            // Register shutdown hook
            if (useShutdownHook) {
                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) {
                await();
                stop();
            }
        }

从代码看，做了以下工作：

（1）首先是判断Catalina的Server实例是否初始化成功了，如果没有，则继续调用Catalina类的的load方法进行初始化；

（2）初始化成功之后，会调用上面代码中标红部分进行整个组件的启动操作，这里想说的是，由于Tomcat内部设计的问题，整个组件的启动并不是分散的，父级组件的启动会带动子级元素组件的启动，依次类推，会使整个组件都启动起来，例如Server的启动会使相关的Service组件都启动，而Service的启动又会带动Connector的启动等等。这里不做详述，将另起一篇文章单独说明，这篇文章只简单描述整个启动过程框架。

（3）如上述代码中蓝色部分所示，设置了关闭钩子，用于在Tomcat因为各种原因退出时做一些清理工作；

（4）调用Catalina自身类的await方法循环等待shutdown命令；

/**
         * Await and shutdown.
         */
        public void await() {
    
            getServer().await();
    
        }

Catalina类的await()方法其实只是代理了Server组件的await()方法。

我们在Eclipse内找到org.apache.catalina.core包下的Server组件的标准实现StandardServer，我们看看它的await方法都做了什么？

/**
 * Wait until a proper shutdown command is received, then return.
 * This keeps the main thread alive - the thread pool listening for http 
 * connections is daemon threads.
 */
 @Override
 public void await() {
 // Negative values - don't wait on port - tomcat is embedded or we just don't like ports
 if( port == -2 ) {
 // undocumented yet - for embedding apps that are around, alive.
 return;
 }
 if( port==-1 ) {
 try {
 awaitThread = Thread.currentThread();
 while(!stopAwait) {
 try {
 Thread.sleep( 10000 );
 } catch( InterruptedException ex ) {
 // continue and check the flag
 }
 }
 } finally {
 awaitThread = null;
 }
 return;
 }
 
 // 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;
 }
 
 try {
 awaitThread = Thread.currentThread();
 
 // Loop waiting for a connection and a valid command
 while (!stopAwait) {
 ServerSocket serverSocket = awaitSocket;
 if (serverSocket == null) {
 break;
 }
 
 // Wait for the next connection
 Socket socket = null;
 StringBuilder command = new StringBuilder();
 try {
 InputStream stream;
 long acceptStartTime = System.currentTimeMillis();
 try {
 socket = serverSocket.accept();
 socket.setSoTimeout(10 * 1000); // Ten seconds
 stream = socket.getInputStream();
 } catch (SocketTimeoutException ste) {
 // This should never happen but bug 56684 suggests that
 // it does.
 log.warn(sm.getString("standardServer.accept.timeout",
 Long.valueOf(System.currentTimeMillis() - acceptStartTime)), ste);
 continue;
 } catch (AccessControlException ace) {
 log.warn("StandardServer.accept security exception: "
 + ace.getMessage(), ace);
 continue;
 } catch (IOException e) {
 if (stopAwait) {
 // Wait was aborted with socket.close()
 break;
 }
 log.error("StandardServer.await: accept: ", e);
 break;
 }
 
 // Read a set of characters from the socket
 int expected = 1024; // Cut off to avoid DoS attack
 while (expected < shutdown.length()) {
 if (random == null)
 random = new Random();
 expected += (random.nextInt() % 1024);
 }
 while (expected > 0) {
 int ch = -1;
 try {
 ch = stream.read();
 } catch (IOException e) {
 log.warn("StandardServer.await: read: ", e);
 ch = -1;
 }
 if (ch < 32) // Control character or EOF terminates loop
 break;
 command.append((char) ch);
 expected--;
 }
 } finally {
 // Close the socket now that we are done with it
 try {
 if (socket != null) {
 socket.close();
 }
 } catch (IOException e) {
 // Ignore
 }
 }
 
 // Match against our command string
 boolean match = command.toString().equals(shutdown);
 if (match) {
 log.info(sm.getString("standardServer.shutdownViaPort"));
 break;
 } else
 log.warn("StandardServer.await: Invalid command '"
 + command.toString() + "' received");
 }
 } finally {
 ServerSocket serverSocket = awaitSocket;
 awaitThread = null;
 awaitSocket = null;
 
 // Close the server socket and return
 if (serverSocket != null) {
 try {
 serverSocket.close();
 } catch (IOException e) {
 // Ignore
 }
 }
 }
 }

正如上面标红部分描述的那样，这个方法一直等待socket连接并接受shutdown命令。上述代码中蓝色标记部分用于一直等待Socket连接，并且判断接收到的指令是否是shutdown变量(在类前面定义了shutdown = "SHUTDOWN";这里用的是equals，因此是大小写敏感的，如果写成了小写的“shutdown”也是不行的哦！！！），如果是，则跳出循环，并关闭socket服务；

（5）如果Tomcat正常运行且没有收到shutdown命令，那么程序会一直等待在await()方法处（阻塞在（4）中的serverSocket.accept()），一旦接收到shutdown命令，awaiit()方法会退出循环等待，并执行stop方法。下面看看stop()方法做了什么：

/**
 * Stop an existing server instance.
 */
 public void stop() {
 
 try {
 // Remove the ShutdownHook first so that server.stop()
 // doesn't get invoked twice
 if (useShutdownHook) {
 Runtime.getRuntime().removeShutdownHook(shutdownHook);
 
 // If JULI is being used, re-enable JULI's shutdown to ensure
 // log messages are not lost
 LogManager logManager = LogManager.getLogManager();
 if (logManager instanceof ClassLoaderLogManager) {
 ((ClassLoaderLogManager) logManager).setUseShutdownHook(
 true);
 }
 }
 } catch (Throwable t) {
 ExceptionUtils.handleThrowable(t);
 // This will fail on JDK 1.2. Ignoring, as Tomcat can run
 // fine without the shutdown hook.
 }
 
 // Shut down the server
 try {
 Server s = getServer();
 LifecycleState state = s.getState();
 if (LifecycleState.STOPPING_PREP.compareTo(state) <= 0
 && LifecycleState.DESTROYED.compareTo(state) >= 0) {
 // Nothing to do. stop() was already called
 } else {
 s.stop();
 s.destroy();
 }
 } catch (LifecycleException e) {
 log.error("Catalina.stop", e);
 }
 
 }

从代码看，首先是在运行时中移除了关闭钩子，然后调用stop方法和destroy()方法分别关闭服务和释放资源。

至此，整个Tomcat的启动过程我们比较详细的进行了说明，至于其中的部分细节并没有详细说明，将另起文章进行单独说明，如类加载器、组件之间如何只要启动一个Server组件就可以全部启动，启动成功之后关闭又是什么样的一个过程等等，如果想知道，可以继续关注我的博客，谢谢。