Tomcat简单的分析-生命周期管理

1.LifyCycle接口

 Tomcat通过org.apache.catalina.Lifecycle接口统一管理生命周期，所有生命周期的组件都要实现这个接口。Lifycycle接口一共做了四件事：

    1.1定义了13个String类型的常量，用于LifecycleEvent事件中type的属性，作用是区分发出事件的状态(初始化，启动前后)

    1.2定义了三个管理监听器LifecycleListener的方法,分别用来添加，查找和删除监听器

    1.3定义了四个生命周期的方法init,start,stop,destroy

    1.4定义了获取当前状态的两个方法getState和getStateName

源码：

package org.apache.catalina;

public interface Lifecycle {
    String BEFORE_INIT_EVENT = "before_init";
    String AFTER_INIT_EVENT = "after_init";
    String START_EVENT = "start";
    String BEFORE_START_EVENT = "before_start";
    String AFTER_START_EVENT = "after_start";
    String STOP_EVENT = "stop";
    String BEFORE_STOP_EVENT = "before_stop";
    String AFTER_STOP_EVENT = "after_stop";
    String AFTER_DESTROY_EVENT = "after_destroy";
    String BEFORE_DESTROY_EVENT = "before_destroy";
    String PERIODIC_EVENT = "periodic";
    String CONFIGURE_START_EVENT = "configure_start";
    String CONFIGURE_STOP_EVENT = "configure_stop";

    void addLifecycleListener(LifecycleListener var1);

    LifecycleListener[] findLifecycleListeners();

    void removeLifecycleListener(LifecycleListener var1);

    void init() throws LifecycleException;

    void start() throws LifecycleException;

    void stop() throws LifecycleException;

    void destroy() throws LifecycleException;

    LifecycleState getState();

    String getStateName();

    public interface SingleUse {
    }
}

2.LifycycleBase抽象类

      Lifecycle的默认实现是org.apache.catalina.util.LifecycleBase，

            监听器是通过LifecycleSupport类中定义了一个LifecycleListener数据来保存所有的监听器。

            生命周期方法中设置了相应的状态并调用了相应的模板方法init,start,stop,destroy所对应的模板方法分别是initInternal,startInternal,stopInternal,destroyInternal方法，这四个方法都是由子类具体实现

源码：

public abstract class LifecycleBase implements Lifecycle {
    private static final Log log = LogFactory.getLog(LifecycleBase.class);
    private static final StringManager sm = StringManager.getManager(LifecycleBase.class);
    private final List<LifecycleListener> lifecycleListeners = new CopyOnWriteArrayList();
    private volatile LifecycleState state;
    private boolean throwOnFailure;

    public LifecycleBase() {
        this.state = LifecycleState.NEW;
        this.throwOnFailure = true;
    }

    public boolean getThrowOnFailure() {
        return this.throwOnFailure;
    }

    public void setThrowOnFailure(boolean throwOnFailure) {
        this.throwOnFailure = throwOnFailure;
    }

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

    public LifecycleListener[] findLifecycleListeners() {
        return (LifecycleListener[])this.lifecycleListeners.toArray(new LifecycleListener[0]);
    }

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

    protected void fireLifecycleEvent(String type, Object data) {
        LifecycleEvent event = new LifecycleEvent(this, type, data);
        Iterator var4 = this.lifecycleListeners.iterator();

        while(var4.hasNext()) {
            LifecycleListener listener = (LifecycleListener)var4.next();
            listener.lifecycleEvent(event);
        }

    }

    public final synchronized void init() throws LifecycleException {
        if (!this.state.equals(LifecycleState.NEW)) {
            this.invalidTransition("before_init");
        }

        try {
            this.setStateInternal(LifecycleState.INITIALIZING, (Object)null, false);
            this.initInternal();
            this.setStateInternal(LifecycleState.INITIALIZED, (Object)null, false);
        } catch (Throwable var2) {
            this.handleSubClassException(var2, "lifecycleBase.initFail", this.toString());
        }

    }

    protected abstract void initInternal() throws LifecycleException;

    public final synchronized void start() throws LifecycleException {
        if (!LifecycleState.STARTING_PREP.equals(this.state) && !LifecycleState.STARTING.equals(this.state) && !LifecycleState.STARTED.equals(this.state)) {
            if (this.state.equals(LifecycleState.NEW)) {
                this.init();
            } else if (this.state.equals(LifecycleState.FAILED)) {
                this.stop();
            } else if (!this.state.equals(LifecycleState.INITIALIZED) && !this.state.equals(LifecycleState.STOPPED)) {
                this.invalidTransition("before_start");
            }

            try {
                this.setStateInternal(LifecycleState.STARTING_PREP, (Object)null, false);
                this.startInternal();
                if (this.state.equals(LifecycleState.FAILED)) {
                    this.stop();
                } else if (!this.state.equals(LifecycleState.STARTING)) {
                    this.invalidTransition("after_start");
                } else {
                    this.setStateInternal(LifecycleState.STARTED, (Object)null, false);
                }
            } catch (Throwable var2) {
                this.handleSubClassException(var2, "lifecycleBase.startFail", this.toString());
            }

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

        }
    }

