tomcat——生命周期管理机制

Catalina由多个组件组成，当Catalina启动的时候，这些组件也会启动。当Catalina停止的时候，这些组件也必须有机会被清除。保持组件启动和停止一致的机制通过实现org.apache.catalina.Lifecycle接口来实现

如果一个组件可以触发事件，那么必须存在相应的监听器来对触发的事件作出回应。

Tomcat的生命周期管理机制算是监听器模式的一种应用

Lifecycle接口

Catalina的设计允许一个组件包含其他的组件，一个父组件负责启动和停止其子组件。

public interface Lifecycle {
    /**
     * 添加生命周期监听器
     *
     * @param listener 添加的监听器
     */
    void addLifecycleListener(LifecycleListener listener);

    /**
     * 删除生命周期监听器
     *
     * @param listener 删除的监听器
     */
    void removeLifecycleListener(LifecycleListener listener);

    /**
     * 获取所有的生命周期监听器
     *
     * @return 所有的生命周期监听器
     */
    List<LifecycleListener> findListeners();

    /**
     * 启动组件
     *
     * @throws LifecycleException 启动失败
     */
    void start() throws LifecycleException;

    /**
     * 关闭组件
     *
     * @throws LifecycleException 关闭失败
     */
    void stop() throws LifecycleException;

}

LifecycleEvent：表示一个生命周期事件 ，继承EventObject

public final class LifecycleEvent extends EventObject {
    //事件类型
    private LifecycleEventType type;
    //事件关联的数据对象
    private Object data;
    
    private Lifecycle lifecycle;

    public LifecycleEvent(LifecycleEventType type, Lifecycle lifecycle) {
        this(type, null, lifecycle);
    }

    public LifecycleEvent(LifecycleEventType type, Object data, Lifecycle lifecycle) {
        super(lifecycle);
        this.type = type;
        this.data = data;
        this.lifecycle = lifecycle;
    }

    public LifecycleEventType getType() {
        return type;
    }

    public void setType(LifecycleEventType type) {
        this.type = type;
    }

    public Object getData() {
        return data;
    }

    public void setData(Object data) {
        this.data = data;
    }

    public Lifecycle getLifecycle() {
        return lifecycle;
    }

    public void setLifecycle(Lifecycle lifecycle) {
        this.lifecycle = lifecycle;
    }
}
生命周期事件类型：

public enum LifecycleEventType {
    //启动前事件
    BEFORE_START,
    //启动事件
    START,
    //启动后事件
    AFTER_START,
    BEFORE_STOP,
    STOP,
    AFTER_STOP;
}
自定义生命周期异常

public class LifecycleException extends RuntimeException {

    public LifecycleException() {
    }

    public LifecycleException(String message) {
        super(message);
    }

    public LifecycleException(String message, Throwable cause) {
        super(message, cause);
    }

    public LifecycleException(Throwable cause) {
        super(cause);
    }

    public LifecycleException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
        super(message, cause, enableSuppression, writableStackTrace);
    }
}

监听器接口

public interface LifecycleListener {
    /**
     * 触发了生命周期事件
     *
     * @param event 触发的生命周期事件
     */
    void lifecycleEvent(LifecycleEvent event);

}

监听器实现

public class BeforeListener implements LifecycleListener {

    public void lifecycleEvent(LifecycleEvent event) {
        if (event.getType() == LifecycleEventType.BEFORE_START || event.getType() == LifecycleEventType.BEFORE_STOP) {
            System.out.println("BeforeListener");
        }
    }
}

LifecycleSupport : 统一实现触发事件和通知所有的listener

public final class LifecycleSupport {

    private Lifecycle lifecycle;

    private CopyOnWriteArrayList<LifecycleListener> listeners = new CopyOnWriteArrayList<LifecycleListener>();

    public LifecycleSupport(Lifecycle lifecycle) {
        this.lifecycle = lifecycle;
    }

    public void addLifecycleListener(LifecycleListener listener) {
        listeners.add(listener);
    }

    public void removeLifecycleListener(LifecycleListener listener) {
        listeners.remove(listener);
    }

    public List<LifecycleListener> findListeners() {
        return listeners;
    }

    public void fireLifecycleEvent(LifecycleEvent event) {
        for (LifecycleListener listener : listeners) {
            listener.lifecycleEvent(event);
        }
    }

}

组件——实现Lifecycle接口，负责触发生命周期事件

public class Component implements Lifecycle {

    private LifecycleSupport lifecycleSupport = new LifecycleSupport(this);

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

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

    public List<LifecycleListener> findListeners() {
        return lifecycleSupport.findListeners();
    }

    public void start() throws LifecycleException {
        LifecycleEvent event = new LifecycleEvent(LifecycleEventType.BEFORE_START, this);
        lifecycleSupport.fireLifecycleEvent(event);
        event = new LifecycleEvent(LifecycleEventType.START, this);
        lifecycleSupport.fireLifecycleEvent(event);
        event = new LifecycleEvent(LifecycleEventType.AFTER_STOP, this);
        lifecycleSupport.fireLifecycleEvent(event);
    }

    public void stop() throws LifecycleException {
        LifecycleEvent event = new LifecycleEvent(LifecycleEventType.BEFORE_STOP, this);
        lifecycleSupport.fireLifecycleEvent(event);
        event = new LifecycleEvent(LifecycleEventType.STOP, this);
        lifecycleSupport.fireLifecycleEvent(event);
        event = new LifecycleEvent(LifecycleEventType.AFTER_STOP, this);
        lifecycleSupport.fireLifecycleEvent(event);
    }
}

测试类

public class TestLifecycle {

    public static void main(String[] args) {
        Component component = new Component();
        component.addLifecycleListener(new BeforeListener());
        if (component instanceof Lifecycle) {
            component.start();
            component.stop();
        }
    }
}