深入分析理解Tomcat体系结构

时间:2022-03-12 15:56:45

Tomcat整体结构

深入分析理解Tomcat体系结构

  由上图可知Tomcat的顶层容器是Server,而且一个Tomcat对应一个Server,一个server有多个service提供服务.service包含两个重要组件:Connector和Container.这个后面详细讲解.这个Server由谁来管理呢?当然是Catalina了,她是tomcat的管理类,她的三个方法load,start,stop分别用来管理整个服务器的生命周期.

Load方法:Load方法根据conf/server.xml文件创建Server并调用Server的init方法进行初始化.Server的init方法调用所有service的init方法,service的init方法调用所有Connector和Container的init方法.整个初始化工作就完成了.

Start方法:用于启动服务,类似init,也是逐层进行启动.

Stop方法:用于关闭服务,类似init,也是逐层调用关闭.

最后,CatAlina中的await方法非常重要,这个方法调用Server中的await方法,这个方法的作用就是进入一个循环,保持主线程不退出.

Tomcat组件启动过程

深入分析理解Tomcat体系结构

Bootstrap的启动过程

Tomcat启动的入口方法就是Bootstrap中的main方法,代码如下:

 public static void main(String args[]) {
if (daemon == null) {
// Don't set daemon until init() has completed
Bootstrap bootstrap = new Bootstrap();
try {//初始化ClassLoader,创建了Catalina实例,赋值给catalinaDaemon
bootstrap.init();
} catch (Throwable t) {
handleThrowable(t);
t.printStackTrace();
return;
}
daemon = bootstrap;
} else {
// When running as a service the call to stop will be on a new
// thread so make sure the correct class loader is used to prevent
// a range of class not found exceptions.
Thread.currentThread().setContextClassLoader(daemon.catalinaLoader);
}
//根据args参数执行不同的命令
try {
String command = "start";//默认执行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();
} 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);
}
}
public void start()
throws Exception {
if( catalinaDaemon==null ) init(); Method method = catalinaDaemon.getClass().getMethod("start", (Class [] )null);
method.invoke(catalinaDaemon, (Object [])null); }

调用执行start方法前,先判断catalinaDaemon有没有被初始化,如果没有则执行init方法,然后使用Method进行反射调用Catalina的start方法.

知识点补充:

Method是java.lang.reflect包里的类,可以使用其中的invoke方法来执行所代表的方法,invoke里有两个参数,第一个参数是Method方法所在的实体,第二个参数是可变参数,用于Method方法执行时所需要的参数.

Catalina的启动过程

Catalina的启动主要调用setAwait,load和start方法来完成.setAwait方法用于设置Server启动后是否进入等待状态的标志,为true进入,否则不进入.load方法用于加载配置文件,start方法用于启动服务器.

public void setAwait(boolean b) {
await = b;
} public void load() {
//...创建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("Catalina.start", e);
} }
//...
} /**
* Start a new server instance.
*/
public void start() { if (getServer() == null) {
load();
} if (getServer() == null) {
log.fatal("Cannot start server. Server instance is not configured.");
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;
}
//...
if (await) {
await();
stop();
}
}

Server的启动过程

  Server接口中提供了addService(Service service),removeService(Service service)来增加和删除Service,Server中的init和start方法循环调用Service中的init和start方法来启动所有Service.Server的默认实现是StandardServer.

Service的启动过程

  Service的默认实现是StandardService,和StandardServer一样也继承自LifecycleMBeanBase类,所以init和start方法最终会调用initInternal和startInternal方法.而StandardService中的initInternal和startInternal方法主要调用container,executors,mapperListener,connectors的init和start方法.

Tomcat声明周期管理

1.Lifecycle接口

  Tomcat通过Lifecycle接口统一管理生命周期,所有生命周期组件都要实现这个接口,Lifecycle接口主要做了4件事:

1)       定义了13个String类型常量,用于LifecycleEvent事件的type属性中,作用是为了区分组件发出LifecycleEvent事件的状态.

2)       定义了3个管理监听器的方法addLifecycleListener,findLifecycleListener,removeLifecycleListener,分别用来添加,查找,删除LifecycleListener类型的监听器.

3)       定义了4个生命周期方法:init,start,stop和destroy,用于执行生命周期的各个阶段的操作.

4)       定义了获取当前状态的两个方法:getState和getStateName,用来获取当前的状态.

具体接口代码如下:

