tomcat(6)生命周期

最新推荐文章于 2023-07-03 22:44:11 发布

原创最新推荐文章于 2023-07-03 22:44:11 发布 · 5.1k 阅读

0 ·

CC 4.0 BY-SA版权

(5)HowTomcatWorks 专栏收录该内容

30 篇文章

订阅专栏

本文详细介绍了Tomcat的生命周期接口（Lifecycle）、事件（LifecycleEvent）、监听器（LifecycleListener）及其支持类（LifecycleSupport）的功能与实现。通过阐述生命周期接口的引入背景、组件事件触发机制、事件监听器的使用，以及相关类的功能，文章提供了从概念到实践的全面指导，帮助开发者掌握Tomcat组件的启动与关闭机制。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

【0】README

0.1）本文部分文字描述转自“深入剖析tomcat”，旨在学习 “tomcat生命周期” 的基础知识；

0.2）for source code, please visit https://github.com/pacosonTang/HowTomcatWorks/tree/master/chapter6

0.3）温馨建议：建议阅读本文之前，已阅读过 tomcat(1~5)的系列文章，因为它们是环环相扣的；

1）生命周期LifeCycle接口引入的背景：Catalina包含很多组件，当Catalina启动或关闭时，这些组件也会启动或关闭。而通过实现 org.apache.catalina.Lifecyle接口，可以达到统一启动或关闭这些组件的目的；

2）实现了Lifecycle接口的组件可以触发一个或多个事件：BEFORE_START_ENVET, START_EVENT, AFTER_START_EVENT, BEFORE_STOP_EVENT, STOP_EVENT, AFTER)STOP_EVENT（共6个事件）;

3)当组件启动时，会触发前3个事件；而当组件关闭时，会触发后3个事件；

4）事件监听器：如果Catalina组件可以触发事件，那么需要编写相应的事件监听器对这些事件进行响应。事件监听器是 org.apache.catalina.LifecycleListener 接口的实例；

5）本文会介绍3个相关类：分别是 Lifecycle, LifecycleEvent, LifecycleListener；还外加一个工具类 LifecycleSupport，该类提供了一个简单的方法来触发某个组件的生命周期事件，并对事件监听器进行处理；

【1】Lifecycle接口（生命周期接口）

1）intro to Lifecycle：Catalina在设计上允许一个组件包含其他组件，以使得所有的组件都置于其父组件的监护之下；这样一来，Catalina的启动类只需要启动一个组件就可以将全部应用的组件都启动起来。这种单一启动/关闭机制是通过 Lifecycle 接口来实现的；（干货——Lifecycle接口的引入目的是：Catalina的启动类只需要启动一个组件就可以将全部应用的组件都启动起来）（干货——单一启动/关闭机制）

public interface Lifecycle {
    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 void addLifecycleListener(LifecycleListener listener); 
    public LifecycleListener[] findLifecycleListeners(); 
    public void removeLifecycleListener(LifecycleListener listener); 
    public void start() throws LifecycleException; 
    public void stop() throws LifecycleException; 
}

【2】LifecycleEvent类（生命周期事件类）

public final class LifecycleEvent  extends EventObject { 
    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);
    }
}

【3】LifecycleListener接口（生命周期事件监听器接口）

1）该接口只有一个方法：即 lifecycleEvent 方法，当某个事件监听器监听到相关事件发生时，会调用该方法；

public interface LifecycleListener {
    public void lifecycleEvent(LifecycleEvent event);
 }

【4】LifecycleSupport类

1）LifecycleSupport类：实现了 Lifecycle接口，并且对某个事件注册了监听器的组件必须提供 Lifecycle接口中3个与监听器相关的方法（分别是 addLifecycleListener(), findLifecycleListeners(), removeLifecycleListener()）的实现。

2）然后，该组件需要将所有注册的事件监听器存储到一个数组，ArrayList 或其他类似的对象中。

