声明:源码版本为Tomcat 6.0.35
前面的文章中介绍了Tomcat的基本配置,每个配置项也基本上对应了Tomcat的组件结构,如果要用一张图来形象展现一下Tomcat组成的话,整个Tomcat的组成可以如下图所示:
Tomcat在接收到用户请求时,将会通过以上组件的协作来给最终用户产生响应。首先是最外层的Server和Service来提供整个运行环境的基础设施,而Connector通过指定的协议和接口来监听用户的请求,在对请求进行必要的处理和解析后将请求的内容传递给对应的容器,经过容器一层层的处理后,生成最终的响应信息,返回给客户端。
Tomcat的容器通过实现一系列的接口,来统一处理一些生命周期相关的操作,而Engine、Host、Context等容器通过实现Container接口来完成处理请求时统一的模式,具体表现为该类容器内部均有一个Pipeline结构,实际的业务处理都是通过在Pipeline上添加Valve来实现,这样就充分保证整个架构的高度可扩展性。Tomcat核心组件的类图如下图所示:
在介绍请求的处理过程时,将会详细介绍各个组件的作用和处理流程。本文将会主要分析Tomcat的启动流程,介绍涉及到什么组件以及初始化的过程,简单期间将会重点分析HTTP协议所对应Connector启动过程。
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的组件整装待命,等待请求的到来。关于请求的处理,会在下篇文章中介绍。