Tomcat源码分析三：Tomcat启动加载过程（一）的源码解析

Tomcat启动加载过程（一）的源码解析

今天，我将分享用源码的方式讲解Tomcat启动的加载过程，关于Tomcat的架构请参阅《Tomcat源码分析二：先看看Tomcat的整体架构》一文。

先看看应用情况

在《Servlet与Tomcat运行示例》一文中，我详细的记录了Tomcat是如何启动一个Servlet的程序的步骤。其中，第6步骤是启动Tomcat，也就是在windows系统上执行startup.bat， 在linux操作系统上执行startup.sh的脚本。那么，我们就从这个脚本出发，走进Tomcat，看看它是如何启动的？这里，我们以startup.sh为例，windows端的startup.bat类似。

startup.sh的内容是什么？

我们先看看tomcat的启动脚本startup.sh的内容是什么，先看看其脚本内容(省略部分注释)，如下：

#!/bin/sh

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

提取其中主要的几句：

PRGDIR=`dirname "$PRG"`
EXECUTABLE=catalina.sh
exec "$PRGDIR"/"$EXECUTABLE" start "$@"

简而概之，该脚本的执行内容为：调用catalina.sh脚本。下面，我们继续来看下catalina.sh脚本的内容

catalina.sh脚本

由于catalina.sh脚本内容比较多，这里提取一些重要的内容，然后解释其用途：

再简要的描述下在catalina.sh中作用：完成环境检查、环境初始化、参数初始化、启动操作步骤。注意一下上图中被绿色框出来的内容，可以看到其调用执行的是org.apache.catalina.startup.Bootstrap类，并且传输过去的command指令为start。

回归Java代码

Bootstrap类进行了什么操作呢？

接下来，我们带着这几个问题来去探索一下Bootstrap类：

• Bootstrap类在接收到start指令后要去干什么？
• Bootstrap类在启动过程中的职责是什么？

下面，我们带着上面的几个问题来具体的探讨一下Tomcat的源码。先来看看Bootstrap类的main方法：

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

从这段代码中，可以看出，其主要实现了两个功能：

• 初始化一个守护进程变量daemon
• 加载catalina.sh传递过来的参数，解析catalina.sh传递过来的指令，并按照指令执行程序，控制守护进程daemon的启停等操作

bootstrap.init();有什么操作呢？

针对上面的两个功能，我们进入到 init()方法看下有什么操作，先看下init()方法的代码：

public void init() throws Exception {

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

在init()方法中，首先执行的方法initClassLoaders()的作用是初始化三个类加载器，代码如下：

/**
* Daemon reference.
*/
private Object catalinaDaemon = null;

ClassLoader commonLoader = null;
ClassLoader catalinaLoader = null;
ClassLoader sharedLoader = null;

private void initClassLoaders() {
try {
commonLoader = createClassLoader("common", null);
if (commonLoader == null) {
// no config file, default to this loader - we might be in a 'single' env.
commonLoader = this.getClass().getClassLoader();
}
catalinaLoader = createClassLoader("server", commonLoader);
sharedLoader = createClassLoader("shared", commonLoader);
} catch (Throwable t) {
handleThrowable(t);
log.error("Class loader creation threw exception", t);
System.exit(1);
}
}

private ClassLoader createClassLoader(String name, ClassLoader parent)
throws Exception {

String value = CatalinaProperties.getProperty(name + ".loader");
if ((value == null) || (value.equals("")))
return parent;

value = replace(value);

List<Repository> repositories = new ArrayList<>();

String[] repositoryPaths = getPaths(value);

for (String repository : repositoryPaths) {
// Check for a JAR URL repository
try {
@SuppressWarnings("unused")
URL url = new URL(repository);
repositories.add(new Repository(repository, RepositoryType.URL));
continue;
} catch (MalformedURLException e) {
// Ignore
}

// Local repo
3ff8
sitory
if (repository.endsWith("*.jar")) {
repository = repository.substring
(0, repository.length() - "*.jar".length());
repositories.add(new Repository(repository, RepositoryType.GLOB));
} else if (repository.endsWith(".jar")) {
repositories.add(new Repository(repository, RepositoryType.JAR));
} else {
repositories.add(new Repository(repository, RepositoryType.DIR));
}
}

return ClassLoaderFactory.createClassLoader(repositories, parent);
}

//  catalina.properties
common.loader="${catalina.base}/lib","${catalina.base}/lib/*.jar","${catalina.home}/lib","${catalina.home}/lib/*.jar"

• commonLoader: 根据common.loader属性的配置(通过代码

  CatalinaProperties.getProperty(name + ".loader");

  读取：catalina.properties), 创建commonLoader类加载器, 默认情况下顺序加载 ${catalina.base}/lib, ${catalina.base}/lib/.jar, ${catalina.home}/lib, ${catalina.home}/lib/.jar 四个目录下的class和jar.
• catalinaLoader: 根据server.loader属性的配置, 创建catalinaLoader类加载器，其父类加载其为commonLoader, 默认server.loader属性为空, 直接使用commonLoader.
• sharedLoader:根据shared.loader属性配置,创建sharedLoader类加载器，其父类加载其为commonLoader, 默认shared.loader属性为空, 直接使用commonLoader.

当执行完initClassLoaders()方法之后，调用Thread.currentThread().setContextClassLoader(catalinaLoader);设置上下文类加载器为catalinaLoader，从上面解析的情况看，其实设置的上下文类加载器为catalinaLoader的父类commonLoader。

SecurityClassLoad.securityClassLoad(catalinaLoader)

的作用是如果有SecurityManager，提前加载部分类。

之后，通过使用catalinaLoader加载org.apache.catalina.startup.Catalina类，创建实例Catalina并利用反射调用方法setParentClassLoader()，设置Catalina实例的parentClassLoader属性为sharedLoader类加载器（也就是commonLoader）。

最后，设置daemon为新创建的实例Bootstrap。接下来，看一下main()方法下的指令处理。

传递过来的command指令是如何处理的呢？

我们观察一下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();
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) {
// ...... 省略
}

