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

62次阅读
没有评论

共计 9097 个字符,预计需要花费 23 分钟才能阅读完成。

这篇文章主要讲解了“Tomcat 的生命周期是什么样子的”,文中的讲解内容简单清晰,易于学习与理解,下面请大家跟着丸趣 TV 小编的思路慢慢深入,一起来研究和学习“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 的生命周期是什么样子的这一问题有了更深刻的体会,具体使用情况还需要大家实践验证。这里是丸趣 TV,丸趣 TV 小编将为大家推送更多相关知识点的文章,欢迎关注!

正文完
 
丸趣
版权声明:本站原创文章,由 丸趣 2023-08-16发表,共计9097字。
转载说明:除特殊说明外本站除技术相关以外文章皆由网络搜集发布,转载请注明出处。
评论(没有评论)