3）Catalina提供了一个工具类——org.apache.catalina.util.LifecycleSupport： 来帮助组件管理监听器，并触发相应的生命周期事件；

4）LifecycleSupport类的定义如下：

public final class LifecycleSupport {
    public LifecycleSupport(Lifecycle lifecycle) {
        super();
        this.lifecycle = lifecycle;
    }
    private Lifecycle lifecycle = null;
    private LifecycleListener listeners[] = new LifecycleListener[0];
    public void addLifecycleListener(LifecycleListener listener) { //添加生命周期事件监听器
      synchronized (listeners) {
          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) { // 触发生命周期事件监听器
        LifecycleEvent event = new LifecycleEvent(lifecycle, type, data);
        LifecycleListener interested[] = null;
        synchronized (listeners) {
            interested = (LifecycleListener[]) listeners.clone();
        }
        for (int i = 0; i < interested.length; i++)
            interested[i].lifecycleEvent(event);
    }
    public void removeLifecycleListener(LifecycleListener listener) { // 移除生命周期事件监听器
        synchronized (listeners) {
            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;
        }
    }
}

5）添加和删除事件监听器的方法（干货——添加和删除事件监听器的方法，其处理技巧非常重要，代码如上）

5.1）添加事件监听器：当调用addLifecycleListener()方法添加一个事件监听器时，会创建一个新数组，大小为原数组的元素个数加1；然后将原数组中的所有元素copy到新数组中，并将新的事件监听器添加到新数组中；

5.2）删除事件监听器：当调用 removeLifecycleListener() 方法删除一个事件监听器时，也会新建一个数组，大小为原数组的元素个数减1；然后将除了指定监听器外的其他所有监听器都copy到新数组中；

6）触发生命周期事件（fireLifecycleEvent（）方法）：会触发一个生命周期事件。首先，它会copy 事件监听器数组，然后调用数组中每个成员的lifecycleEvent() 方法，并传入要触发的事件；

public void fireLifecycleEvent(String type, Object data) {
        LifecycleEvent event = new LifecycleEvent(lifecycle, type, data); 
        LifecycleListener interested[] = null;
        synchronized (listeners) {
            interested = (LifecycleListener[]) listeners.clone(); // step1
        }
        for (int i = 0; i < interested.length; i++)
            interested[i].lifecycleEvent(event); // step2
    }

7）当要添加一个事件监听器时，SimpleContext实例会调用LifecycleSupport类的 addLifecycleListener() 方法：

 // implementation of the Lifecycle interface's methods
  public void addLifecycleListener(LifecycleListener listener) {
    lifecycle.addLifecycleListener(listener);
  }

【5】应用程序

【5.1】 SimpleContext类

1）SimpleContext类使用变量lifecycle 引用了一个 LifecycleSupport 实例：

2）SimpleContext的start方法和stop方法

public synchronized void start() throws LifecycleException { // SimpleContext.start()
    if (started)
      throw new LifecycleException("SimpleContext has already started");

    // Notify our interested LifecycleListeners
    lifecycle.fireLifecycleEvent(BEFORE_START_EVENT, null);
    started = true;
    try {
     // 启动它的组件和子容器，当前程序中，共有两个组件实现了Lifecycle接口，分别是
     // SimpleLoader类和 SimplePipeline类.
      // Start our subordinate components, if any
      if ((loader != null) && (loader instanceof Lifecycle))
        ((Lifecycle) loader).start(); // highlight line.

      // Start our child containers, if any
      Container children[] = findChildren();
      for (int i = 0; i < children.length; i++) {
        if (children[i] instanceof Lifecycle)
          ((Lifecycle) children[i]).start(); // highlight line.
      }

      // Start the Valves in our pipeline (including the basic),
      // if any
      if (pipeline instanceof Lifecycle)
        ((Lifecycle) pipeline).start(); // highlight line.
      // Notify our interested LifecycleListeners
      // 组件和子容器都启动完毕后，会触发两个事件：START_EVENT AND AFTER_START_EVENT.
      lifecycle.fireLifecycleEvent(START_EVENT, null);
    }
    catch (Exception e) {
      e.printStackTrace();
    }

    // Notify our interested LifecycleListeners
    lifecycle.fireLifecycleEvent(AFTER_START_EVENT, null);
  }

