淺讀tomcat架構設計之tomcat生命周期(2)

　　淺讀tomcat架構設計和tomcat啟動過程(1)

　　https://www.cnblogs.com/piaomiaohongchen/p/14977272.html

　　tomcat通過org.apache.catalina.Lifecycle接口統一管理生命周期,所有有生命周期的組建都要實現Lifecycle接口.

　　通過反射加載查看代碼:

　　Lifecycle的接口方法有很多,簡單解讀下:　　

　　(1)定義13個String類型的常量,不同的常量,代表不同的狀態信息

　　

 

 

　　(2)定義了3個管理監聽器的方法:

　　分別是添加,監聽和刪除

    void addLifecycleListener(LifecycleListener var1);

    LifecycleListener[] findLifecycleListeners();

    void removeLifecycleListener(LifecycleListener var1);

 

　　

 

　　

　　(3)定義了四個生命周期方法:

　　　　分別是初始化,開啟,停止,銷毀:

void init() throws LifecycleException;

void start() throws LifecycleException;

void stop() throws LifecycleException;

void destroy() throws LifecycleException;

　　

 

 

 　(4)定義了獲取狀態的兩個方法:

LifecycleState getState();

String getStateName();

　　

 

 　　其中getState的返回類是enum類型,getStateName返回的類型是String類型

　　Lifecycle接口的默認實現是org.apache.catalina.util.LifecycleBase,LifecycleBase為Lifecycle里的接口方法提供了默認實現.

　　先看看三個管理監聽器方法的具體實現:

　　org.apache.catalina.util.LifecycleBase:　　　

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

    public LifecycleListener[] findLifecycleListeners() {
        return this.lifecycle.findLifecycleListeners();
    }

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

　　發現在方法內部都是調用的lifecycle.**()方法

　　而this.lifecycle的定義是

　　　　

　private final LifecycleSupport lifecycle = new LifecycleSupport(this);

　　　　

 

　　三個監聽器方法都是調用的是LifecycleSupport類的對象方法

　　LifecycleSupport監聽器是通過一個數組屬性listeners來保存的,代碼如下:

　　org.apache.catalina.util.LifecycleSupport:

private final Object listenersLock = new Object();

    public LifecycleSupport(Lifecycle lifecycle) {
        this.lifecycle = lifecycle;
    }

    public void addLifecycleListener(LifecycleListener listener) {
        synchronized(this.listenersLock) {
            LifecycleListener[] results = new LifecycleListener[this.listeners.length + 1];

            for(int i = 0; i < this.listeners.length; ++i) {
                results[i] = this.listeners[i];
            }

            results[this.listeners.length] = listener;
            this.listeners = results;
        }
    }

    public LifecycleListener[] findLifecycleListeners() {
        return this.listeners;
    }

    public void fireLifecycleEvent(String type, Object data) {
        LifecycleEvent event = new LifecycleEvent(this.lifecycle, type, data);
        LifecycleListener[] interested = this.listeners;

        for(int i = 0; i < interested.length; ++i) {
            interested[i].lifecycleEvent(event);
        }

    }

    public void removeLifecycleListener(LifecycleListener listener) {
        synchronized(this.listenersLock) {
            int n = -1;

            for(int i = 0; i < this.listeners.length; ++i) {
                if (this.listeners[i] == listener) {
                    n = i;
                    break;
                }
            }

            if (n >= 0) {
                LifecycleListener[] results = new LifecycleListener[this.listeners.length - 1];
                int j = 0;

                for(int i = 0; i < this.listeners.length; ++i) {
                    if (i != n) {
                        results[j++] = this.listeners[i];
                    }
                }

                this.listeners = results;
            }
        }
    }

　　這三個方法的實現非常簡單,就是新增/刪除/查找等動作的實現,就是對listener屬性做操作

　　　　其中的fireLifecycleEvent函數的含義是用於遍歷所有監聽器進行處理　　

　　　　

 

　　

　　四個生命周期的方法:

　　　　先看init方法,讓我們回到之前的org.apache.catalina.util.LifecycleBase類:

　　　　org.apache.catalina.util.LifecycleBase:

　　　　

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

        this.setStateInternal(LifecycleState.INITIALIZING, (Object)null, false);

        try {
            this.initInternal();
        } catch (Throwable var2) {
            ExceptionUtils.handleThrowable(var2);
            this.setStateInternal(LifecycleState.FAILED, (Object)null, false);
            throw new LifecycleException(sm.getString("lifecycleBase.initFail", new Object[]{this.toString()}), var2);
        }

        this.setStateInternal(LifecycleState.INITIALIZED, (Object)null, false);
    }

　　代碼很簡單,就是先判斷state是否是LifecycleState.NEW,如果是NEW的話就設置為state狀態為LifecycleState.INITIALIZING,如果不是,就拋出異常,所以init初始化的時候必須是LifecycleState.NEW

　　接着往下看,看start方法:

　　　　　

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

            this.setStateInternal(LifecycleState.STARTING_PREP, (Object)null, false);

            try {
                this.startInternal();
            } catch (Throwable var2) {
                ExceptionUtils.handleThrowable(var2);
                this.setStateInternal(LifecycleState.FAILED, (Object)null, false);
                throw new LifecycleException(sm.getString("lifecycleBase.startFail", new Object[]{this.toString()}), var2);
            }

            if (!this.state.equals(LifecycleState.FAILED) && !this.state.equals(LifecycleState.MUST_STOP)) {
                if (!this.state.equals(LifecycleState.STARTING)) {
                    this.invalidTransition("after_start");
                }

                this.setStateInternal(LifecycleState.STARTED, (Object)null, false);
            } else {
                this.stop();
            }

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

        }
    }

　　start方法做的事情比int方法多一些,判斷state狀態,如果是LifecycleState.NEW,就初始化,根據不同的state狀態,進不同的邏輯,然后設置狀態調用setStateInternal方法:

　　　　跟進方法:

　　　　還是在org.apache.catalina.util.LifecycleBase:

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

    }

　　這個方法先是判斷check,然后判斷state是否為null,是null就拋出異常,最后將state賦值給state變量,然后調用getLifecycleEvent方法處理事件,下面的this.fireLifecycleEvent(lifecycleEvent, data);實際上調用的是LifecycleSupport類的方法:

　　跟進這個方法看下:

　　　　

 protected void fireLifecycleEvent(String type, Object data) {
        this.lifecycle.fireLifecycleEvent(type, data);
    }

　　　繼續往上回溯:

　　

 private final LifecycleSupport lifecycle = new LifecycleSupport(this);

 

　　同理stop和destroy方法邏輯類似

 

　　獲取狀態的兩個方法　　

　　還是在org.apache.catlina.util.LifecycleBase:

　　在生命周期的相應方法中獲取state屬性,直接返回的state

　　

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

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