    protected abstract void startInternal() throws LifecycleException;

    public final synchronized void stop() throws LifecycleException {
        if (!LifecycleState.STOPPING_PREP.equals(this.state) && !LifecycleState.STOPPING.equals(this.state) && !LifecycleState.STOPPED.equals(this.state)) {
            if (this.state.equals(LifecycleState.NEW)) {
                this.state = LifecycleState.STOPPED;
            } else {
                if (!this.state.equals(LifecycleState.STARTED) && !this.state.equals(LifecycleState.FAILED)) {
                    this.invalidTransition("before_stop");
                }

                try {
                    if (this.state.equals(LifecycleState.FAILED)) {
                        this.fireLifecycleEvent("before_stop", (Object)null);
                    } else {
                        this.setStateInternal(LifecycleState.STOPPING_PREP, (Object)null, false);
                    }

                    this.stopInternal();
                    if (!this.state.equals(LifecycleState.STOPPING) && !this.state.equals(LifecycleState.FAILED)) {
                        this.invalidTransition("after_stop");
                    }

                    this.setStateInternal(LifecycleState.STOPPED, (Object)null, false);
                } catch (Throwable var5) {
                    this.handleSubClassException(var5, "lifecycleBase.stopFail", this.toString());
                } finally {
                    if (this instanceof SingleUse) {
                        this.setStateInternal(LifecycleState.STOPPED, (Object)null, false);
                        this.destroy();
                    }

                }

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

        }
    }

    protected abstract void stopInternal() throws LifecycleException;

    public final synchronized void destroy() throws LifecycleException {
        if (LifecycleState.FAILED.equals(this.state)) {
            try {
                this.stop();
            } catch (LifecycleException var3) {
                log.warn(sm.getString("lifecycleBase.destroyStopFail", new Object[]{this.toString()}), var3);
            }
        }

        if (!LifecycleState.DESTROYING.equals(this.state) && !LifecycleState.DESTROYED.equals(this.state)) {
            if (!this.state.equals(LifecycleState.STOPPED) && !this.state.equals(LifecycleState.FAILED) && !this.state.equals(LifecycleState.NEW) && !this.state.equals(LifecycleState.INITIALIZED)) {
                this.invalidTransition("before_destroy");
            }

            try {
                this.setStateInternal(LifecycleState.DESTROYING, (Object)null, false);
                this.destroyInternal();
                this.setStateInternal(LifecycleState.DESTROYED, (Object)null, false);
            } catch (Throwable var2) {
                this.handleSubClassException(var2, "lifecycleBase.destroyFail", this.toString());
            }

        } else {
            if (log.isDebugEnabled()) {
                Exception e = new LifecycleException();
                log.debug(sm.getString("lifecycleBase.alreadyDestroyed", new Object[]{this.toString()}), e);
            } else if (log.isInfoEnabled() && !(this instanceof SingleUse)) {
                log.info(sm.getString("lifecycleBase.alreadyDestroyed", new Object[]{this.toString()}));
            }

        }
    }

    protected abstract void destroyInternal() throws LifecycleException;

    public LifecycleState getState() {
        return this.state;
    }

    public String getStateName() {
        return this.getState().toString();
    }

    protected synchronized void setState(LifecycleState state) throws LifecycleException {
        this.setStateInternal(state, (Object)null, true);
    }

    protected synchronized void setState(LifecycleState state, Object data) throws LifecycleException {
        this.setStateInternal(state, data, true);
    }

    private synchronized void setStateInternal(LifecycleState state, Object data, boolean check) throws LifecycleException {
        if (log.isDebugEnabled()) {
            log.debug(sm.getString("lifecycleBase.setState", new Object[]{this, state}));
        }

        if (check) {
            if (state == null) {
                this.invalidTransition("null");
                return;
            }

            if (state != LifecycleState.FAILED && (this.state != LifecycleState.STARTING_PREP || state != LifecycleState.STARTING) && (this.state != LifecycleState.STOPPING_PREP || state != LifecycleState.STOPPING) && (this.state != LifecycleState.FAILED || state != LifecycleState.STOPPING)) {
                this.invalidTransition(state.name());
            }
        }

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

    }

    private void invalidTransition(String type) throws LifecycleException {
        String msg = sm.getString("lifecycleBase.invalidTransition", new Object[]{type, this.toString(), this.state});
        throw new LifecycleException(msg);
    }

    private void handleSubClassException(Throwable t, String key, Object... args) throws LifecycleException {
        ExceptionUtils.handleThrowable((Throwable)t);
        this.setStateInternal(LifecycleState.FAILED, (Object)null, false);
        String msg = sm.getString(key, args);
        if (this.getThrowOnFailure()) {
            if (!(t instanceof LifecycleException)) {
                t = new LifecycleException(msg, (Throwable)t);
            }

            throw (LifecycleException)t;
        } else {
            log.error(msg, (Throwable)t);
        }
    }
}