How Tomcat Works（九）

本文接下来描述servlet容器是怎样管理其相关组件的生命周期的，首先本人描述一下事件监听模式，也可以称为观察者模式，该模式分为以下角色

即抽象主题角色 具体主题角色 抽象观察者角色及具体观察者角色，通常在主题角色里面维持一个观察者角色的聚集，并定义了对观察者角色的添加和删除方法；在主题角色事件发生时，通过迭代向这些观察者角色发布事件。

在tomcat容器中，管理其相关组件的生命周期即是基于事件监听模式实现的，相关接口和类为org.apache.catalina.Lifecycle接口、org.apache.catalina.LifecycleListener接口、org.apache.catalina.LifecycleEvent类

org.apache.catalina.Lifecycle接口定义如下

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;

}

上面的六个静态字符串代表六种类型的事件，接着的三个方法addLifecycleListener()、 findLifecycleListeners()、removeLifecycleListener()为与事件监听器相关的，最后的两个方法start()和stop()为启动与关闭操作，组件必须提供这两种方法的实现，供其父组件调用。

org.apache.catalina.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);
    }
}

org.apache.catalina.LifecycleListener为监听器接口

public interface LifecycleListener {


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


}

通常实现了Lifecycle接口并且对某个事件注册了监听器的组件必须提供 Lifecycle接口中三个与监听器相关方法（分别为addLifecycleListener()、 findLifecycleListeners()、removeLifecycleListener()）的实现，然后该组件需要将所有注册的监听器存储到数组、ArrayList或者其他类似的对象中；tomcat容器提供了一个工具类org.apache.catalina.util.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;
        }
    }
}

下面我们来看Context容器（SimpleContext实例）是怎么实现生命周期管理及触发监听器事件的，关键代码如下

public class SimpleContext implements Context, Pipeline, Lifecycle {

protected LifecycleSupport lifecycle = new LifecycleSupport(this);

// implementation of the Lifecycle interface's methods
  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 {
    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);
  }

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

Context容器实例持有对LifecycleSupport lifecycle = new LifecycleSupport(this)的引用，与事件监听器相关方法均为操作该实例的相应方法

在其与生命周期相关方法start()和stop()方法里面，分别调用相关组件的生命周期方法，并采用LifecycleSupport lifecycle引用发布事件

一个简单的监听器实现如下：

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("Stopping context.");
    }
  }
}

子容器wrapper实例（SimpleWrapper），同样实现了Lifecycle接口，其相关实现与Context容器类似

public class SimpleWrapper implements Wrapper, Pipeline, Lifecycle {

protected LifecycleSupport lifecycle = new LifecycleSupport(this);

// implementation of the Lifecycle interface's methods
  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);
  }
}

其他相关组件的相关实现不再赘述

--------------------------------------------------------------------------- 

本系列How Tomcat Works系本人原创 

转载请注明出处 博客园 刺猬的温驯 

本人邮箱： chenying998179#163.com （#改为@）

本文链接http://www.cnblogs.com/chenying99/p/3235736.html