1 概述
Catalina包括很多组件，当catalina启动的时候，也需要启动这些组件，当关闭catalina的时候同时也需要关闭这些组件。Tomcat通过事件机制来实现这种控制，所有的组件都实现org.apache.catalina.Lifecycle接口。
例如，当container关闭时，它必须调用已经载入的servlet的destroy方法。tomcat中的实现机制是通过实现org.apache.catalina.Lifecycle接口来管理。
实现了org.apache.catalina.Lifecycle接口的组件会触发下面的事件：
BEFORE_START_EVENT；
START_EVENT；
AFTER_START_EVENT；
BEFORE_STOP_EVENT；
STOP_EVENT；
AFTER_STOP_EVENT。
当组件启动是会触发前三个事件（BEFORE_START_EVENT，START_EVENT，AFTER_START_EVENT），关闭组件时会触发后三个事件（BEFORE_STOP_EVENT，STOP_EVENT，AFTER_STOP_EVENT）。而相应的监听器由org.apache.catalina.LifecycleListener接口表示。
本章将讨论三种类型，Lifecycle接口、LifecycleListener接口、LifecycleEvent类、LifecycleSupport类。
2 Lifecycle接口
catalina在设计上允许一个组件包含其他组件，如container中可以包含loader，manger等组件。
父组件负责启动/关闭其包含的子组件。所有的组件都可以通过其父组件来启动/关闭，这种单一启动/关闭机制是通过Lifecycle接口实现的。Lifecycle接口定义如下：
package org.apache.catalina;
public interface Lifecycle {
public static final String INIT_EVENT = "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 DESTROY_EVENT = "destroy";
public void addLifecycleListener(LifecycleListener listener);
public LifecycleListener[] findLifecycleListeners();
public void removeLifecycleListener(LifecycleListener listener);
public void start() throws LifecycleException;
public void stop() throws LifecycleException;
}
其中，最重要的方法时start和stop方法。父组件通过这两个方法来启动/关闭该组件。addLifecycleListener，findLifecycleListeners，removeLifecycleListener三个方法用于向组件注册/查找/删除监听器。当事件发生时，会触发监听器。接口中还定义了相关事件。
3. LifecycleListener接口
接口定义如下：
//当监听的事件发生时，触发LifecycleListener接口的lifecycleEvent方法
package org.apache.catalina;
public interface LifecycleListener {
//具体实现放在各组件对应的LifecycleListener中
public void lifecycleEvent(LifecycleEvent event);
}
其中，当监听的事件发生时，触发lifecycleEvent方法。
4. LifecycleEvent类
org.apache.catalina.LifecycleEvent类表示生命周期中的某个事件。定义如下：
//LifecycleEvent类表示生命周期中的某个事件
package org.apache.catalina;
public final class LifecycleEvent {
//type即为各状态init、start。。。
public LifecycleEvent(Lifecycle lifecycle, String type) {
this(lifecycle, type, null);
}
public LifecycleEvent(Lifecycle lifecycle, String type, Object data) {
super(lifecycle);
this.lifecycle = lifecycle;
this.type = type;
this.data = data;
}
private Object data = null;
private Lifecycle lifecycle = null;
private String type = null;
public Object getData() {
return (this.data);
}
public Lifecycle getLifecycle() {
return (this.lifecycle);
}
public String getType() {
return (this.type);
}
}
5 LifecycleSupport类
实现了Lifecycle接口的组件可以向监听器注册感兴趣的事件，catalina提供一个工具类来管理对组件注册的监听器，org.apache.catalina.util.LifecycleSupport。代码如下：
LifecycleSupport类中用数组类型的变量listeners存储了所有监听器。当添加一个新的监听器时，是创建一个新数组，存储全部的监听器。删除一个监听器的时候，也是返回一个新的数组对象。
fireLifecycleEvent方法会触发已经注册的各个监听器。
实现了Lifecycle接口的组件可以使用LifecycleSupport类，对监听器进行添加、删除、触发等操作。
//catalina提供一个工具类来管理对组件注册的监听器LifecycleSupport，实现了Lifecycle接口的组件可以向监听器注册感兴趣的事件，
/**
* LifecycleSupport类中用数组类型的变量listeners存储了所有监听器。
* 当添加一个新的监听器时，是创建一个新数组，存储全部的监听器。删除一个监听器的时候，也是返回一个新的数组对象。
* fireLifecycleEvent方法会触发已经注册的各个监听器。
*/
package org.apache.catalina.util;
import org.apache.catalina.Lifecycle;
import org.apache.catalina.LifecycleEvent;
import org.apache.catalina.LifecycleListener;
/* catalina提供一个工具类来管理对组件注册的监听器LifecycleSupport，实现了Lifecycle接口的组件可以向监听器注册感兴趣的事件
* 各步骤类使用LifecycleSupport 处理，如StandardServer类:
* 构造函数调用addLifecycleListener添加listener，
* 初始化时调用fireLifecycleEvent ，如lifecycle.fireLifecycleEvent(INIT_EVENT, null);其他操作类似
*
* private LifecycleSupport lifecycle = new LifecycleSupport(this);
*/
/*fireLifecycleEvent(String type, Object data) 中初始化LifecycleEvent，同时触发
* 各监听器LifecycleListener 调用interested[i].lifecycleEvent(event);
* type为 类型init/before_start/start/after_start/stop等
*
* lifecycle 参数为上方LifecycleSupport中对象this
* LifecycleEvent event = new LifecycleEvent(lifecycle, type, data);
*/
public final class LifecycleSupport {
public LifecycleSupport(Lifecycle lifecycle) {
super();
this.lifecycle = lifecycle;
}
private Lifecycle lifecycle = null;
private LifecycleListener listeners[] = new LifecycleListener[0];
private final Object listenersLock = new Object(); // Lock object for changes to listeners
private String state = "NEW";
public void addLifecycleListener(LifecycleListener listener) {
synchronized (listenersLock) {
LifecycleListener results[] =
new LifecycleListener[listeners.length + 1];
for (int i = 0; i < listeners.length; i++)
results[i] = listeners[i];
results[listeners.length] = listener;
listeners = results;
}
}
public LifecycleListener[] findLifecycleListeners() {
return listeners;
}
public void fireLifecycleEvent(String type, Object data) {
if (Lifecycle.INIT_EVENT.equals(type)) {
state = "INITIALIZED";
} else if (Lifecycle.BEFORE_START_EVENT.equals(type)) {
state = "STARTING_PREP";
} else if (Lifecycle.START_EVENT.equals(type)) {
state = "STARTING";
} else if (Lifecycle.AFTER_START_EVENT.equals(type)) {
state = "STARTED";
} else if (Lifecycle.BEFORE_STOP_EVENT.equals(type)) {
state = "STOPPING_PREP";
} else if (Lifecycle.STOP_EVENT.equals(type)) {
state = "STOPPING";
} else if (Lifecycle.AFTER_STOP_EVENT.equals(type)) {
state = "STOPPED";
} else if (Lifecycle.DESTROY_EVENT.equals(type)) {
state = "DESTROYED";
}
//通过type判断哪个状态
LifecycleEvent event = new LifecycleEvent(lifecycle, type, data);
LifecycleListener interested[] = listeners;
for (int i = 0; i < interested.length; i++)
interested[i].lifecycleEvent(event);
}
public void removeLifecycleListener(LifecycleListener listener) {
synchronized (listenersLock) {
int n = -1;
for (int i = 0; i < listeners.length; i++) {
if (listeners[i] == listener) {
n = i;
break;
}
}
if (n < 0)
return;
LifecycleListener results[] =
new LifecycleListener[listeners.length - 1];
int j = 0;
for (int i = 0; i < listeners.length; i++) {
if (i != n)
results[j++] = listeners[i];
}
listeners = results;
}
}
public String getState() {
return state;
}
}
public class MyLifecycle1Listener implements LifecycleListener {
@Override
public void lifecycleEvent(LifecycleEvent event) {
MyLifecycle1 myLifecycle1 = (MyLifecycle1) event.getLifecycle();
// System.out.println(myLifecycle1);
if (event.getType().equals(Lifecycle.BEFORE_INIT_EVENT)) {
beforeInit();
} else if (event.getType().equals(Lifecycle.AFTER_INIT_EVENT)) {
} else if (event.getType().equals(Lifecycle.BEFORE_START_EVENT)) {
} else if (event.getType().equals(Lifecycle.START_EVENT)) {
} else if (event.getType().equals(Lifecycle.AFTER_START_EVENT)) {
} else if (event.getType().equals(Lifecycle.BEFORE_STOP_EVENT)) {
} else if (event.getType().equals(Lifecycle.STOP_EVENT)) {
} else if (event.getType().equals(Lifecycle.AFTER_STOP_EVENT)) {
} else if (event.getType().equals(Lifecycle.BEFORE_DESTROY_EVENT)) {
} else if (event.getType().equals(Lifecycle.AFTER_DESTROY_EVENT)) {
}
System.out.println("trigger event : " + event.getType());
}
protected synchronized void beforeInit() {
}
}
具体组件使用：
Catalina包括很多组件，当catalina启动的时候，也需要启动这些组件，当关闭catalina的时候同时也需要关闭这些组件。Tomcat通过事件机制来实现这种控制，所有的组件都实现org.apache.catalina.Lifecycle接口。
//注意组件实现了Lifecycle接口
public final class StandardServer
implements Lifecycle {
//catalina提供一个工具类来管理对组件注册的监听器LifecycleSupport，实现了Lifecycle接口的组件可以向监听器注册感兴趣的事件，
private LifecycleSupport lifecycle = new LifecycleSupport(this);
private NamingContextListener namingContextListener = null;
private Service services[] = new Service[0];
/**
* 构造方法中添加对应的监听器LifecycleListener
*/
public StandardServer() {
super();
ServerFactory.setServer(this);
globalNamingResources = new NamingResources();
globalNamingResources.setContainer(this);
if (isUseNaming()) {
if (namingContextListener == null) {
namingContextListener = new NamingContextListener();
addLifecycleListener(namingContextListener);
}
}
}
//LifecycleSupport工具类添加对应的监听器LifecycleListener
/**
* LifecycleSupport将该StandardServer对应的监听器NamingContextListener放入其内的LifecycleListener listeners[]数组中
*
* public void addLifecycleListener(LifecycleListener listener) {
*
* synchronized (listenersLock) {
* LifecycleListener results[] =
* new LifecycleListener[listeners.length + 1];
* for (int i = 0; i < listeners.length; i++)
* results[i] = listeners[i];
* results[listeners.length] = listener;
* listeners = results;
* }
*
* }
*/
public void addLifecycleListener(LifecycleListener listener) {
lifecycle.addLifecycleListener(listener);
}
//组件初始化
public void initialize() {
if (initialized) {
log.info(sm.getString("standardServer.initialize.initialized"));
return;
}
lifecycle.fireLifecycleEvent(INIT_EVENT, null);
initialized = true;
......
// Initialize our defined Services
for (int i = 0; i < services.length; i++) {
services[i].initialize();
}
}
//组件启动
public void start() throws LifecycleException {
if (started) {
log.debug(sm.getString("standardServer.start.started"));
return;
}
// Notify our interested LifecycleListeners
lifecycle.fireLifecycleEvent(BEFORE_START_EVENT, null);
lifecycle.fireLifecycleEvent(START_EVENT, null);
started = true;
// 启动子组件Services
synchronized (services) {
for (int i = 0; i < services.length; i++) {
if (services[i] instanceof Lifecycle)
((Lifecycle) services[i]).start();
}
}
// Notify our interested LifecycleListeners
lifecycle.fireLifecycleEvent(AFTER_START_EVENT, null);
}
//组件关闭
public void stop() throws LifecycleException {
// Validate and update our current component state
if (!started)
return;
// Notify our interested LifecycleListeners
lifecycle.fireLifecycleEvent(BEFORE_STOP_EVENT, null);
lifecycle.fireLifecycleEvent(STOP_EVENT, null);
started = false;
// Stop our defined Services
for (int i = 0; i < services.length; i++) {
if (services[i] instanceof Lifecycle)
((Lifecycle) services[i]).stop();
}
lifecycle.fireLifecycleEvent(AFTER_STOP_EVENT, null);
stopAwait();
}
/**
* 添加子组件
*/
public void addService(Service service) {
service.setServer(this);
synchronized (services) {
Service results[] = new Service[services.length + 1];
System.arraycopy(services, 0, results, 0, services.length);
results[services.length] = service;
services = results;
if (initialized) {
try {
service.initialize();
} catch (LifecycleException e) {
log.error(e);
}
}
if (started && (service instanceof Lifecycle)) {
try {
((Lifecycle) service).start();
} catch (LifecycleException e) {
;
}
}
// Report this property change to interested listeners
support.firePropertyChange("service", null, service);
}
}
。。。
}
public class NamingContextListener
implements LifecycleListener {
public void lifecycleEvent(LifecycleEvent event) {
//具体实现方法
...
if (event.getType() == Lifecycle.START_EVENT) {
} else if (event.getType() == Lifecycle.STOP_EVENT) {
}
}
}
参考：《深入剖析Tomcat 》第6章 生命周期（Lifecycle）
tomcat 7 源码分析-8 生命周期lifecycle和监听listener
Tomcat自定义LifecycleListener，如何监听StandardContext
相关推荐
5. **部署与生命周期管理**： Tomcat提供自动部署和管理Web应用的功能，这涉及到`StandardContext`和`LifeCycle`接口的实现。 6. **安全管理**： Tomcat的安全特性包括用户认证、角色授权等，这在`org.apache....
在描述中提到的InstanceSupport.edx文件可能是一个教学资源，可能包含了关于Tomcat生命周期和事件管理的详细讲解和实例。通常，这种类型的文件可能是教育平台如EdX上的课程资料，用于辅助学习者理解相关概念。 了解...
4. **Lifecycle**：Tomcat的组件遵循生命周期管理，包括初始化、启动、停止和销毁等阶段。 5. **Naming and Directory Interface (JNDI)**：Tomcat使用JNDI提供命名和目录服务，用于查找和绑定资源，如数据源、邮件...
2. Jasper：Jasper负责JSP的编译和执行，将JSP转换为Servlet并管理其生命周期。 3. Coyote：提供了HTTP/1.1协议的支持，处理来自客户端的HTTP请求，并将响应返回给客户端。 4. JMX Remote Lifecycle Listener：这个...
- **LifecycleListeners**：生命周期监听器，可以监听Tomcat的启动、停止等事件。 2. **Tomcat 9.0.38的更新**： 每个新版本通常会包含性能优化、安全修复和新功能。9.0.38版本可能包括对之前版本的bug修复，增强...
组件的生命周期管理 用Lifecycle管理启动、停止、关闭 Lifecycle接口预览 几个核心方法 Server中的init方法示例 为啥StandardServer没有init方法 LifecycleBase中的init与initInternal方法 为什么这么设计...
2. **btm-tomcat55-lifecycle-2.1.4**：这个jar包是专门为Tomcat5.5定制的BTM生命周期模块，它允许BTM与Tomcat的启动和停止过程无缝集成，确保在Tomcat启动时自动配置事务管理器，并在停止时清理资源。 3. **H2 ...
8. **生命周期管理**：Tomcat组件遵循一种称为"生命周期"的概念，使得它们可以在启动、运行和停止时执行特定的步骤。`Lifecycle`接口和`LifecycleListener`接口是这一概念的核心。 9. **线程模型**：Tomcat使用工作...
4. `Lifecycle`和`Container`接口：这两个接口定义了Tomcat组件的生命周期管理和容器结构。所有Tomcat组件都遵循这些接口定义的状态转换和嵌套容器模型。 5. `Server.xml`配置文件：这是Tomcat最重要的配置文件，...
3. **生命周期管理**：Tomcat采用Java的生命周期接口（Lifecycle Interface）来管理其组件，如`LifecycleListener`监听器，确保了组件在启动、停止、初始化和销毁时的正确操作。 4. **服务器配置**：在`conf`目录下...
3. **生命周期管理**：在`catalina`包中，可以看到`Lifecycle`接口和相关的生命周期管理类。每个Tomcat组件都有其特定的生命周期阶段，如初始化、启动、停止和销毁。 4. **容器概念**：Tomcat使用容器的概念来组织...
2. **生命周期管理**：在源码中，可以看到Tomcat如何通过生命周期接口（Lifecycle interface）和生命周期事件（LifecycleEvent）来管理各个组件的启动、停止和暂停等状态。了解这些，有助于我们掌握如何在运行时动态...
5. **生命周期管理**：Tomcat使用Java的生命周期接口（Lifecycle）来管理和控制其组件的状态。每个组件都有若干个状态（如 初始化、运行、暂停、停止、销毁），并且可以注册监听器来响应这些状态变化。 6. **线程...
- 介绍Tomcat组件的生命周期管理机制。 - 如何使用Lifecycle接口来监控和控制组件的状态变化。 通过上述内容的学习，读者将能更深入地理解Tomcat的工作机制以及如何利用其构建高性能的Web应用。
生命周期（Lifecycle）是Tomcat设计中的一个重要概念，它通过`Lifecycle`接口统一管理各个组件的启动、停止和关闭操作。此外，`MBeanRegistration`接口用于实现JMX（Java Management Extensions）功能，使得我们可以...
第6章：生命周期（Lifecycle） 容器和其组件都有各自的生命周期，包括初始化、启动、停止和销毁等阶段。本章将探讨这些阶段的详细过程，以及如何通过接口和事件来控制这些阶段。 第7章：Logger 日志系统在Tomcat中...
- Tomcat使用了Java的生命周期接口（Lifecycle interface）来管理各个组件的状态，如启动、停止、暂停和恢复。 4. **容器概念**： - **Engine**：顶级容器，管理多个Host。 - **Host**：对应于域名，管理多个...