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