《How Tomcat Works》读书笔记（六）Lifecycle

Tomcat有很多组件，在Tomcat启动的同时，这些组件也应该跟着启动，在Tomcat要停止之前，这些组件需要有机会完成自己的收尾工作.

之前提过servlet的生命周期,从上一节我们知道一个Wrapper代表一个Servlet,一个Context可以有很多个Wrapper.当一个Context要停止，它会调用它的Wrapper的stop方法，Wrapper会调用servlet的destory方法.

一个组件只需实现org.apache.catalina.Lifecycle就可以管理自己的生命周期了。

看一下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;
}

start和 stop算是最重要的两个方法了， 父组件在start/stop时会调用它的子组件的start/stop方法，完成启动/停止。

Lifecycle里只有生命周期事件的名称，来看下它的实现： 

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

再看下监听器接口LifecycleListener :

public interface LifecycleListener {
    //当监听器感兴趣的事情发生时 调用该方法
    public void lifecycleEvent(LifecycleEvent event);
}

监听器是怎么样注册自己感兴趣的事件呢？那就需要LifecycleSupport这个帮助类。

public final class LifecycleSupport {
    public LifecycleSupport(Lifecycle lifecycle) {
        super();
        this.lifecycle = lifecycle;
    }
    //引用一个实现了Lifecycle接口的Tomcat组件
    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是如何启动/停止它的子组件、子容器，绑定生命周期事件和监听器的呢。

public class SimpleContext implements Context, Pipeline, Lifecycle {
    //把SimpleContext自己注册给帮助类
    protected LifecycleSupport lifecycle = new LifecycleSupport(this);
    //委托帮助类处理监听器
    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");
        lifecycle.fireLifecycleEvent(BEFORE_START_EVENT, null);
        started = true;
        try {
            if ((loader != null) && (loader instanceof Lifecycle))
                ((Lifecycle) loader).start();
            //启动子容器
            Container Children[] = findChildren();
            for (int i = 0; i < children.length; i++) {
                if (children[i] instanceof Lifecycle)
                    ((Lifecycle) children[i]).start();
            }
            //启动pipeline中的value(包括baseValue)
            if (pipeline instanceof Lifecycle)
                ((Lifecycle) pipeline).start();
            //绑定事件监听器
            lifecycle.firelifecycleEvent(START_EVENT, null);
        } catch (Exception e) {
            e.printStackTrace();
        } 
        lifecycle.fireLifecycleEvent(AFTER_START_EVENT, null);
    }
    public void stop() throws LifecycleException {
        if (!started) throw new LifecycleException("SimpleContext has not been started"); 
        lifecycle.fireLifecycleEvent(BEFORE_STOP_EVENT, null);
        lifecycle.fireLifecycleEvent(STOP_EVENT, null);
        started = false;
        try {
            if (pipeline instanceof Lifecycle){
                ((Lifecycle) pipeline).stop();
            }
            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();
        }
        lifecycle.fireLifecycleEvent(AFTER_STOP_EVENT, null);
}

Lifecycle接口定义了一个组件的生命周期，并提供一个优雅的方式向组件推送事件。
另外通过Lifecycle接口，Tomcat可以"一键"启动/停止所有组件。