可以看到，其默认指令为

start

， 然后，其根据接收到的参数区分为startd、stopd、start、stop、configtest和其他6种指令情况。这里我们主要看一下start指令的执行逻辑。

• daemon.setAwait(true) ：这句代码有什么含义呢，下面我们来具体的分析一下：

/**
* Set flag.
* @param await <code>true</code> if the daemon should block
* @throws Exception Reflection error
*/
public void setAwait(boolean await)
throws Exception {

Class<?> paramTypes[] = new Class[1];
paramTypes[0] = Boolean.TYPE;
Object paramValues[] = new Object[1];
paramValues[0] = Boolean.valueOf(await);
Method method =
catalinaDaemon.getClass().getMethod("setAwait", paramTypes);
method.invoke(catalinaDaemon, paramValues);
}

这段代码的主要作用是通过反射调用Catalina.setAwait(true)，主要目的是当启动完成后， 阻塞main线程，等待stop命令到来。 如果不设置daemon.setAwait(true)， 则main线程执行完之后就 直接退出了。

• daemon.load(args)
  daemon.load(args);其实是最终执行的Catalina.load()，在Catalina.load()方法中，主要功能是首先初始化temp目录，然后再初始化naming的一些系统属性，然后获取server.xml配置文件, 创建Digester实例, 开始解析server.xml的操作。

/**
* Start a new server instance.
*/
public void load() {

if (loaded) {
return;
}
loaded = true;

long t1 = System.nanoTime();

initDirs();

// Before digester - it may be needed
initNaming();

// Set configuration source
ConfigFileLoader.setSource(new CatalinaBaseConfigurationSource(Bootstrap.getCatalinaBaseFile(), getConfigFile()));
File file = configFile();

// Create and execute our Digester
Digester digester = createStartDigester();

try (ConfigurationSource.Resource resource = ConfigFileLoader.getSource().getServerXml()) {
InputStream inputStream = resource.getInputStream();
InputSource inputSource = new InputSource(resource.getURI().toURL().toString());
inputSource.setByteStream(inputStream);
digester.push(this);
digester.parse(inputSource);
} catch (Exception e) {
log.warn(sm.getString("catalina.configFail", file.getAbsolutePath()), e);
if (file.exists() && !file.canRead()) {
log.warn(sm.getString("catalina.incorrectPermissions"));
}
return;
}

getServer().setCatalina(this);
getServer().setCatalinaHome(Bootstrap.getCatalinaHomeFile());
getServer().setCatalinaBase(Bootstrap.getCatalinaBaseFile());

// 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(sm.getString("catalina.initError"), e);
}
}

long t2 = System.nanoTime();
if(log.isInfoEnabled()) {
log.info(sm.getString("catalina.init", Long.valueOf((t2 - t1) / 1000000)));
}
}

• daemon.start()： 启动Tomcat

通过调用daemon.start()启动Tomcat，其内容如下：

