Tomcat组件梳理--Catalina
1.定义和功能
Catalina是Tomcat的核心组件，是Servlet容器，Catalina包含了所有的容器组件，其他模块均为Catalina提供支撑。通过Coyote模块提供连接通信，Jasper模块提供JSP引擎，Naming提供JNDI服务，Juli提供日志服务。结构如下：
主要的功能包括接收请求，处理请求，返回结果。但是这些具体的实现是在catalina里面的子容器里面，我们在对应的文章里面讲解，此处聚焦在Catalina的源代码提供的功能上。
处理上面这些，Catalina还提供启动入口，关闭入口等。
2.属性
//org.apache.catalina.startup.Catalina
/**
* 用于await的flag
*/
protected boolean await = false;
/**
* Server配置的文件路
*/
protected String configFile = "conf/server.xml";
/**
* The shared extensions class loader for this server.
* 此server的shared 类加载器
*/
protected ClassLoader parentClassLoader =
Catalina.class.getClassLoader();
/**
* Server组件
*/
protected Server server = null;
/**
* 使用shutdown钩子的flag
*/
protected boolean useShutdownHook = true;
/**
* Shutdown钩子实例
*/
protected Thread shutdownHook = null;
/**
* 默认需要开启Naming
*/
protected boolean useNaming = true;
/**
* 预防重复加载的标记字段
*/
protected boolean loaded = false;
有几个主要的属性。
- Catalina的子组件Server，通过digster工具解析server.xml文件构造该对象。
- 用户shutdown时的钩子，是否使用以及调用的线程
- 是否需要启动JNDI的标识
- Server.xml配置文件的地址
- stop用的await标记
- 父类加载器。
3.操作
Catalina的操作有比较明显的区分，因为主要是处理来自shell的不同命令，所以，根据shell的传入的命令行，我们可以看到Catalina主要处理来自shell的start和stop命令。下面来解析start命令和stop命令的背后，以及Tomcat中提供的一个对xml解析很有用的库Digester。
再看一下Bootstrap类中的main方法中对shell命令的处理,可以看到start时主要调用load(args)和start()方法，stop时主要调用stopServer(args)方法。
//3.判断shell传入的值，执行对应的动作
if (command.equals("startd")) {
//执行start方法的内容，主要为执行Catalina的load()和start()方法
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.");
}
3.1.执行shell的start命令
3.1.1.调用load(args)方法
现在我们知道Shell的start命令交给Catalina处理时，实际上调用了load(args)和start()方法。我们先看load(args)方法
//org.apache.catalina.startup.Catalina#load(java.lang.String[])
/*
* 使用参数进行load
*/
public void load(String args[]) {
try {
//1.根据传入的参数设置Catalina的一些属性的值
if (arguments(args)) {
//2.调用无参的load()方法
load();
}
} catch (Exception e) {
e.printStackTrace(System.out);
}
}
可以看到这里有两个业务逻辑：
- 1.根据传入的参数设置Catalina的一些属性，这些属性主要就是Naming等一些值。
- 2.调用午餐的load()方法
再看load()方法，去掉里面的异常和环境检查，可以看到主要逻辑如下：
//org.apache.catalina.startup.Catalina#load()
/**
* 准备好环境，解析好server.xml文件生成好对象。server对象也准备好，然后调用server的init方法
*/
public void load() {
//1.检查java.io.tmpdir是有有效
initDirs();
//2.设置catalina.useNaming的系统参数
initNaming();
//3.用digester解析server.xml文件，把配置文件中的配置解析成java对象
//3.1.准备好用来解析server.xml文件需要用的digester。
Digester digester = createStartDigester();
//3.2.server.xml文件作为一个输入流传入
File file = configFile();
InputStream inputStream = new FileInputStream(file);
//3.3.使用inputStream构造一个sax的inputSource
InputSource inputSource = new InputSource(file.toURI().toURL().toString());
inputSource.setByteStream(inputStream);
//3.4.把当前类压入到digester的栈顶，用来作为digester解析出来的对象的一种引用
digester.push(this);
//3.5.调用digester的parse()方法进行解析。
digester.parse(inputSource);
//4.为子组件Server设置一些值
getServer().setCatalina(this);
getServer().setCatalinaHome(Bootstrap.getCatalinaHomeFile());
getServer().setCatalinaBase(Bootstrap.getCatalinaBaseFile());
//执行server的init方法，start方法的准备方法
getServer().init();
}
分析一下主要逻辑
1.检查java.io.tmpdir是有有效，这个没啥好说的。
2.设置catalina.useNaming的系统参数，这个也没啥好多的，等主要流程梳理完，咱们做一个JDNI的源码解析。
3.用digester解析server.xml文件，把配置文件中的配置解析成java对象。该过程需要经过5个步骤才可以。
- 3.1.准备好用来解析server.xml文件需要用的digester。
- 3.2.读取server.xml文件作为一个输入流。
- 3.3.使用inputStream构造一个sax的inputSource，因为digester底层用的是sax去解析的。
- 3.4.把当前类压入到digester的栈顶，用来作为digester解析出来的对象的一种引用，digester自带一个栈的结构。
- 3.5.调用digester的parse()方法进行解析。前面几步都是在准备环境，这里才是正真的去解析了。
4.为子组件Server设置一些值，并调用server的init方法，start方法的准备方法。
这里面最值得说的应该就是第3步，通过Digester去解析xml文件，每遇到一个匹配的节点，都可以添加一个对应的事件。对Digester的操作都是一些普通的API操作，这里就不解释了，可以查看官方文档，或者查看博客，API挺简单的。
3.1.2.调用start()方法
start()方法主要作用就是调用Server的start()方法，并将一个shutdown的钩子加到JVM中。
主要的逻辑如下：
- 1.执行Server的start()方法，如果执行失败，就调用Server的destroy()方法
- 2.注册一个shutdown的钩子
- 3.等待处理如何停止的问题
比较有意思的是3，如何停止一个服务，这种方法比较有意思，不过我们放在Server组件中去讲，因为实现是放在Server中的。
//org.apache.catalina.startup.Catalina#start
public void start() {
//1.执行Server的start()方法，如果执行失败，就调用Server的destroy()方法
try {
//执行server的start方法
getServer().start();
} catch (LifecycleException e) {
try {
//如果start失败，就调用server的destroy方法
getServer().destroy();
} catch (LifecycleException e1) {
log.debug("destroy() failed for failed Server ", e1);
}
return;
}
//2.注册一个shutdown的钩子
if (useShutdownHook) {
if (shutdownHook == null) {
shutdownHook = new CatalinaShutdownHook();
}
Runtime.getRuntime().addShutdownHook(shutdownHook);
}
//3.等待处理如何停止的问题
if (await) {
await();
stop();
}
}
在第2步的逻辑中，new了一个类去注册，该类的主要处理逻辑如下：
protected class CatalinaShutdownHook extends Thread {
@Override
public void run() {
try {
if (getServer() != null) {
//1.调用Catalina的stop()方法
Catalina.this.stop();
}
} catch (Throwable ex) {
ExceptionUtils.handleThrowable(ex);
log.error(sm.getString("catalina.shutdownHookFail"), ex);
} finally {
// If JULI is used, shut JULI down *after* the server shuts down
// so log messages aren't lost
LogManager logManager = LogManager.getLogManager();
if (logManager instanceof ClassLoaderLogManager) {
((ClassLoaderLogManager) logManager).shutdown();
}
}
}
}
可以看到，只是去调用Catalina的stop()方法。不过这总调用方法也是比较奇特的，通过Catalina.this.stop()方法，不知道这种是不是可以跨线程调用一个类的实例，如果能，那将是一个很棒。
[补充]：Catalina.this方法是内部类调用外部类的方法。可以用来解决线程之间传递示例的问题。
3.2.执行shell的stop命令
shell的stop命令落在Catalina上只是去调用stopServer(args)方法，具体方法实现如下：
public void stopServer(String[] arguments) {
//1.参数设置
if (arguments != null) {
arguments(arguments);
}
Server s = getServer();
//2.如果Server存在，就调用Server的stop和destroy方法进行关闭，
if (s == null) {
// Create and execute our Digester
Digester digester = createStopDigester();
File file = configFile();
try (FileInputStream fis = new FileInputStream(file)) {
InputSource is =
new InputSource(file.toURI().toURL().toString());
is.setByteStream(fis);
digester.push(this);
digester.parse(is);
} catch (Exception e) {
log.error("Catalina.stop: ", e);
System.exit(1);
}
} else {
// Server object already present. Must be running as a service
try {
s.stop();
s.destroy();
} catch (LifecycleException e) {
log.error("Catalina.stop: ", e);
}
return;
}
// 3.如果Server不存在，就重新解析server.xml文件构造server，然后通过socket发送shutdown命令关闭
s = getServer();
if (s.getPort()>0) {
try (Socket socket = new Socket(s.getAddress(), s.getPort());
OutputStream stream = socket.getOutputStream()) {
String shutdown = s.getShutdown();
for (int i = 0; i < shutdown.length(); i++) {
stream.write(shutdown.charAt(i));
}
stream.flush();
} catch (Exception ce) {
ce.printStackTrace();
}
} else {
log.error(sm.getString("catalina.stopServer"));
System.exit(1);
}
}
主要的业务逻辑有三个：
- 1.参数设置
- 2.如果Server存在，就调用Server的stop和destroy方法进行关闭
- 3.如果Server不存在，就重新解析server.xml文件构造server，然后通过socket发送shutdown命令关闭
关闭Server的具体实现，我们放在Server组件中。
4.总结
我们根据用户的调用，梳理了Catalina对start和stop命令行的相应方法。其中Digester对xml文件的解析时值得注意的，停止Server的方式也比较有意思，但是我们放在Server中解析。