Tomcat启动分析
tomcat在启动时的重点功能如下：
-
初始化类加载器：主要初始化CommonLoader、CatalinaLoader以及SharedLoader；
-
解析配置文件：使用Digester组件解析Tomcat的server.xml，初始化各个组件（包含各个web应用，解析对应的web.xml进行初始化）；
-
初始化连接器：初始化声明的Connector，以指定的协议打开端口，等待请求。
不管是通过命令行启动还是通过Eclipse的WST server UI，Tomcat的启动流程是在org.apache.catalina.startup. Bootstrap类的main方法中开始的，在启动时，这个类的核心代码如下所示：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
public
static
void
main(String args[]) {
if
(daemon ==
null
) {
daemon =
new
Bootstrap();
//实例化该类的一个实例
try
{
daemon.init();
//进行初始化
}
catch
(Throwable t) {
……;
}
}
try
{
……
//此处略去代码若干行
if
(command.equals(
"start"
)) {
daemon.setAwait(
true
);
daemon.load(args);
//执行load，生成组件实例并初始化
daemon.start();
//启动各个组件
}
……
//此处略去代码若干行
}
|
从以上的代码中，可以看到在Tomcat启动的时候，执行了三个关键方法即init、load、和start。后面的两个方法都是通过反射调用org.apache.catalina.startup.Catalina的同名方法完成的，所以后面在介绍时将会直接转到Catalina的同名方法。首先分析一下Bootstrap的init方法，在该方法中将会初始化一些全局的系统属性、初始化类加载器、通过反射得到Catalina实例，在这里我们重点看一下初始化类加载器的方法：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
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) {
log.error(
"Class loader creation threw exception"
, t);
System.exit(
1
);
}
}
|
在以上的代码总，我们可以看到初始化了三个类加载器，这三个类加载器将会有篇博文进行简单的介绍。
然后我们进入Catalina的load方法：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
|
public
void
load() {
//……
//初始化Digester组件，定义了解析规则
Digester digester = createStartDigester();
//……中间略去代码若干，主要作用为将server.xml文件转换为输入流
try
{
inputSource.setByteStream(inputStream);
digester.push(
this
);
//通过Digester解析这个文件，在此过程中会初始化各个组件实例及其依赖关系
digester.parse(inputSource);
inputStream.close();
}
catch
(Exception e) {
}
// 调用Server的initialize方法，初始化各个组件
if
(getServer()
instanceof
Lifecycle) {
try
{
getServer().initialize();
}
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);
}
}
}
|
在以上的代码中，关键的任务有两项即使用Digester组件按照给定的规则解析server.xml、调用Server的initialize方法。关于Digester组件的使用，后续会有一篇专门的博文进行讲解，而Server的initialize方法中，会发布事件并调用各个Service的initialize方法，从而级联完成各个组件的初始化。每个组件的初始化都是比较有意思的，但是我们限于篇幅先关注Connector的初始化，这可能是最值得关注的。
Connector的initialize方法，核心代码如下：
|
1
2
3
4
5
6
7
8
9
10
11
|
public
void
initialize()
throws
LifecycleException{
//该适配器会完成请求的真正处理
adapter =
new
CoyoteAdapter(
this
);
//对于不同的实现，会有不同的ProtocolHandler实现类，我们来看 //Http11Protocol，它用来处理HTTP请求
protocolHandler.setAdapter(adapter);
try
{
protocolHandler.init();
}
catch
(Exception e) {
……
}
}
|
在Http11Protocol的init方法中，核心代码如下：
|
1
2
3
4
5
6
7
8
9
|
public
void
init()
throws
Exception {
endpoint.setName(getName());
//endpoint为JIoEndpoint的实现类
endpoint.setHandler(cHandler);
try
{
endpoint.init();
//核心代码就是调用 JIoEndpoint的初始化方法
}
catch
(Exception ex) {
……
}
}
|
我们看到最终的初始化方法最终都会调到JIoEndpoint的init方法，网络初始化和对请求的最初处理都是通过该类及其内部类完成的，所以后续的内容将会重点关注此类：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
public
void
init()
throws
Exception {
if
(acceptorThreadCount ==
0
) {
//接受请求的线程数
acceptorThreadCount =
1
;
}
if
(serverSocket ==
null
) {
try
{
if
(address ==
null
) {
//基于特定端口创建一个ServerSocket对象，准备接受请求
serverSocket = serverSocketFactory.createSocket(port, backlog);
}
else
{
serverSocket = serverSocketFactory.createSocket(port, backlog, address);
}
}
catch
(BindException orig) {
……
}
}
}
|
在上面的代码中，我们可以看到此时初始化了一个ServerSocket对象，用来准备接受请求。
如果将其比作赛跑，此时已经到了“各就各位”状态，就等最终的那声“发令枪”了，而Catalina的start方法就是“发令枪”啦：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
public
void
start() {
if
(getServer() ==
null
) {
load();
}
if
(getServer() ==
null
) {
log.fatal(
"Cannot start server. Server instance is not configured."
);
return
;
}
if
(getServer()
instanceof
Lifecycle) {
try
{
((Lifecycle) getServer()).start();
}
catch
(LifecycleException e) {
log.error(
"Catalina.start: "
, e);
}
}
//……
}
|
此时会调用Server的start方法，这里我们重点还是关注JIoEndpoint的start方法：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
public
void
start()
throws
Exception {
if
(!initialized) {
init();
}
if
(!running) {
running =
true
;
paused =
false
;
if
(executor ==
null
) {
//初始化处理连接的线程，maxThread的默认值为200，这也就是为什么 //说Tomcat只能同时处理200个请求的来历
workers =
new
WorkerStack(maxThreads);
}
for
(
int
i =
0
; i < acceptorThreadCount; i++) {
//初始化接受请求的线程
Thread acceptorThread =
new
Thread(
new
Acceptor(), getName() +
"-Acceptor-"
+ i);
acceptorThread.setPriority(threadPriority);
acceptorThread.setDaemon(daemon);
acceptorThread.start();
}
}
}
|
从以上的代码，可以看到，如果没有在server.xml中声明Executor的话，将会使用内部的一个容量为200的线程池用来后续的请求处理。并且按照参数acceptorThreadCount的设置，初始化线程来接受请求。而Acceptor是真正的幕后英雄，接受请求并分派给处理过程：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
protected
class
Acceptor
implements
Runnable {
public
void
run() {
while
(running) {
// 接受发送过来的请求
Socket socket = serverSocketFactory.acceptSocket(serverSocket);
serverSocketFactory.initSocket(socket);
//处理这个请求
if
(!processSocket(socket)) {
//关闭连接
try
{
socket.close();
}
catch
(IOException e) {
// Ignore
}
}
}
}
}
|
从这里我们可以看到，Acceptor接受Socket请求，并调用processSocket方法来进行请求的处理。至此，Tomcat的组件整装待命，等待请求的到来。关于请求的处理，会在下篇文章中介绍。