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

- 日理万妓 2022-05-21 10:04 140阅读 0赞

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