tomcat8 生命周期

1. tomcat组件架构图

Server：表示一个运行在JVM的tomcat实例

Service：表示tomcat的服务，是由连接器和容器两大部分组成

Connector：表示连接器，由HTTP、AJP、HTTPS组成。其中HTTP主要用于解析http请求报文，HTTPS是在HTTP基础上增加了加密传输的功能。AJP是tomcat内部协议

Engine：表示servlet引擎。

Host：表示虚拟主机，一个Host代表一个站点，可以配置多个

Context：表示上下文，一个Context代表一个Web应用，可以配置多个

Wrapper：表示servlet一个实例，可以配置多个


（出自：Packt,.Tomcat.6.Developer’s.Guide.(2009)）

类图

tomcat是有一系列组件组成的，生命周期贯穿每个组件。一个父组件负责启动和停止其子组件。

2. Lifecycle生命周期状态

/**
* The LifecycleEvent type for the "component before init" event.
*/
public static final String BEFORE_INIT_EVENT = "before_init";

/**
* The LifecycleEvent type for the "component after init" event.
*/
public static final String AFTER_INIT_EVENT = "after_init";

/**
* The LifecycleEvent type for the "component start" event.
*/
public static final String START_EVENT = "start";

/**
* The LifecycleEvent type for the "component before start" event.
*/
public static final String BEFORE_START_EVENT = "before_start";

/**
* The LifecycleEvent type for the "component after start" event.
*/
public static final String AFTER_START_EVENT = "after_start";

/**
* The LifecycleEvent type for the "component stop" event.
*/
public static final String STOP_EVENT = "stop";

/**
* The LifecycleEvent type for the "component before stop" event.
*/
public static final String BEFORE_STOP_EVENT = "before_stop";

/**
* The LifecycleEvent type for the "component after stop" event.
*/
public static final String AFTER_STOP_EVENT = "after_stop";

/**
* The LifecycleEvent type for the "component after destroy" event.
*/
public static final String AFTER_DESTROY_EVENT = "after_destroy";

/**
* The LifecycleEvent type for the "component before destroy" event.
*/
public static final String BEFORE_DESTROY_EVENT = "before_destroy";

/**
* The LifecycleEvent type for the "periodic" event.
*/
public static final String PERIODIC_EVENT = "periodic";

/**
* The LifecycleEvent type for the "configure_start" event. Used by those
* components that use a separate component to perform configuration and
* need to signal when configuration should be performed - usually after
* {@link #BEFORE_START_EVENT} and before {@link #START_EVENT}.
*/
public static final String CONFIGURE_START_EVENT = "configure_start";

/**
* The LifecycleEvent type for the "configure_stop" event. Used by those
* components that use a separate component to perform configuration and
* need to signal when de-configuration should be performed - usually after
* {@link #STOP_EVENT} and before {@link #AFTER_STOP_EVENT}.
*/
public static final String CONFIGURE_STOP_EVENT = "configure_stop";

3. LifecycleEvent类

LifecycleEvent表示一个生命周期，由生命周期状态、事件类型、事件数据组成

// ----------------------------------------------------------- Constructors

/**
* Construct a new LifecycleEvent with the specified parameters.
*
* @param lifecycle Component on which this event occurred
* @param type Event type (required)
* @param data Event data (if any)
*/
public LifecycleEvent(Lifecycle lifecycle, String type, Object data) {

super(lifecycle);
this.type = type;
this.data = data;
}

// ----------------------------------------------------- Instance Variables

/**
* The event data associated with this event.
*/
private final Object data;

/**
* The event type this instance represents.
*/
private final String type;

3、生命周期监听器

LifecycleListener表示生命周期监听器，用于监听感兴趣的生命周期事件。

/**
* Acknowledge the occurrence of the specified event.
*
* @param event LifecycleEvent that has occurred
*/
public void lifecycleEvent(LifecycleEvent event);

4. 生命周期轮转图

5. 源码剖析

第一步：初始化调用LifecycleBase类的init()方法。首先初始化父组件（StandardServer）的生命周期

代码清单：

