Tomcat的生命周期是什么樣子的

這篇文章主要講解了“Tomcat的生命周期是什么樣子的”，文中的講解內容簡單清晰，易于學習與理解，下面請大家跟著小編的思路慢慢深入，一起來研究和學習“Tomcat的生命周期是什么樣子的”吧！

序言

Tomcat的生命周期管理的話，我們不能總是從書中獲取那些知識，而是結合實踐，然后綜合書中的內容，進行一層一層的深入分析，這樣對自己記憶和理解都能更加的透徹。

啟動的時候的

大家可以隨便找一個zip版本的Tomcat，然后直接啟動起來，我們來看看是個什么樣子的，

一月 11, 2021 10:16:24 上午 org.apache.coyote.AbstractProtocol init 信息: Initializing ProtocolHandler ["http-bio-8080"] 一月 11, 2021 10:16:24 上午 org.apache.coyote.AbstractProtocol init 信息: Initializing ProtocolHandler ["ajp-bio-8009"] 一月 11, 2021 10:16:24 上午 org.apache.catalina.startup.Catalina load 信息: Initialization processed in 470 ms 一月 11, 2021 10:16:24 上午 org.apache.catalina.core.StandardService startInternal 信息: Starting service Catalina 一月 11, 2021 10:16:24 上午 org.apache.catalina.core.StandardEngine startInternal 信息: Starting Servlet Engine: Apache Tomcat/7.0.88 一月 11, 2021 10:16:24 上午 org.apache.catalina.startup.HostConfig deployDirectory

大家看到這個啟動過程之后，在聯想一下之前的文章中的Tomcat的啟動流程，是不是又感覺有點那個味道了，load，然后start，最后然后stop了。

劃重點1：Lifecycle

在之前的文章中，我們提到了Lifecycle,  而Tomcat也就是通過Lifecycle接口統一管理生命周期，所有有生命周期的組件都要實現Lifecycle接口，以便提供一致的機制去啟動和停止組件。

那么我們就來分析一下這個Lifecycle接口里面都包含了哪些內容，大家可以直接去tomcat的包中的catalina的jar下面去尋找看一下，

• 定義了13個String類型的變量

• 定義了3個管理監聽器的方法

• 定義了4個生命周期

• 定義了2個獲取當前狀態的方法

那么我們先說這個13個變量：

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

這13個變量是什么意思呢?在《Tomcat架構解析》一書中說到，這些常量信息用于LifecycleEvent事件的type屬性中，作用是區分組件發出的LifecycleEvent事件時的狀態(如初始化前、啟動前、啟動中等)。這種設計方法可以讓多種狀態都發送同一種類型的時間，然后用其中的一個屬性類區分狀態而不用定義多種事件。

其實大家可以根據變量的名字就能看出來，初始化前，初始化后，啟動，啟動前，啟動后。。。。說的在直白一點 ，就是為了表示組件發出時的狀態而已。

而三個管理監聽的方法又是什么呢?

void addLifecycleListener(LifecycleListener var1);  LifecycleListener[] findLifecycleListeners();  void removeLifecycleListener(LifecycleListener var1);

而這個三個監聽器也分別就是用來添加，查找和刪除LifecycleListener類型的監聽器。這里面是三個接口，具體實現一會我們去子類里面找，在這里先知道有這么個東西就行，下面就會直接分析。

4個生命周期

這個就肯定很簡單了，比如像我們都知道在Servlet的生命周期一樣，init，start，stop，destroy，初始化，啟動，停止，銷毀，

void init() throws LifecycleException;  void start() throws LifecycleException;  void stop() throws LifecycleException;  void destroy() throws LifecycleException;

2個獲取狀態的方法

LifecycleState getState();  String getStateName();

畢竟這個Lifecycle是一個接口，它并不是具體的實現類，我們想要了解這個，那么就一定得去具體的實現類里面去找尋這個內容，那么他的實現類是什么呢?來了來了，它來了，LifecycleBase

LifecycleBase

LifecycleBase是抽象類，是tomcat中所有組件類的基類,他實現了Lifecycle，但是Tomcat下的很多子類也同樣的繼承了它，所以他也是非常重要的，

