序言
Tomcat的生命周期管理的话，我们不能总是从书中获取那些知识，而是结合实践，然后综合书中的内容，进行一层一层的深入分析，这样对自己记忆和理解都能更加的透彻。
启动的时候的
大家可以随便找一个zip版本的Tomcat，然后直接启动起来，我们来看看是个什么样子的，
一月11,202110:16:24上午org.apache.coyote.AbstractProtocolinit信息:InitializingProtocolHandler["http-bio-8080"]一月11,202110:16:24上午org.apache.coyote.AbstractProtocolinit信息:InitializingProtocolHandler["ajp-bio-8009"]一月11,202110:16:24上午org.apache.catalina.startup.Catalinaload信息:Initializationprocessedin470ms一月11,202110:16:24上午org.apache.catalina.core.StandardServicestartInternal信息:StartingserviceCatalina一月11,202110:16:24上午org.apache.catalina.core.StandardEnginestartInternal信息:StartingServletEngine:ApacheTomcat/7.0.88一月11,202110:16:24上午org.apache.catalina.startup.HostConfigdeployDirectory
大家看到这个启动过程之后，在联想一下之前的文章中的Tomcat的启动流程，是不是又感觉有点那个味道了，load，然后start，最后然后stop了。
划重点1：Lifecycle
在之前的文章中，我们提到了Lifecycle, 而Tomcat也就是通过Lifecycle接口统一管理生命周期，所有有生命周期的组件都要实现Lifecycle接口，以便提供一致的机制去启动和停止组件。
那么我们就来分析一下这个Lifecycle接口里面都包含了哪些内容，大家可以直接去tomcat的包中的catalina的jar下面去寻找看一下，
定义了13个String类型的变量
定义了3个管理***的方法
定义了4个生命周期
定义了2个获取当前状态的方法
那么我们先说这个13个变量：
StringBEFORE_INIT_EVENT ="before_init";StringAFTER_INIT_EVENT ="after_init";StringSTART_EVENT ="start";StringBEFORE_START_EVENT ="before_start";StringAFTER_START_EVENT ="after_start";StringSTOP_EVENT ="stop";StringBEFORE_STOP_EVENT ="before_stop";StringAFTER_STOP_EVENT ="after_stop";StringAFTER_DESTROY_EVENT ="after_destroy";StringBEFORE_DESTROY_EVENT ="before_destroy";StringPERIODIC_EVENT ="periodic";StringCONFIGURE_START_EVENT ="configure_start";StringCONFIGURE_STOP_EVENT ="configure_stop";
这13个变量是什么意思呢？在《Tomcat架构解析》一书中说到，这些常量信息用于LifecycleEvent事件的type属性中，作用是区分组件发出的LifecycleEvent事件时的状态(如初始化前、启动前、启动中等)。这种设计方法可以让多种状态都发送同一种类型的时间，然后用其中的一个属性类区分状态而不用定义多种事件。
其实大家可以根据变量的名字就能看出来，初始化前，初始化后，启动，启动前，启动后。。。。说得在直白一点 ，就是为了表示组件发出时的状态而已。
而三个管理监听的方法又是什么呢？
voidaddLifecycleListener(LifecycleListener var1);LifecycleListener[]findLifecycleListeners();voidremoveLifecycleListener(LifecycleListener var1);
而这个三个***也分别就是用来添加，查找和删除LifecycleListener类型的***。这里面是三个接口，具体实现一会我们去子类里面找，在这里先知道有这么个东西就行，下面就会直接分析。
4个生命周期
这个就肯定很简单了，比如像我们都知道在Servlet的生命周期一样，init，start，stop，destroy，初始化，启动，停止，销毁，
voidinit()throwsLifecycleException;voidstart()throwsLifecycleException;voidstop()throwsLifecycleException;voiddestroy()throwsLifecycleException;
2个获取状态的方法
LifecycleStategetState();StringgetStateName();
毕竟这个Lifecycle是一个接口，它并不是具体的实现类，我们想要了解这个，那么就一定得去具体的实现类里面去找寻这个内容，那么他的实现类是什么呢？来了来了，它来了，LifecycleBase
LifecycleBase
LifecycleBase是抽象类，是tomcat中所有组件类的基类,他实现了Lifecycle，但是Tomcat下的很多子类也同样的继承了它，所以他也是非常重要的，
publicabstractclassLifecycleBaseimplementsLifecycle{privateLifecycleSupport lifecycle =newLifecycleSupport(this);// 源组件的当前状态,不同状态触发不同事件privatevolatileLifecycleState state;publicLifecycleBase(){this.state = LifecycleState.NEW; } }
在这里我们还要注意一下这个LifecycleSupport类，LifecycleSupport中定义了一个LifecycleListener数组类型的属性来保存所有的***，然后在里面分别定义了添加，删除，查找，执行***的方法，不信的话，我们来看看，毕竟这个类放在这里先new出来也是有一定道理的。
publicfinalclassLifecycleSupport{privateLifecycle lifecycle =null;privateLifecycleListener[] listeners = new LifecycleListener[0];privatefinalObject listenersLock = new Object();publicLifecycleSupport(Lifecycle lifecycle) {this.lifecycle = lifecycle; }publicvoid addLifecycleListener(LifecycleListener listener) { Object var2 =this.listenersLock; synchronized(this.listenersLock) { LifecycleListener[] results = new LifecycleListener[this.listeners.length +1];for(int i =0; i =0) { LifecycleListener[] results = new LifecycleListener[this.listeners.length -1]; int j =0;for(int i =0; i
话不多说，我们继续往下，它的生命周期方法又是什么呢？这才是今天的重点。之前我们就说生命周期包含了哪些内容，从init开始，然后start，然后stop以及最后的destroy方法，在实现类里面表现的那是淋漓尽致。
init方法
publicfinalsynchronized voidinit() throws LifecycleException {//这里表示只有NEW状态下是可以使用的，if(!this.state.equals(LifecycleState.NEW)) {this.invalidTransition("before_init"); }//在这里通过不同的状态，然后去触发不同的事件，try{//设置生命周期状态为INITIALIZINGthis.setStateInternal(LifecycleState.INITIALIZING, (Object)null,false);//执行方法this.initInternal();//设置生命周期状态为INITIALIZEDthis.setStateInternal(LifecycleState.INITIALIZED, (Object)null,false); }catch(Throwable var2) { ExceptionUtils.handleThrowable(var2);this.setStateInternal(LifecycleState.FAILED, (Object)null,false);thrownew LifecycleException(sm.getString("lifecycleBase.initFail", new Object[]{this.toString()}), var2); } }
start方法
publicfinalsynchronized void start() throws LifecycleException {//在这里验证生命周期状态，状态是这三种状态的是为不可用状态STARTING_PREP，STARTING，STARTEDif(!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方法}elseif(this.state.equals(LifecycleState.FAILED)) {this.stop();//如果是INITIALIZED状态，那么就会告诉你是个非法的操作}elseif(!this.state.equals(LifecycleState.INITIALIZED) && !this.state.equals(LifecycleState.STOPPED)) {this.invalidTransition("before_start"); }try{//设置启动状态为 STARTING_PREPthis.setStateInternal(LifecycleState.STARTING_PREP, (Object)null,false);this.startInternal();//这里就非常的严谨，他会在启动之后，继续去看状态是什么，保证启动成功if(this.state.equals(LifecycleState.FAILED)) {this.stop(); }elseif(!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);thrownew 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); }elseif(log.isInfoEnabled()) { log.info(sm.getString("lifecycleBase.alreadyStarted", new Object[]{this.toString()})); } } }
stop方法
publicfinalsynchronized void stop() throws LifecycleException {//同样的，和上面一样，三种状态下不可执行if(!LifecycleState.STOPPING_PREP.equals(this.state) && !LifecycleState.STOPPING.equals(this.state) && !LifecycleState.STOPPED.equals(this.state)) {//如果是NEW状态，状态直接修改为STOPPEDif(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方法
publicfinalsynchronized 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，那么就不再进行执行了，直接进行returnif(!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);thrownew LifecycleException(sm.getString("lifecycleBase.destroyFail", new Object[]{this.toString()}), var2); } }else{ ... ｝ }
阿粉在其中精简了一些代码，如果大家有兴趣的可以自己去翻一下源码，然后自己去看一下，这样对比出来才有效果。
总结
其实就是通过不同的状态转变，然后相应地去调用init、start、stop、destroy方法,然后提供所有Tomcat组件的生命周期管理。
上图就是接口状态不同情况执行不同方法地图，图片来自《Tomcat架构解析》
</article>
京公网安备 11010502036488号