public interface Lifecycle {
//13中LifecycleEvent事件的类型
public static final String BEFORE_INIT_EVENT = "before_init"; public static final String AFTER_INIT_EVENT = "after_init"; public static final String START_EVENT = "start"; public static final String BEFORE_START_EVENT = "before_start"; public static final String AFTER_START_EVENT = "after_start"; public static final String STOP_EVENT = "stop"; public static final String BEFORE_STOP_EVENT = "before_stop"; public static final String AFTER_STOP_EVENT = "after_stop"; public static final String AFTER_DESTROY_EVENT = "after_destroy"; public static final String BEFORE_DESTROY_EVENT = "before_destroy"; public static final String PERIODIC_EVENT = "periodic"; public static final String CONFIGURE_START_EVENT = "configure_start"; public static final String CONFIGURE_STOP_EVENT = "configure_stop"; //3个管理监听器的方法
public void addLifecycleListener(LifecycleListener listener); public LifecycleListener[] findLifecycleListeners(); public void removeLifecycleListener(LifecycleListener listener); //4个生命周期方法
public void init() throws LifecycleException; public void start() throws LifecycleException; public void stop() throws LifecycleException; public void destroy() throws LifecycleException; //2个获取当前状态的方法
public LifecycleState getState(); public String getStateName();
}

2.LifecycleBase

  LifecycleBase是Lifecycle的默认实现,所有实现了生命周期的组件都直接或间接的继承了LifecycleBase.LifecycleBase为Lifecycle里的接口方法提供了默认实现.监听器管理是专门提供了一个LifecycleSupport类来完成,在LifecycleSupport中定义了LifecycleListener类型的数组,用来保存所有监听器,并定义了添加,删除,查找,执行监听器的方法;生命周期中设置了相应的状态并调用了相应的模板方法,init,start,stop,destroy所对应的模板方法分别是initInternal,startInternal,stopInternal,destroyInternal方法,执行生命周期就是这4个方法.组件的当前状态在这4个方法中已经设置好了,所以直接返回就OK了.

Container分析

  Container是Tomcat中容器的接口,通常使用的Servlet就封装在其子接口Wrapper中.Container一共有4个接口Engine,Host,Context,Wrapper和一个默认实现类ContainerBase,每个子接口都是一个容器,这四个容器都有一个对应的StandardXXX实现类,并且这些实现类都继承自ContainerBase类.Container还继承Lifecycle接口,而且ContainerBase间接继承LifecycleBase. 4个接口Engine,Host,Context,Wrapper也符合Tomcat的生命周期管理模式.

1.Container容器结构

深入分析理解Tomcat体系结构

2.4个容器的作用

Engine:引擎,用来管理多个站点,一个Service最多只能有一个Engine.

Host:代表一个站点,也可叫虚拟主机,通过配置Host来添加站点.

Context:代表一个应用程序,对应一套程序或者WEB-INF目录及下面的web.xml

Wraper:每个Wrapper封装着一个Servlet.

Pipeline-value管道

  Container处理请求是使用Pipeline-value管道来处理的.Pipeline-value是责任链模式,区别于普通的责任链模式:

1)       每个Pipeline都有特定的Value,而且是在管道的最后执行,这个value叫做BaseValue,是不可删除的.

2)       在上层容器的BaseValue中会调用下层容器的管道.

Pipeline的实现方法

Pipeline管道的实现分为生命周期管理和处理请求两部分.

1.生命周期实现方法

Container中的Pipeline在抽象实现类ContainerBase中定义,并在生命周期的startInternal,stopInternal,destroyInternal方法中调用管道的相应生命周期方法.

2.处理请求实现方法

Pipeline调用所包含Value的invoke方法来处理请求,并且在BaseValue里又调用了子容器Pipeline所包含Value的invoke方法,直到最后调用了Wrapper的Pipeline所包含的BaseValue—StandardWrapperValue

Connector分析

  Connector用于接收请求并将请求封装成Request和Response来具体处理,最底层是使用Socket来进行连接的,Request和Response是按照Http协议来封装的,所以Connector同时实现了TCP/IP协议和HTTP协议,Request和Response封装完之后交给Container进行处理,Container就是Servlet容器,Container处理完成之后返回给Connector,最后Connector使用Socket将处理结果返回给客户端,整个请求就完成了.

深入分析理解Tomcat体系结构

  Connector中具体是用ProtocolHandler来处理请求,并且Connector的创建过程主要是初始化ProtocolHandler.不同的ProtocolHandler代表不同的连接类型.Http11Protocol使用的是普通的Socket来连接的.Http11NioProtocol使用的是NioSocket来连接的.

Protocol三个重要组件:

Endpoint:用于处理底层的Socket网络连接.

Processor:用于将Enpoint接收到的请求封装成Request

Adapter:用于将封装好的Request交给Container处理.

最近学习有些懈怠了,主要是工作太忙,下班后基本剩下上床睡觉了.无论如何还是要不断加强学习,提高自身技术水平.