《How Tomcat Works》翻译(4)之 生命周期

第六章 生命周期

一、本章总括

Catalina 由许多组件组成。当Catalina启动后，这些组件同时也需要启动。当Catalina停止，这些组件一定要有机会做一些清楚的工作。比如，当The Container停止后，就必须要底啊用整个加载的Servlet的destory方法以及会话管理一定需要保存到第二存储器的会话对象。启动和关闭组件的一致的原理就是需要实现the org.apache.catalina.Lifecycle接口。

 

实现 the Lifecycle接口的组件也要触发一个或者下面许多事件：BEFORE_STATRT_EVENT,START_EVENT,AFTER_START_EVENT,BEFORE_STOP_EVENT,STOP_EVENT,AFTER_STOP_EVENT.

 当组件开始启动就会触发前面三个事件，当组件关闭时就会触发后面的三个事件。一个事件由the org.apache.catalina,LifecycleEvent类代表。当然如果Catalina组件触发了这些事件，你一定要有一个事件监听器(目的是回应这些事件)。一个Listener有the org.apache.catalina.LifecycleListener接口代表。

 

   这章主要讨论三个类型：Lifecycle,LifecycleEvent,LifecycleListener.除此之外，我们也解释了一个十分有用的类叫做LifecycleSupport（它提供了触发lifecycle事件的一种简易方式并且还处理lifecycle监听）。在这章中，你将要构建一个实现Lifecycle接口类的项目。本章的应用程序是基于第五章应用程序进行扩展。

 

 二、The Lifecycle接口

   Catalina设计者允许一个组件又可以包含其他组件。比如：一个容器能够包含诸如此类的组件：a Loader,a Manager等得。一个父容器负责启动和关闭孩子组件，The catalina设计者把整个组件运用这样的方式，且把组件放到父亲组件中，以至于一个启动类只需要仅仅启动一个单个的组件。因此使用了the Lifecycle接口让一个单一的启动、关闭模式实现成为了可能。现在让我们来看看The Lifecycle接口：

 

package org.apache.catalina;
public interface Lifecycle {
    public static final String START_EVENT = "start";
    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";
    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;


}

 在Lifecycle接口十分重要的方法是the start和stop方法，一个组件提供了实现此接口的所有方法，目的就是该组件的父组件能够关闭和启动该组件。此接口的其他三个方法是addLifecycleListener,findLifecycleListeners,removeLifecycleListener是与listeners相关联的。一个组件能够监听到发生在该组件感兴趣的事件。当一个事件发生就这监听感兴趣的那个事件就被通知。The Lifecycle实例被触发的六个事件的名字以static final String方式定义在Lifecycle接口里面。

 

三、The LifecycleEvent类

  The org.apache.catalina.LifecycleEvent类代表了a lifecycle事件，下面是其呈现的代码：

 

package org.apache.catalina;


import java.util.EventObject;
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);

    }


}

 

 四、The LifecycleListener接口

 The org.apache.catalina.LifecycleListener接口代表了一个lifecycle listener,下面是其呈现的代码：

 

package org.apache.catalina;
public interface LifecycleListener {
    public void lifecycleEvent(LifecycleEvent event);


}

 在这个接口中仅仅只有一个方法lifecycleEvent方法。当触发了感兴趣的监听的事件，这个方法就会被调用。

 

 五、The LifecycleSupport类

 该组件实现了Lifecycle，并且一个监听者注册感兴趣的事件。所以该类也提供了在Lifecycle接口中的三个方法(addLifecycleListener,findLifecycleListeners,removeLifecycleListener).该组件必须把所有的监听者以数组或者ArrayList或者类似对象全部存在里面。Catalina提供了提供了一个十分使用的类，那就是是的组件能够更加容易的处理监听者和触发lifecycle事件，该类的名字叫做org.apache.catalina.util.LifecycleSupport.The LifecycleSupport类看下面的代码：

package org.apache.catalina.util;


import org.apache.catalina.Lifecycle;
import org.apache.catalina.LifecycleEvent;
import org.apache.catalina.LifecycleListener;
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;
        }

    }


}

