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**:对应于域名,管理多个...