Tomcat源码解析（十）：启动和关闭

之前一直说，catalina是tomcat的一个重要组成。Server、connector、container都归Catalina来管理，它的主要功能就是，在启动的时候读取server.xml文件，创建server对象，也就创建了server管理的connector、container。在应用程序关闭的时候，它进行一些善后的工作。

shutdown

应用程序关闭的时候，需要做一些清理现场的工作。如果程序正常关闭，可以调用catalina.stop()进行清理。可是如果用户键入ctrl+c或者未关闭程序的情况下退出系统，会导致jvm强制关闭，这时候怎么办呢？

于是就有了ShutdownHook。

ShutdownHook是交给系统的，当程序异常关闭的时候，虚拟机会调用启动之前已经注册的ShutdownHook的run()，来进行清理工作。

// --------------------------------------- CatalinaShutdownHook Inner Class

/**
* CatalinaShutdownHook是catalina的内部类，调用server的stop方法清理内部的connector、container等
* Shutdown hook which will perform a clean shutdown of Catalina if needed.
*/
protected class CatalinaShutdownHook extends Thread {

public void run() {

if (server != null) {
try {
((Lifecycle) server).stop();
} catch (LifecycleException e) {
System.out.println("Catalina.stop: " + e);
e.printStackTrace(System.out);
if (e.getThrowable() != null) {
System.out.println("----- Root Cause -----");
e.getThrowable().printStackTrace(System.out);
}
}
}

}
}

catalina.start

catalina在启动时，读取server.xml文件，创建Server，这是用digester实现的。

/**
* Startup/Shutdown shell program for Catalina.  The following command line
* options are recognized:
* <ul>
* <li><b>-config {pathname}</b> - Set the pathname of the configuration file
*     to be processed.  If a relative path is specified, it will be
*     interpreted as relative to the directory pathname specified by the
*     "catalina.base" system property.   [conf/server.xml]
* <li><b>-help</b> - Display usage information.
* <li><b>-stop</b> - Stop the currently running instance of Catalina.
* </u>
*
* @author Craig R. McClanahan
* @version $Revision: 1.48 $ $Date: 2002/05/23 17:22:37 $
*/