在上面你能够看到，The LifecyleSupport类用一个数组存储了整个lifecycle监听者，并且该数组初始化为了。

     private LifecycleListener listeners[]=new LifecycleListener[0];

 

 当一个listener被添加到了addLifecycleListener方法中，一个新的数组就会创建并且该数组的长度是以原来数组长度加1的。然后，整个原来数组被复制到新建的数组当中以及新的listener也别添加到新的数组中去。注解：这样写代码就是怎样创建动态数组，非常值得借鉴。

 当一个listener通过removeLifecycleListener方法移除，新的数组也会被创建，并且该数组的长度是原来数组长度减1，然而除了那个要删除的元素，原来数组的元素全部都要复制到新的数组中去。注解：推荐大家看看removeLifecycleListener方法中的代码是怎样删除一个元素的，里面的代码十分的优雅，非常值得我们学习。

 

The fireLifecycleEvent 方法是触发一个lifecycle事件。首先，方法里面克隆所有的监听者并存放在一个数组中。然后又调用数组中每个对象的lifecycleEvent方法（触发的事件当做参数传过去）。

 

 实现Lifecycle组件要使用LifecycleSupport类。比如，在这章的应用程序中的The SimpleContext类，就定义了LifecycleSupport为成员变量：

      protected LifecycleSupport lifecycle=new LifecycleSupport(this);

 如果要添加一个lifecycle listener，那么the SimpleContext类就必须要调用The LifecycleSupport类中的addLifecycleListener方法：

 

     public void addLifecycleListener(LifecycleListener listener){

         lifecycle.addLifecycleListener(listener);

}

 

如果要移除一个lifecycle Listener,那么the SimpleContext类必须调用The LifecycleSupport类中的removeLifecycleListener方法：

 

     public void removeLifecycleListener(LifecycleListener listener){

         lifecycle.removeLifecycleListener(listener);

}

 

 如果要触发一个事件，The SimpleCOntext类必须调用the LifecycleSupport类中的 fireLifecycleEvent方法,下面是其代码：

        lifecycle.fireLifecycleEvent(START_EVENT,null);

 

六、应用程序

本章的应用程序是基于第五章的应用程序，目的是要说明the Lifecycle接口的使用以及lifecycle相关的类型。本应用程序包含了一个context,两个wrappers以及a Loader, a mapper.在本应用程序中实现Lifecycle接口的组件和使用在context中的一个listener.为了使本程序尽量简单，这里就没有使用第五章中的两个valves。下面会呈现本应用程序的类图关系。注意的是：这些接口(Container,Wrapper,Context,Loader,Mapper)和这些类(SimpleContextValve,SimpleContextMapper,SimpleWrapperValve)是没有在下面类中体现出来的。

 注意的是：The SimpleContextLifecycleListener类代表了the SimpleContext类的监听类。The SimpleContextValve,SimpleContextMapper,SimpleWrapperValve类的功能与第五章是一样，这里就不在详细的讨论。

 

六、ex06.pyrmont.core.SimpleContext

 

The SimpleContext类在本应用程序与第五章是十分相似的，除了它实现了The Lifecycle接口。The SimpleContext使用了一个成员变量那就是LifecycleSupport实例。

     protected LifecycleSupport lifecycle=new LifecyleSupport(this);

 

 如果The SimpleContext实例已经启动了，那么The SimpleContext需要一个布尔变量来进行控制是否该类已经启动。下面的代码就是The SimpleContext实现了the Lifecycle接口。

 

 