@Override
public final synchronized void init() throws LifecycleException {
if (!state.equals(LifecycleState.NEW)) {
invalidTransition(Lifecycle.BEFORE_INIT_EVENT);
}

try {
setStateInternal(LifecycleState.INITIALIZING, null, false);
initInternal();
setStateInternal(LifecycleState.INITIALIZED, null, false);
} catch (Throwable t) {
ExceptionUtils.handleThrowable(t);
setStateInternal(LifecycleState.FAILED, null, false);
throw new LifecycleException(
sm.getString("lifecycleBase.initFail",toString()), t);
}
}

动态调用图



第二步：调用LifecycleBase类的setStateInternal()方法。

代码清单：

private synchronized void setStateInternal(LifecycleState state,
Object data, boolean check) throws LifecycleException {

if (log.isDebugEnabled()) {
log.debug(sm.getString("lifecycleBase.setState", this, state));
}

if (check) {
// Must have been triggered by one of the abstract methods (assume
// code in this class is correct)
// null is never a valid state
if (state == null) {
invalidTransition("null");
// Unreachable code - here to stop eclipse complaining about
// a possible NPE further down the method
return;
}

// Any method can transition to failed
// startInternal() permits STARTING_PREP to STARTING
// stopInternal() permits STOPPING_PREP to STOPPING and FAILED to
// STOPPING
if (!(state == LifecycleState.FAILED ||
(this.state == LifecycleState.STARTING_PREP &&
state == LifecycleState.STARTING) ||
(this.state == LifecycleState.STOPPING_PREP &&
state == LifecycleState.STOPPING) ||
(this.state == LifecycleState.FAILED &&
state == LifecycleState.STOPPING))) {
// No other transition permitted
invalidTransition(state.name());
}
}

this.state = state;
String lifecycleEvent = state.getLifecycleEvent();
if (lifecycleEvent != null) {
fireLifecycleEvent(lifecycleEvent, data);
}
}

主用有两个作用

1、更新StandardServer组件生命周期状态为INITIALIZING；（this.state = state;）

2、触发对before_init生命周期感兴趣的生命周期监听器（fireLifecycleEvent(lifecycleEvent, data);）

第三步：调用StandardServer类的initInternal()方法（具体容器）

代码清单：

/**
* Invoke a pre-startup initialization. This is used to allow connectors
* to bind to restricted ports under Unix operating environments.
*/
@Override
protected void initInternal() throws LifecycleException {

super.initInternal();

// Register global String cache
// Note although the cache is global, if there are multiple Servers
// present in the JVM (may happen when embedding) then the same cache
// will be registered under multiple names
onameStringCache = register(new StringCache(), "type=StringCache");

// Register the MBeanFactory
MBeanFactory factory = new MBeanFactory();
factory.setContainer(this);
onameMBeanFactory = register(factory, "type=MBeanFactory");

// Register the naming resources
globalNamingResources.init();

// Populate the extension validator with JARs from common and shared
// class loaders
if (getCatalina() != null) {
ClassLoader cl = getCatalina().getParentClassLoader();
// Walk the class loader hierarchy. Stop at the system class loader.
// This will add the shared (if present) and common class loaders
while (cl != null && cl != ClassLoader.getSystemClassLoader()) {
if (cl instanceof URLClassLoader) {
URL[] urls = ((URLClassLoader) cl).getURLs();
for (URL url : urls) {
if (url.getProtocol().equals("file")) {
try {
File f = new File (url.toURI());
if (f.isFile() &&
f.getName().endsWith(".jar")) {
ExtensionValidator.addSystemResource(f);
}
} catch (URISyntaxException e) {
// Ignore
} catch (IOException e) {
// Ignore
}
}
}
}
cl = cl.getParent();
}
}
// Initialize our defined Services
for (int i = 0; i < services.length; i++) {
services[i].init();
}
}

主要有三个作用

1、StandardServer组件注册在jmx，便于监控管理（不是很准确）

2、 if (getCatalina() != null) {}以内的代码没有研究

3、启动StandardServer子组件StandardService[Catalina]，调用LifecycleBase类的init()方法。(以此遍历所有容器）

注意：1、一个父组件可以包含多个子组件

2、父组件负责启动和停止子组件

容器初始化时序图（出自：http://www.cnblogs.com/jiaan-geng/p/4864501.html）