tomcat源码分析二：生命周期管理

tomcat源码分析二：生命周期管理

tomcat各个组件的启动与停止是是通过生命周期进行管理的。各个需要被生命周期管理的组件均实现了生命周期接口。

生命周期接口定义如下

public interface Lifecycle {
    // 首先定义了十一种生命周期事件点
    public static final String BEFORE_INIT_EVENT = "before_init";
    public static final String AFTER_INIT_EVENT = "after_init";
    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 static final String AFTER_DESTROY_EVENT = "after_destroy";
    public static final String BEFORE_DESTROY_EVENT = "before_destroy";
    public static final String PERIODIC_EVENT = "periodic";
    public static final String CONFIGURE_START_EVENT = "configure_start";
    public static final String CONFIGURE_STOP_EVENT = "configure_stop";

    //三种关于LifeCycleListener的操作，增加，查找，以及删除
    public void addLifecycleListener(LifecycleListener listener);
    public LifecycleListener[] findLifecycleListeners();
    public void removeLifecycleListener(LifecycleListener listener);
    // 生命周期的四种动作，并且四个生命周期是依次执行的。
    public void init() throws LifecycleException;  //结束后会产生 INIT_EVENT 事件
    public void start() throws LifecycleException;  //过程中会产生BEFORE_START_EVENT，START_EVENT，AFTER_START_EVENT事件
    public void stop() throws LifecycleException; //会产生BEFORE_STOP_EVENT，STOP_EVENT，AFTER_STOP_EVENT事件
    public void destroy() throws LifecycleException; //会产生 DESTROY_EVENT事件

    // 获取当前的生命周期状态
    public LifecycleState getState();
    public String getStateName();
}

生命周期各状态定义

public enum LifecycleState {
    NEW(false, null),
    INITIALIZING(false, Lifecycle.BEFORE_INIT_EVENT),
    INITIALIZED(false, Lifecycle.AFTER_INIT_EVENT),
    STARTING_PREP(false, Lifecycle.BEFORE_START_EVENT),
    STARTING(true, Lifecycle.START_EVENT),
    STARTED(true, Lifecycle.AFTER_START_EVENT),
    STOPPING_PREP(true, Lifecycle.BEFORE_STOP_EVENT),
    STOPPING(false, Lifecycle.STOP_EVENT),
    STOPPED(false, Lifecycle.AFTER_STOP_EVENT),
    DESTROYING(false, Lifecycle.BEFORE_DESTROY_EVENT),
    DESTROYED(false, Lifecycle.AFTER_DESTROY_EVENT),
    FAILED(false, null);

    private final boolean available;
    private final String lifecycleEvent;

    private LifecycleState(boolean available, String lifecycleEvent) {
        this.available = available;
        this.lifecycleEvent = lifecycleEvent;
    }
    // 只有在 STARTING，STARTED，STOPPING_PREP三个状态下时，才是有效状态
    public boolean isAvailable() {
        return available;
    }

    public String getLifecycleEvent() {
        return lifecycleEvent;
    }
}

生命周期变化监听器

生命周期变化监听器LifecycleListener可以监听生命周期变化，根据生命周期各事件，从而响应各动作。接口定义如下

public interface LifecycleListener {
    public void lifecycleEvent(LifecycleEvent event);
}

可以作为二等生命周期组件来看待。例如EngineConfig 其实现了LifecycleListener接口。其的具体实现如下

@Override
    public void lifecycleEvent(LifecycleEvent event) {

        // Identify the engine we are associated with
        try {
            engine = (Engine) event.getLifecycle();
        } catch (ClassCastException e) {
            log.error(sm.getString("engineConfig.cce", event.getLifecycle()), e);
            return;
        }

        // Process the event that has occurred
        if (event.getType().equals(Lifecycle.START_EVENT))
            start();
        else if (event.getType().equals(Lifecycle.STOP_EVENT))
            stop();

    }

生命周期的子类

看各个子类的继承图

我们核心关注红色标注的几个接口。
Container中有四个主要的子接口

• Engine，其实现类为StandardEngine
• Host，其实现类为StandardHost
• Context，其实现类为StandardContext。
• Wrapper ，其实现类为StandardWrapper

同时，该四个实现类均实现了ContainerBase接口，ContainerBase类是一个虚类。
还有Service类及其实现类StandardService，Server类及期实现类StandardServer类，Executor类及期实现类StandardThreadExecutor。

通过这个生命周期管理，以及tomcat中的各个组件就有了启动时的时序图。时序图如下

同理，stop的时序图下，与start整体相同，部分有少许差异

通过以上的流程，就完成了tomcat各个组件的启动与停止