  // stop方法 类似于上述的 start方法.
  public void stop() throws LifecycleException { // SimpleContext.stop() 方法
    if (!started)
      throw new LifecycleException("SimpleContext has not been started");
    // Notify our interested LifecycleListeners
    lifecycle.fireLifecycleEvent(BEFORE_STOP_EVENT, null);
    lifecycle.fireLifecycleEvent(STOP_EVENT, null);
    started = false;
    try {
      // Stop the Valves in our pipeline (including the basic), if any
      if (pipeline instanceof Lifecycle) {
        ((Lifecycle) pipeline).stop();
      }

      // Stop our child containers, if any
      Container children[] = findChildren();
      for (int i = 0; i < children.length; i++) {
        if (children[i] instanceof Lifecycle)
          ((Lifecycle) children[i]).stop();
      }
      if ((loader != null) && (loader instanceof Lifecycle)) {
        ((Lifecycle) loader).stop();
      }
    }
    catch (Exception e) {
      e.printStackTrace();
    }
    // Notify our interested LifecycleListeners
    lifecycle.fireLifecycleEvent(AFTER_STOP_EVENT, null);
  }

3）problem+solution：

3.1）problem：

problem1）start() 方法是如何将所有子容器，以及与之相关的组件，包括载入器，管道和映射器等，启动起来的？

problem2）又是如何关闭这些容器和组件的？

3.2）solution：就是使用前面提到的 单一启动/关闭机制；使用这种机制，只需要启动最高层级的组件即可，其余组件会由各自的父组件去启动。同样，关闭这些组件时，也只需要关闭最高层级的组件即可； （干货—— 单一启动/关闭机制 ）

4）start（）方法的调用过程

step1）首先检查组件是否已经启动

step2）触发BEFORE_START_EVENT事件

step3）将started 设置为true，表明该组件已经启动了

step4）启动start方法所在类的组件和子容器。当前应用程序中，共有两个组件实现了Lifecycle接口，分别是 SimpleLoader and SimplePipeline类。

step5）触发两个事件：START_EVENT and AFTER_START_EVENT;

step6）触发 BEFORE_STOP_EVENT事件和 STOP_EVENT事件，重置started

5）stop() 方法调用过程（与start方法类似）

step1）关闭与它关联的所有组件和 SimpleContext 实例的子容器；

step2）触发 AFTER_STOP_EVENT 事件

【5.2】 SimpleContextLifecycleListener类（事件监听器的实现类）

1）其中的 lifecycleEvent() 方法：它仅仅输出已触发事件类型；

【5.3】SimpleLoader类（仅仅是返回类加载器，与以往的Loader不同的是，它实现了 Lifecycle接口）

1）该类的Lifecycle接口中各个方法的实现只是向console输出字符串。重要的是，通过实现Lifecycle接口，启动SimpleLoader实例的任务就可以由与其相关联的servlet容器来完成了；

【5.4】SimplePipeline类（管道，管道包括多个阀，每个阀就是一个任务，遍历管道中的阀，就是挨个执行任务，基础阀最后执行）

【5.5】SimpleWrapper类（利用SimpleLoader返回的类加载器，加载并返回相应的servlet）

1）该类实现了 Lifecycle接口，就可以由其父容器来启动该实例。

2）参见其start方法（与SimpleContext类的start方法类似）：

public synchronized void start() throws LifecycleException {  // SimpleWrapper.start()
    System.out.println("Starting Wrapper " + name);
    if (started)
      throw new LifecycleException("Wrapper already started");

    // Notify our interested LifecycleListeners
    lifecycle.fireLifecycleEvent(BEFORE_START_EVENT, null);
    started = true;

    // Start our subordinate components, if any
    if ((loader != null) && (loader instanceof Lifecycle))
      ((Lifecycle) loader).start();

    // Start the Valves in our pipeline (including the basic), if any
    if (pipeline instanceof Lifecycle)
      ((Lifecycle) pipeline).start();

    // Notify our interested LifecycleListeners
    lifecycle.fireLifecycleEvent(START_EVENT, null);
    // Notify our interested LifecycleListeners
    lifecycle.fireLifecycleEvent(AFTER_START_EVENT, null);
  }

3）参见其stop方法（比较有趣）

3.1）stop方法的调用steps as follows：

step 1）除了输出一个简单的字符串外，它还要调用servlet实例的destroy方法

step2）检查Wrapper实例是否启动

step3）触发BEFORE_STOP_EVENT 和 STOP_EVENT事件，并重置started

step4）关闭与其相关联的载入器和管道组件

step5）最后，触发 AFTER_STOP_EVENT事件