public class Catalina {

/**
* Pathname to the server configuration file.
*/
protected String configFile = "conf/server.xml";

/**
* 管理的Server
* The server component we are starting or stopping
*/
protected Server server = null;

/**
* The application main program.
*
* @param args Command line arguments
*/
public static void main(String args[]) {

(new Catalina()).process(args);
}

/**
* The instance main program.
*
* @param args Command line arguments
*/
public void process(String args[]) {

setCatalinaHome();
setCatalinaBase();
try {
if (arguments(args))
execute();
} catch (Exception e) {
e.printStackTrace(System.out);
}
}

/**
* Execute the processing that has been configured from the command line.
*/
protected void execute() throws Exception {

if (starting)
start();
else if (stopping)
stop();

}

/**
* 创建digester，用于读取server.xml
* Create and configure the Digester we will be using for startup.
*/
protected Digester createStartDigester() {

// Initialize the digester
Digester digester = new Digester();
if (debug)
digester.setDebug(999);
digester.setValidating(false);

// Configure the actions we will be using
digester.addObjectCreate("Server",
"org.apache.catalina.core.StandardServer",
"className");
digester.addSetProperties("Server");
digester.addSetNext("Server",
"setServer",
"org.apache.catalina.Server");//在start()中首先push了catalina，所以此处是调用catalina.setServer()

digester.addObjectCreate("Server/GlobalNamingResources",
"org.apache.catalina.deploy.NamingResources");
digester.addSetProperties("Server/GlobalNamingResources");
digester.addSetNext("Server/GlobalNamingResources",
"setGlobalNamingResources",
"org.apache.catalina.deploy.NamingResources");

//此处...省略一大段

return (digester);

}

/**
* Start a new server instance.
*/
protected void start() {

// Create and execute our Digester
Digester digester = createStartDigester();
File file = configFile();
try {
InputSource is =
new InputSource("file://" + file.getAbsolutePath());
FileInputStream fis = new FileInputStream(file);
is.setByteStream(fis);
digester.push(this);
digester.parse(is);
fis.close();
} catch (Exception e) {
System.out.println("Catalina.start: " + e);
e.printStackTrace(System.out);
System.exit(1);
}

// Setting additional variables
if (!useNaming) {
System.setProperty("catalina.useNaming", "false");
} else {
System.setProperty("catalina.useNaming", "true");
String value = "org.apache.naming";
String oldValue =
System.getProperty(javax.naming.Context.URL_PKG_PREFIXES);
if (oldValue != null) {
value = value + ":" + oldValue;
}
System.setProperty(javax.naming.Context.URL_PKG_PREFIXES, value);
value = System.getProperty
(javax.naming.Context.INITIAL_CONTEXT_FACTORY);
if (value == null) {
System.setProperty
(javax.naming.Context.INITIAL_CONTEXT_FACTORY,
"org.apache.naming.java.javaURLContextFactory");
}
}

// If a SecurityManager is being used, set properties for
// checkPackageAccess() and checkPackageDefinition
if( System.getSecurityManager() != null ) {
String access = Security.getProperty("package.access");
if( access != null && access.length() > 0 )
access += ",";
else
access = "sun.,";
Security.setProperty("package.access",
access + "org.apache.catalina.,org.apache.jasper.");
String definition = Security.getProperty("package.definition");
if( definition != null && definition.length() > 0 )
definition += ",";
else
definition = "sun.,";
Security.setProperty("package.definition",
// FIX ME package "javax." was removed to prevent HotSpot
// fatal internal errors
definition + "java.,org.apache.catalina.,org.apache.jasper.");
}

// Replace System.out and System.err with a custom PrintStream
SystemLogHandler log = new SystemLogHandler(System.out);
System.setOut(log);
System.setErr(log);

Thread shutdownHook = new CatalinaShutdownHook();

// Start the new server
if (server instanceof Lifecycle) {
try {
server.initialize();
((Lifecycle) server).start();
try {
//注册shutdownhook到系统中。如果程序异常关闭，就无法从server.await()返回，就会执行shutdownhook.run()，来进行清理
// Register shutdown hook
Runtime.getRuntime().addShutdownHook(shutdownHook);
} catch (Throwable t) {
// This will fail on JDK 1.2. Ignoring, as Tomcat can run
// fine without the shutdown hook.
}
//await()建立一个单独的线程，等待shutdown指令，收到shutdown指令后返回，就会执行下面的server.stop()，进行关闭操作
// Wait for the server to be told to shut down
server.await();
} catch (LifecycleException e) {
System.out.println("Catalina.start: " + e);
e.printStackTrace(System.out);
if (e.getThrowable() != null) {
System.out.println("----- Root Cause -----");
e.getThrowable().printStackTrace(System.out);
}
}
}

// Shut down the server
if (server instanceof Lifecycle) {
try {
try {
// Remove the ShutdownHook first so that server.stop()
// doesn't get invoked twice
Runtime.getRuntime().removeShutdownHook(shutdownHook);
} catch (Throwable t) {
// This will fail on JDK 1.2. Ignoring, as Tomcat can run
// fine without the shutdown hook.
}
((Lifecycle) server).stop();
} catch (LifecycleException e) {
System.out.println("Catalina.stop: " + e);
e.printStackTrace(System.out);
if (e.getThrowable() != null) {
System.out.println("----- Root Cause -----");
e.getThrowable().printStackTrace(System.out);
}
}
}

}

catalina.stop

catalina.process收到关闭命令时，调用stop()进行清理工作。

“`

/**
* Stop an existing server instance.
*/
protected void stop() {

// Create and execute our Digester
//这里只读取了server部分，是为了回收前一个Server吗？？
Digester digester = createStopDigester();
File file = configFile();
try {
InputSource is =
new InputSource("file://" + file.getAbsolutePath());
FileInputStream fis = new FileInputStream(file);
is.setByteStream(fis);
digester.push(this);
digester.parse(is);
fis.close();
} catch (Exception e) {
System.out.println("Catalina.stop: " + e);
e.printStackTrace(System.out);
System.exit(1);
}

// Stop the existing server
try {
//发送shutdown命令，await线程收到后，从await()返回，即可执行server.stop()
Socket socket = new Socket("127.0.0.1", server.getPort());
OutputStream stream = socket.getOutputStream();
String shutdown = server.getShutdown();
for (int i = 0; i < shutdown.length(); i++)
stream.write(shutdown.charAt(i));
stream.flush();
stream.close();
socket.close();
} catch (IOException e) {
System.out.println("Catalina.stop: " + e);
e.printStackTrace(System.out);
System.exit(1);
}
}

/**
* Create and configure the Digester we will be using for shutdown.
*/
protected Digester createStopDigester() {

// Initialize the digester
Digester digester = new Digester();
if (debug)
digester.setDebug(999);

// Configure the rules we need for shutting down
//只读取了server部分
digester.addObjectCreate("Server",
"org.apache.catalina.core.StandardServer",
"className");
digester.addSetProperties("Server");
digester.addSetNext("Server",
"setServer",
"org.apache.catalina.Server");

return (digester);

}

stop()中创建了一个新的digester，读取server.xml文件。不过读取的内容要少一些，只创建了一个简单的Server对象，没有创建内部的connector、container。然后从这个server中，拿到shutdown命令，并发送。这里为什么要创建一个新的server呢?

我的理解是，创建一个新的server，catalina就不再包含旧的server的引用。这样，等待shutdown命令的线程收到命令并结束，旧的server从await()返回后，旧的server就可以被回收了。

启动脚本

tomcat实际启动，不是手动运行Bootstrap.jar来执行的，而是sh catalina.sh start这样启动脚本来启动。tomcat下bin目录下有多个.sh文件，包括startup.sh catalina.sh shutdown.sh等。startup.sh shutdown.sh实际都是调用了catalina.sh,只是传递了不同的参数。这个可以通过Catalina类的代码也可以看出，传递不同的参数，会执行不同的操作，包括开始和结束。