public void addLifecycleListener(LifecycleListener listener) {
    lifecycle.addLifecycleListener(listener);
  }

  public LifecycleListener[] findLifecycleListeners() {
    return null;
  }

  public void removeLifecycleListener(LifecycleListener listener) {
    lifecycle.removeLifecycleListener(listener);
  }

  public synchronized void start() throws LifecycleException {
    log("starting Context");
    if (started)
      throw new LifecycleException("SimpleContext has already started");

    // Notify our interested LifecycleListeners
    lifecycle.fireLifecycleEvent(BEFORE_START_EVENT, null);
    started = true;
    try {
      // Start our subordinate components, if any
      if ((loader != null) && (loader instanceof Lifecycle))
        ((Lifecycle) loader).start();

      // 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();
      }

      // 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);
    }
    catch (Exception e) {
      e.printStackTrace();
    }

    // Notify our interested LifecycleListeners
    lifecycle.fireLifecycleEvent(AFTER_START_EVENT, null);
    log("Context started");
  }

  public void stop() throws LifecycleException {
    log("stopping Context");
    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);
    log("Context stopped");
  }

 注意the start 方法启动了所有孩子容器与之关联的组件如：The Loader,Pipeline,Mapper, 那么stop方法是怎么停止他们的呢？通过这种机制（开启容器模块中所有的组件），你仅仅需要启动在层次等级上最高那个组件（在本应用程序是The SimpleContext实例）。为了停止他们，你仅仅需要停止一样的单个组件。

 

 在SimpleContext类中的start方法开始是通过核实，如果组件在先前以及启动了，那么就会抛出一个异常LifecycleException.

        if(strated)

                throw new LifecycleException(

                           "SimpleContext has already started");

 

   然后又调用the BEFORE_START_EVENT事件。

 

    lifecycle.fireLifecycleEvent(BEFORE_START_EVENT,null);

 

结果，在SimpleContext实例中注册感兴趣的事件的每个监听者将被通知（也叫调用）。在本应用程序中SimpleContextLifecycleListener是注册感兴趣的事件之一。当我们讨论the SimpleContextLifecycleListener类，我就会看到这个监听者会发生什么样的事情。

 

   接下来，the start 方法设置布尔值started为TRUE，这就表明该组件已经启动了。

       started=true;

the start 方法然后又调用整个组件(该组件的孩子容器)。当前有两个组件（SimpleLoader , SimplePieline）实现了the Lifecycle接口. The SimpkeContext有两个孩子容器即两个Wrappers。这些wrappers中有一个类SimpleWrapper(他也是实现了Lifecycle接口)。

 

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

      // 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();
      }

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

 

 这些组件和孩子都启动后，这个start方法有开始激发两个事件：START_EVENT, AFTER_START_EVENT.

 

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

                  ...

                  ...

                  ...

       lifecycle.fireLifecycleEvent(AFTER_START_EVENT, null);

 

  The stop方法首先核实这个实例是否已经启动，如果没有启动，那么就会抛出一个LifecycleException异常。

 

     if (!started)
      throw new LifecycleException("SimpleContext has not been started");

然后又产生两个事件：BEFORE_STOP_EVENT,STOP_EVENT，并且重新设置布尔值started。

 

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

 接下来，the stop方法停止与容器相关联整个组件以及SimpleContext实例的孩子容器。

 

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();
    }

 最后又触发了AFTER_STOP_EVENT事件

 

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

 

七、ex06.prymont.core.SImpleContextLifecycleListener

   The SimpleContextLifecycleListener类代表了一个SimpleContext实例的监听者，下面的代码：

 

package ex07.pyrmont.core;

import org.apache.catalina.Lifecycle;
import org.apache.catalina.LifecycleEvent;
import org.apache.catalina.LifecycleListener;

public class SimpleContextLifecycleListener implements LifecycleListener {