/**
* Start the Catalina daemon.
* @throws Exception Fatal start error
*/
public void start() throws Exception {
if (catalinaDaemon == null) {
init();
}

Method method = catalinaDaemon.getClass().getMethod("start", (Class [])null);
method.invoke(catalinaDaemon, (Object [])null);
}

程序通过反射的方式调用Catalina.start()方式启动Tomcat，下面，我们看下Catalina.start()方法的实现逻辑：

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

if (getServer() == null) {
load();
}

if (getServer() == null) {
log.fatal(sm.getString("catalina.noServer"));
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(sm.getString("catalina.startup", Long.valueOf((t2 - t1) / 1000000)));
}

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

可以看出，程序调用getServer().start()启动，getServer()方法返回的是一个StandardServer类，继而其调用的是StandardServer.startInternal()方法，在StandardServer中，又调用到StandardService.startInternal()方法。

// StandardServer.java
protected void startInternal() throws LifecycleException {

fireLifecycleEvent(CONFIGURE_START_EVENT, null);
setState(LifecycleState.STARTING);

globalNamingResources.start();

// Start our defined Services
synchronized (servicesLock) {
for (int i = 0; i < services.length; i++) {
services[i].start();
}
}
// ......省略部分代码
}

protected void startInternal() throws LifecycleException {

if(log.isInfoEnabled())
log.info(sm.getString("standardService.start.name", this.name));
setState(LifecycleState.STARTING);

// Start our defined Container first
if (engine != null) {
synchronized (engine) {
engine.start();
}
}

synchronized (executors) {
for (Executor executor: executors) {
executor.start();
}
}

mapperListener.start();

// Start our defined Connectors second
synchronized (connectorsLock) {
for (Connector connector: connectors) {
// If it has already failed, don't try and start it
if (connector.getState() != LifecycleState.FAILED) {
connector.start();
}
}
}
}

注意，这里为什么不是start()方法，而是startInternal()方法呢？原因是StandardServer和StandService类都继承了LifecycleMBeanBase类，而LifecycleMBeanBase类又继承了LifecycleBase类。下面看下LifecycleBase类的start()方法：

public final synchronized void start() throws LifecycleException {

if (LifecycleState.STARTING_PREP.equals(state) || LifecycleState.STARTING.equals(state) ||
LifecycleState.STARTED.equals(state)) {

if (log.isDebugEnabled()) {
Exception e = new LifecycleException();
log.debug(sm.getString("lifecycleBase.alreadyStarted", toString()), e);
} else if (log.isInfoEnabled()) {
log.info(sm.getString("lifecycleBase.alreadyStarted", toString()));
}

return;
}

if (state.equals(LifecycleState.NEW)) {
init();
} else if (state.equals(LifecycleState.FAILED)) {
stop();
} else if (!state.equals(LifecycleState.INITIALIZED) &&
!state.equals(LifecycleState.STOPPED)) {
invalidTransition(Lifecycle.BEFORE_START_EVENT);
}

try {
setStateInternal(LifecycleState.STARTING_PREP, null, false);
startInternal();
if (state.equals(LifecycleState.FAILED)) {
// This is a 'controlled' failure. The component put itself into the
// FAILED state so call stop() to complete the clean-up.
stop();
} else if (!state.equals(LifecycleState.STARTING)) {
// Shouldn't be necessary but acts as a check that sub-classes are
// doing what they are supposed to.
invalidTransition(Lifecycle.AFTER_START_EVENT);
} else {
setStateInternal(LifecycleState.STARTED, null, false);
}
} catch (Throwable t) {
// This is an 'uncontrolled' failure so put the component into the
// FAILED state and throw an exception.
handleSubClassException(t, "lifecycleBase.startFail", toString());
}
}

可以看出，调用start()方法，最终都会调用到startInternal()方法。在下篇文章中，我们将详细看下StandardService.java中的engine.start()、executor.start()、connector.start()都分别启动了什么？敬请期待！

微信公众号： 源码湾

欢迎关注本人微信公众号： 源码湾。 本公众号将不定期进行相关源码及相关开发技术的分享，共同成长，共同进步～

Blog:

• 简书： https://www.jianshu.com/u/91378a397ffe
• csdn： https://blog.csdn.net/ZhiyouWu
• 开源中国： https://my.oschina.net/u/3204088
• 掘金： https://juejin.im/user/5b5979efe51d451949094265
• 博客园： https://www.cnblogs.com/zhiyouwu/
• 微信公众号： 源码湾
• 微信： WZY1782357529 (欢迎沟通交流)