  public void stop() throws LifecycleException { // SimpleWrapper.stop() 方法
    System.out.println("Stopping wrapper " + name);
    // Shut down our servlet instance (if it has been initialized)
    try {
      instance.destroy();
    }
    catch (Throwable t) {
    }
    instance = null;
    if (!started)
      throw new LifecycleException("Wrapper " + name + " not started");
    // Notify our interested LifecycleListeners
    lifecycle.fireLifecycleEvent(BEFORE_STOP_EVENT, null);

    // Notify our interested LifecycleListeners
    lifecycle.fireLifecycleEvent(STOP_EVENT, null);
    started = false;

    // Stop the Valves in our pipeline (including the basic), if any
    if (pipeline instanceof Lifecycle) {
      ((Lifecycle) pipeline).stop();
    }

    // Stop our subordinate components, if any
    if ((loader != null) && (loader instanceof Lifecycle)) {
      ((Lifecycle) loader).stop();
    }

    // Notify our interested LifecycleListeners
    lifecycle.fireLifecycleEvent(AFTER_STOP_EVENT, null);
  }

【6】运行应用程序

0）app startup

public final class Bootstrap {
  public static void main(String[] args) {
	// 连接器,创建服务器套接字，维护HttpProcessor 对象池（stack）
    Connector connector = new HttpConnector(); 
    // servlet最低级容器 Wrapper，用于封装servlet，并提供类加载器，加载相应的servlet
    Wrapper wrapper1 = new SimpleWrapper();
    wrapper1.setName("Primitive");
    wrapper1.setServletClass("servlet.PrimitiveServlet");
    Wrapper wrapper2 = new SimpleWrapper();
    wrapper2.setName("Modern");
    wrapper2.setServletClass("servlet.ModernServlet");

    // 将Wrapper容器添加到其父容器Context
    Context context = new SimpleContext(); 
    context.addChild(wrapper1);
    context.addChild(wrapper2);

    // 映射器Mapper，其作用是通过 请求路径，如 http://localhost:8080/Modern;
    // 通过HttpProcessor.process() 方法解析reqeust，获取 访问绝对路径 /Modern
    // 通过在映射器（的map方法）查找该路径对应的容器资源名称(Modern)
    // 然后还是在其map方法中继续通过容器名称(Modern)映射到servlet名称（servlet.ModernServlet）
    // 这样才通过 /Modern 映射到对应的servlet访问路径(加载路径，以便类加载器加载)
    Mapper mapper = new SimpleContextMapper();
    mapper.setProtocol("http");
    
    // 添加生命周期监听器
    LifecycleListener listener = new SimpleContextLifecycleListener();
    ((Lifecycle) context).addLifecycleListener(listener);
    context.addMapper(mapper);
    
    // 添加类加载器
    Loader loader = new SimpleLoader();
    context.setLoader(loader);
    
    // 添加servlet访问路径（资源路径） 和 资源名称的映射关系
    // context.addServletMapping(pattern, name);
    context.addServletMapping("/Primitive", "Primitive");
    context.addServletMapping("/Modern", "Modern");
    connector.setContainer(context);
    try {
      connector.initialize(); // 初始化，主要返回服务器套接字
      // 触发生命周期事件（可以参考下面的测试用例调用过程示例图）
      ((Lifecycle) connector).start(); // highlight line.
      ((Lifecycle) context).start(); // highlight line.

      // make the application wait until we press a key.
      System.in.read();
      ((Lifecycle) context).stop(); // highlight line.
    }
    catch (Exception e) {
      e.printStackTrace();
    }
   /* try { // these are some code in tomcat(5)-servlet container.
        connector.initialize();
        connector.start();

        // make the application wait until we press a key.
        System.in.read();
      }*/
  }
}

Attention）习惯上，我还是总结了测试用例（生命周期，事件+监听器）的调用过程示例图

对以上调用过程的分析（SimpleContext.start() 方法为起点的 Analysis）

A1）容器：本应用程序（Bootstrap.java）有两种容器Wrapper 和 Context，实现类分别是 SimpleWrapper 和 SimpleContext；每种容器分别有管道类（SimplePipeline），而管道类通过阀数组类封装非基础阀，和一个阀的实例来封装基础阀（基础阀是可以手动设置的）；即两种容器Wrapper 和 Context 的管道是不同的，非基础阀是不同的，当然基础阀也是不同的；（干货——理解到容器的概念非常重要，之后就是管道中的阀，非基础阀和基础阀，还有管道中阀的遍历，最后遍历基础阀，这些都是晒干了很久的干货）；

A2）SimpleContext.start()方法（第一张图）：通过生命周期实例（lifycycle，这在main方法中已经设定了）调用fireLifecycleEvent()方法去触发一个生命周期事件，这里触发的是START_EVENT事件：

step1）fireLifecycleEvent方法：创建生命周期事件，得到监听器数组的拷贝（多个监听器封装在数组里面），依据监听器数组里面监听器list，挨个排的调用单个监听器的lifecycleEvent()

step2）单个监听器实例： 是由SimpleContextLifecycleListener实例提供的，SimpleContextLifecycleListener.lifecycleEvent() 方法就打印一些对应于事件的info；

step3）调用fireLifecycleEvent方法后，继续调用findChildren()方法：首先要知道children 是一个封装Wrapper类型的HashMap集合，在main方法中就已经填充了children（键和值（键值对）分别是 Wrapper实例的名称和 Wrapper实例，而Wrapper负责加载servlet，并返回servlet）；第二，findChildren会返回children对应的Wrapper数组；第三，在for循环中，遍历该数组，并调用单个Wrapper实例的start方法，转向SimpleWrapper.start()方法；

step4）SimpleWrapper.start()方法： 该方法和SimpleContext.start()方法有点类似，这里就省略了，因为SimpleWrapper 和 SimpleContext都是容器，都实现了 Lifecycle 接口，所以它们的start方法类似，调用过程也是类似的，参见A2中对 SimpleContext.start()方法的描述； （下图所示）

1）运行参数

E:\bench-cluster\cloud-data-preprocess\HowTomcatWorks\src>java -cp .;lib/servlet.jar;lib/catalina_4_1_24.jar;E:\bench-cluster\cloud-data-preprocess\HowTomcatWorks\webroot com.tomcat.chapter6.startup.B ootstrap 
HttpConnector Opening server socket on all host IP addresses
HttpConnector[8080] Starting background thread
SimpleContextLifecycleListener's event before_start
Starting SimpleLoader
Starting Wrapper Primitive
Starting Wrapper Modern
SimpleContextLifecycleListener's event start
Starting context.
SimpleContextLifecycleListener's event after_start
ModernServlet -- init
init
from service
SimpleContextLifecycleListener's event before_stop
SimpleContextLifecycleListener's event stop
Stopping context.
Stopping wrapper Primitive
destroy

2）运行结果