public abstract class LifecycleBase implements Lifecycle {  private LifecycleSupport lifecycle = new LifecycleSupport(this);  // 源組件的當前狀態,不同狀態觸發不同事件     private volatile LifecycleState state;     public LifecycleBase() {         this.state = LifecycleState.NEW;     }    }

在這里我們還要注意一下這個LifecycleSupport類，LifecycleSupport中定義了一個LifecycleListener數組類型的屬性來保存所有的監聽器，然后在里面分別定義了添加，刪除，查找，執行監聽器的方法，不信的話，我們來看看，畢竟這個類放在這里先new出來也是有一定道理的。

public final class LifecycleSupport {     private Lifecycle lifecycle = null;     private LifecycleListener[] listeners = new LifecycleListener[0];     private final Object listenersLock = new Object();      public LifecycleSupport(Lifecycle lifecycle) {         this.lifecycle = lifecycle;     }      public void addLifecycleListener(LifecycleListener listener) {         Object var2 = this.listenersLock;         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) {         Object var2 = this.listenersLock;         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;             }         }     } }

話不多說，我們繼續往下，它的生命周期方法又是什么呢?這才是今天的重點。之前我們就說生命周期包含了哪些內容，從init開始，然后start，然后stop以及最后的destroy方法，在實現類里面表現的那是淋漓盡致。

init方法

public final synchronized void init() throws LifecycleException {        //這里表示只有NEW狀態下是可以使用的，        if (!this.state.equals(LifecycleState.NEW)) {            this.invalidTransition("before_init");        }    //在這里通過不同的狀態，然后去觸發不同的事件，        try {            //設置生命周期狀態為INITIALIZING            this.setStateInternal(LifecycleState.INITIALIZING, (Object)null, false);            //執行方法            this.initInternal();            //設置生命周期狀態為INITIALIZED            this.setStateInternal(LifecycleState.INITIALIZED, (Object)null, false);        } 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);        }    }

start方法

public final synchronized void start() throws LifecycleException {    //在這里驗證生命周期狀態，狀態是這三種狀態的是為不可用狀態STARTING_PREP，STARTING，STARTED        if (!LifecycleState.STARTING_PREP.equals(this.state) && !LifecycleState.STARTING.equals(this.state) && !LifecycleState.STARTED.equals(this.state)) {            //如果是NEW狀態，執行init方法            if (this.state.equals(LifecycleState.NEW)) {                this.init();            //如果是FAILED狀態，那么執行stop方法            } else if (this.state.equals(LifecycleState.FAILED)) {                this.stop();            //如果是INITIALIZED狀態，那么就會告訴你是個非法的操作            } else if (!this.state.equals(LifecycleState.INITIALIZED) && !this.state.equals(LifecycleState.STOPPED)) {                this.invalidTransition("before_start");            }             try {                //設置啟動狀態為 STARTING_PREP                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) {                ExceptionUtils.handleThrowable(var2);                this.setStateInternal(LifecycleState.FAILED, (Object)null, false);                throw new LifecycleException(sm.getString("lifecycleBase.startFail", new Object[]{this.toString()}), var2);            }        } 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()}));            }         }    }

stop方法

public final synchronized void stop() throws LifecycleException {        //同樣的，和上面一樣，三種狀態下不可執行        if (!LifecycleState.STOPPING_PREP.equals(this.state) && !LifecycleState.STOPPING.equals(this.state) && !LifecycleState.STOPPED.equals(this.state)) {            //如果是NEW狀態，狀態直接修改為STOPPED            if (this.state.equals(LifecycleState.NEW)) {                this.state = LifecycleState.STOPPED;            } else {                //如果不是這2中狀態，那么就直接異常                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) {                    ...                } finally {                   ...                }             }        } else {            ...        }    }

destroy方法

public final synchronized void destroy() throws LifecycleException {         //如果狀態是啟動失敗的，也就是FAILED，那么會直接去調用stop方法，         if (LifecycleState.FAILED.equals(this.state)) {             try {                 this.stop();             } catch (LifecycleException var3) {                 log.warn(sm.getString("lifecycleBase.destroyStopFail", new Object[]{this.toString()}), var3);             }         }         //如果是這兩種狀態DESTROYING、DESTROYED，那么就不再進行執行了，直接進行return         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) {                 ExceptionUtils.handleThrowable(var2);                 this.setStateInternal(LifecycleState.FAILED, (Object)null, false);                 throw new LifecycleException(sm.getString("lifecycleBase.destroyFail", new Object[]{this.toString()}), var2);             }         } else {          ...         ｝     }

感謝各位的閱讀，以上就是“Tomcat的生命周期是什么樣子的”的內容了，經過本文的學習后，相信大家對Tomcat的生命周期是什么樣子的這一問題有了更深刻的體會，具體使用情況還需要大家實踐驗證。這里是億速云，小編將為大家推送更多相關知識點的文章，歡迎關注！