tomcat启动流程

由于tomcat各种组件都实现了LifeCycle接口，所以tomcat的启动流程非常简单。从catalina开始，触发Server的start跟init生命周期方法，Server会触发子组件的相应的生命周期方法，同时还会调用相应生命周期事件的Listener。每个子组件相应的也会触发它的子组件的init或start方法，从而完成整个tomcat的启动

LifecycleBase

每个组件并不是直接实现LifeCycle，而是继承了LifecycleBase抽象类，例如StandardServer
LifecycleBase实现了LifeCycle接口中的生命周期方法，主要处理生命周期状态转移、触发生命周期事件Listener等逻辑，而具体的生命周期的逻辑通过xxxInternal交给子类实现

init实现

    public final synchronized void init() throws LifecycleException {
        // 校验转移状态是否合法
        if (!state.equals(LifecycleState.NEW)) {
            invalidTransition(Lifecycle.BEFORE_INIT_EVENT);
        }

        try {
            // 设置状态为INITIALIZING
            setStateInternal(LifecycleState.INITIALIZING, null, false);

            // 抽象方法，由子类实现
            initInternal();

            // 设置状态为INITIALIZED
            setStateInternal(LifecycleState.INITIALIZED, null, false);
        } catch (Throwable t) {
            handleSubClassException(t, "lifecycleBase.initFail", toString());
        }
    }

start实现

    public final synchronized void start() throws LifecycleException {

        // 如果状态STARTING_PREP、STARTING、STARTED，直接忽略
        if (LifecycleState.STARTING_PREP.equals(state) || LifecycleState.STARTING.equals(state) ||
                LifecycleState.STARTED.equals(state)) {

            if (log.isDebugEnabled()) {
                Exception e = new LifecycleException();
                log.debug(sm.getString("lifecycleBase.alreadyStarted", toString()), e);
            } else if (log.isInfoEnabled()) {
                log.info(sm.getString("lifecycleBase.alreadyStarted", toString()));
            }

            return;
        }

        // 如果状态是NEW，先init。init会确保转移的状态是正确的，不需要再次校验状态是否合法
        // 如果状态时FAILED，执行stop
        // 校验状态必须是INITIALIZED或者STOPPED，否则抛异常
        if (state.equals(LifecycleState.NEW)) {
            init();
        } else if (state.equals(LifecycleState.FAILED)) {
            stop();
        } else if (!state.equals(LifecycleState.INITIALIZED) &&
                !state.equals(LifecycleState.STOPPED)) {
            invalidTransition(Lifecycle.BEFORE_START_EVENT);
        }

        try {
            // 设置状态为STARTING_PREP，然后调用startInternal执行子类start逻辑
            setStateInternal(LifecycleState.STARTING_PREP, null, false);
            startInternal();
            if (state.equals(LifecycleState.FAILED)) {
                // 子类startInternal可以将自己状态设置为FAILED。这时执行stop
                stop();
            } else if (!state.equals(LifecycleState.STARTING)) {
                // 子类startInternal执行正常的话，必须要将状态置为STARTING，否则抛异常 
                invalidTransition(Lifecycle.AFTER_START_EVENT);
            } else {
                // 一切都正常，设置状态为STARTED
                setStateInternal(LifecycleState.STARTED, null, false);
            }
        } catch (Throwable t) {
            handleSubClassException(t, "lifecycleBase.startFail", toString());
        }
    }

触发Listener

Listener的触发是在setStateInternal内部。setStateInternal调用fireLifecycleEvent触发Listener

    private synchronized void setStateInternal(LifecycleState state, Object data, boolean check)
            throws LifecycleException {
        // 先校验转换是否合法，不合法的话抛异常

        this.state = state;
        String lifecycleEvent = state.getLifecycleEvent();
        if (lifecycleEvent != null) {
            fireLifecycleEvent(lifecycleEvent, data);
        }
    }

    protected void fireLifecycleEvent(String type, Object data) {
        LifecycleEvent event = new LifecycleEvent(this, type, data);
        for (LifecycleListener listener : lifecycleListeners) {
            listener.lifecycleEvent(event);
        }
    }