  public void lifecycleEvent(LifecycleEvent event) {
    Lifecycle lifecycle = event.getLifecycle();
    System.out.println("SimpleContextLifecycleListener's event " +
      event.getType().toString());
    if (Lifecycle.START_EVENT.equals(event.getType())) {
      System.out.println("Starting context.");
    }
    else if (Lifecycle.STOP_EVENT.equals(event.getType())) {
      System.out.println("Starting context.");
    }
  }
}

 The SimpleContextLifecycleListener类实现了LifeEvent方法是十分简单的。该方法里面的功能打印了调用事件的的类型。如果是一个STRT_EVENT事件，那么The lifecycleEvent方法就是打印这个字符串：Starting context. 如果是一个STOP_EVENT事件那么该方法就会打印这样的字符串：Stopping context.

 

 八、ex06.pyrmont.core.SimpleLoader

 

  The SimpleLoader 类与第五章的类非常相似，除了该类在本应用程序实现了The Lifecycle接口。这个类实现了The Lifecycle接口的这些方法没有做任何事情，除了打印了一个字符串在控制台上。然而，更加重要的是通过实现The Lifecycle接口的SimpleLoader实例开始有容器被关联。（这句话翻译的有问题）

 

  public void addLifecycleListener(LifecycleListener listener) {
  }

  public LifecycleListener[] findLifecycleListeners() {
    return null;
  }

  public void removeLifecycleListener(LifecycleListener listener) {
  }

  public synchronized void start() throws LifecycleException {
    System.out.println("Starting SimpleLoader");
  }

  public void stop() throws LifecycleException {
  }

 

 

八、ex06.pyrmont.core.SimplePipeline

 

The SimplePipeline类除了实现了the Pipeline接口同时还实现了The Lifecycle接口。这个类实现该接口的方法都是空实现，但是此类的实例能够被启动并且它是与容器关联的。其他的功能都与第五章的the SimplePipeline类十分类似。

 

八、ex06.pyrmont.core.SimpleWrapper

 

  这个类与第五章的SimpleWrapper类十分类似，在本应用中它也实现了The Lifecycle接口以至于它能够被父类容器启动。在本应用程序中实现Lifecycle接口的大部分方法都是空实现，除了the start和the stop方法不是。下面是其实现此接口的代码：

 

 public void addLifecycleListener(LifecycleListener listener) {
  }

  public LifecycleListener[] findLifecycleListeners() {
    return null;
  }

  public void removeLifecycleListener(LifecycleListener listener) {
  }

  public synchronized void start() throws LifecycleException {
    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);
  }

  public void stop() throws LifecycleException {
    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);
  }

 在SimpleWrapper 中的The start方法与在SimpleContext类的start方法十分类似。该类能够启动添加该类实例任何组件（当前应用程序为了简单就没有任何组件添加在里面），并且触发了the BEFORE_START_EVENT, STRAT_EVENT, AFTER_START_EVENT事件。

 

   在SimpleWrapper中的stop方法甚至更加有趣。打印了一个简单的字符串后，该方法就调用了the servlet实例的destory方法。

 System.out.println("Stopping wrapper " + name);
    // Shut down our servlet instance (if it has been initialized)
    try {
      instance.destroy();
    }
    catch (Throwable t) {
    }

 然后，该方法就核实是否the wrapper是否已经启动了。如果没有启动，那么就会抛出LifecycleException异常。

 

      if (!started)
      throw new LifecycleException("Wrapper " + name + " not started");

 

接下来，该方法就触发了BEFORE_STOP_EVENT和STOP_EVENT事件，并且重新设置了布尔值started.

 

 

   lifecycle.fireLifecycleEvent(BEFORE_STOP_EVENT, null);

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

 在然后，该方法就停止the loader和pipeline组件。在本应用程序中The SimpleWrappe实例是没有loader组件。

             // 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();
    }

 最后，该方法就触发了the AFTER_STOP_EVENT事件

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

 

 九、运行本程序

   这里具体怎么运行就不作太的解释

 

 

 十、总结

 

  在本章你已经学会了The Lifecycle接口是怎么工作。这个接口定义了the lifecycle给组件，且提供了一种优雅的方式发送事件给其他的组件。除此之外，The Lifecycle接口也尽可能的在Catalina里使用单个start/stop方法来启动所有组件的start和stop方法。

注解：本章是一个典型的观察者模式，特别要关注哪个辅助类LifecycleSupport，这个太典型了不得不佩服设计者的这种思维，实现组件之间的连接。。。。无话可说学习啊。。。。

 

评论

1 楼 longxiaoyan 2010-12-08  

看英文版多好。