Tomcat分析二 —— Tomcat的生命周期管理

最新推荐文章于 2023-07-03 22:44:11 发布
最新推荐文章于 2023-07-03 22:44:11 发布
阅读量425 收藏
点赞数 1
分类专栏： tomcat 文章标签： java servlet tomcat
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/u8080/article/details/105563881
版权

2 Tocmat的生命周期管理

2.1 Lifecycle 接口

​ Tomcat通过Lifecycle接口统一管理生命周期，所有有生命周期的组件都要实现Lifecycle接口。它一共做了4件事

  1. 定义13个String类型常量，用于LifecycleEvent事件的type属性中，为了区分组件发出的LifecycleEvent事件时的状态(初始化前、启动前、启动中等)。

    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. 定义三个管理监听器的方法addLifecycleListener、findLifecycleEvent和removeLifecycleListener，分别用来添加、查找和删除LifecycleListener类型的监听器

  3. 定义4个生命周期的方法：init、start、stop和destroy，用于执行生命周期的各个阶段的操作

  4. 定义了获取当前 状态的两个方法getState和getStateName，用来获取当前的状态，getState获取的事枚举类型，里面列举了生命周期的各个节点，getStateName方法返回String类型的状态的名字，用于JMX中。

2.2 LifecycleBase

​ Lifecycle默认实现是LifecycleBase，实现了生命周期的组件都直接或间接地继承自LifecycleBase。

  • 监听管理使用了LifecycleSupport类来完成，定义了一个LifecycleListener数组类型的属性来保存所有的监听器，然后定义了添加、删除、查找和执行监听器的方法
  • 生命周期方法中设置了相应的状态并调用了相应的模版方法，init、start、stop和destroy对应的模版方法分别是initInternal、startInternal、stopInternal和destroyInternal方法，这四个方法由子类具体实现
  • 组件当前的状态在声明周期的四个方法中已经设置好了，直接返回

三个管理监听器的方法

  private LifecycleSupport lifecycle = new LifecycleSupport(this);
    @Override
    public void addLifecycleListener(LifecycleListener listener) {
        lifecycle.addLifecycleListener(listener);
    }
    @Override
    public LifecycleListener[] findLifecycleListeners() {
        return lifecycle.findLifecycleListeners();
    }
    @Override
    public void removeLifecycleListener(LifecycleListener listener) {
        lifecycle.removeLifecycleListener(listener);
    }

​ addLifecycleListener、findLifecycleListeners和removeLifecycleListener分别调用了LifecycleSupport中同名的方法，LifecycleSupport监听器是通过一个数组属性listeners保存的

​ 这三个方法就是对listeners（数组类型）属性进行操作

  • 添加时新建比当前数组大一的数组，将原来的数据按顺序保存进去，将新的添加最后，并将新建的数组赋给listeners属性
  • 删除时先找到要删除的监听器在数组中的序号，新建一个比当前小一的数组，将除了要删除的监听器所在的序号的元素按顺序添加进入，最后再赋值给listeners属性
private LifecycleListener listeners[] = new LifecycleListener[0];
private final Object listenersLock = new Object(); // Lock object for changes to listeners
public void addLifecycleListener(LifecycleListener listener) {
  synchronized (listenersLock) {
      LifecycleListener results[] = new LifecycleListener[listeners.length + 1];
      for (int i = 0; i < listeners.length; i++)
          results[i] = listeners[i];
      results[listeners.length] = listener;
      listeners = results;
  }
}
public LifecycleListener[] findLifecycleListeners() {
    return listeners;
}
public void removeLifecycleListener(LifecycleListener listener) {
    synchronized (listenersLock) {
        int n = -1;
        for (int i = 0; i < listeners.length; i++) {
            if (listeners[i] == listener) {
                n = i;
                break;
            }
        }
        if (n < 0)
            return;
        LifecycleListener results[] = new LifecycleListener[listeners.length - 1];
        int j = 0;
        for (int i = 0; i < listeners.length; i++) {
            if (i != n)
                results[j++] = listeners[i];
        }
        listeners = results;
    }
}

​ LifecycleSupport中还定义了处理LifecycleEvent实践的fireLifecycleEvent方法，按事件的类型(组件的状态)创建了LifecycleEvent事件，然后遍历所有的监听器进行处理。

public void fireLifecycleEvent(String type, Object data) {
    LifecycleEvent event = new LifecycleEvent(lifecycle, type, data);
    LifecycleListener interested[] = listeners;
    for (int i = 0; i < interested.length; i++)
        interested[i].lifecycleEvent(event);
}

四个生命周期方法

​ 四个声明周期方法的实现首先判断当前的状态和要处理的方法是否匹配，不匹配就会执行相应方法使其匹配(在init之前调用start，start方法里检验状态等，还是会先执行init方法)，或不处理甚至抛出异常，如果匹配或者处理后匹配了，会调用相应的模版方法并设置相应的状态。

init方法

​ LifecycleBase中的状态是通过LifecycleState类型的state属性来保存的，最开始初始化值为NEW，如果不为NEW会调用invalidTransition方法抛出异常，其他三个方法也会这样

public final synchronized void init() throws LifecycleException {
    //最开始的值必须是NEW，否则会抛出异常
    if (!state.equals(LifecycleState.NEW)) {
        invalidTransition(Lifecycle.BEFORE_INIT_EVENT);
    }
    try {
      //初始化前将状态设置为INITALIZING
        setStateInternal(LifecycleState.INITIALIZING, null, false);
        initInternal();
      //初始化后将状态设置为INITALIZED
        setStateInternal(LifecycleState.INITIALIZED, null, false);
    } catch (Throwable t) {
        ExceptionUtils.handleThrowable(t);
        setStateInternal(LifecycleState.FAILED, null, false);
        throw new LifecycleException(
                sm.getString("lifecycleBase.initFail",toString()), t);
    }
}
start方法
1. 通过状态检查是否已经启动，已启动则打印日志并直接返回
2. 如果没有初始化则先进性初始化，如果启动失败则关闭，如果状态无法吹了则抛出异常
3. 启动前将状态设置为LifecycleState.STARTING_PREP
4. 调用模版方法启动组件
5. 启动失败将状态设置为FALLED并执行stop方法停止
6. 启动状态不是STARTED则抛出异常
7. 成功启动后将状态设置为STARTED

public final synchronized void start() throws LifecycleException {
    if (LifecycleState.STARTING_PREP.equals(state) || LifecycleState.STARTING.equals(state) ||
            LifecycleState.STARTED.equals(state)) {
        if (log.isDebugEnabled()) {
            Exception e = new LifecycleException();
            log.debug(sm.getString("lifecycleBase.alreadyStarted", toString()), e);
        } else if (log.isInfoEnabled()) {
            log.info(sm.getString("lifecycleBase.alreadyStarted", toString()));
        }
        return;
    }
    if (state.equals(LifecycleState.NEW)) {
        init();
    } else if (state.equals(LifecycleState.FAILED)) {
        stop();
    } else if (!state.equals(LifecycleState.INITIALIZED) &&
            !state.equals(LifecycleState.STOPPED)) {
        invalidTransition(Lifecycle.BEFORE_START_EVENT);
    }
    try {
        setStateInternal(LifecycleState.STARTING_PREP, null, false);
        startInternal();
        if (state.equals(LifecycleState.FAILED)) {
            stop();
        } else if (!state.equals(LifecycleState.STARTING)) {
            invalidTransition(Lifecycle.AFTER_START_EVENT);
        } else {
            setStateInternal(LifecycleState.STARTED, null, false);
        }
    } catch (Throwable t) {
        setStateInternal(LifecycleState.FAILED, null, false);
    }
}
stop方法
1. 通过状态检查是否已经关闭，已关闭则打印日志并直接返回
2. 如果是NEW状态，将当前state设置为STOPPED并返回
3. 如果状态不是STARTED也不是FAILED则抛出异常
4. 如果当前状态是FAILED则将当前标志为BEFORE_STOP_EVENT事件
5. 调用模版方法进行stop
6. 停止状态不是STOPPING和FAILED则抛出异常
7. 成功启动后将状态设置为STOPPED
8. finally里面执行destory方法

public final synchronized void stop() throws LifecycleException {
    if (LifecycleState.STOPPING_PREP.equals(state) || LifecycleState.STOPPING.equals(state) ||
            LifecycleState.STOPPED.equals(state)) {
        if (log.isDebugEnabled()) {
        } else if (log.isInfoEnabled()) {
        }
        return;
    }
    if (state.equals(LifecycleState.NEW)) {
        state = LifecycleState.STOPPED;
        return;
    }
    if (!state.equals(LifecycleState.STARTED) && !state.equals(LifecycleState.FAILED)) {
        invalidTransition(Lifecycle.BEFORE_STOP_EVENT);
    }
    try {
        if (state.equals(LifecycleState.FAILED)) {
            fireLifecycleEvent(BEFORE_STOP_EVENT, null);
        } else {
            setStateInternal(LifecycleState.STOPPING_PREP, null, false);
        }
        stopInternal();
        if (!state.equals(LifecycleState.STOPPING) && !state.equals(LifecycleState.FAILED)) {
            invalidTransition(Lifecycle.AFTER_STOP_EVENT);
        }
        setStateInternal(LifecycleState.STOPPED, null, false);
    } catch (Throwable t) {
        setStateInternal(LifecycleState.FAILED, null, false);
    } finally {
        if (this instanceof Lifecycle.SingleUse) {
            setStateInternal(LifecycleState.STOPPED, null, false);
            destroy();
        }
    }
}
destory方法
  1. 如果LifecycleState状态是FAILED则先执行stop方法
  2. 如果状态是DESTROYING或DESTROYED 记录日志并退出
  3. 如果状态不是STOPPED、FAILED、NEW、INITIALIZED 抛出异常
  4. 销毁前将状态设置为LifecycleState.DESTROYING
  5. 调用模版方法销毁组件
  6. 销毁后将状态设置为DESTROYED
public final synchronized void destroy() throws LifecycleException {
    if (LifecycleState.FAILED.equals(state)) {
        try {
            stop();
        } catch (LifecycleException e) {
        }
   
    if (!state.equals(LifecycleState.STOPPED) &&
            !state.equals(LifecycleState.FAILED) &&
            !state.equals(LifecycleState.NEW) &&
            !state.equals(LifecycleState.INITIALIZED)) {
        invalidTransition(Lifecycle.BEFORE_DESTROY_EVENT);
    }
    try {
        setStateInternal(LifecycleState.DESTROYING, null, false);
        destroyInternal();
        setStateInternal(LifecycleState.DESTROYED, null, false);
    } catch (Throwable t) {
        setStateInternal(LifecycleState.FAILED, null, false);
    }
}

setStateInternal()

该方法除了设置状态还检查设置的状态合不合逻辑，并在最后发布相应的事件

private synchronized void setStateInternal(LifecycleState state,
        Object data, boolean check) throws LifecycleException {
    if (log.isDebugEnabled()) {
        log.debug(sm.getString("lifecycleBase.setState", this, state));
    }
    if (check) {
        if (state == null) {
            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))) {
            invalidTransition(state.name());
        }
    }
    this.state = state;
    String lifecycleEvent = state.getLifecycleEvent();
    if (lifecycleEvent != null) {
        fireLifecycleEvent(lifecycleEvent, data);
    }
}

fireLifecycleEvent()

处理事件，该方法调用了LifecycleSupport的fireLifecycleEvent方法具体处理

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

invalidTransition()

负责抛出指定状态的异常

private void invalidTransition(String type) throws LifecycleException {
    String msg = sm.getString("lifecycleBase.invalidTransition", type,toString(), state);
    throw new LifecycleException(msg);
}

两个获取当前状态的方法

​ 在生命周期的相应方法已经将状态设置到了state属性，直接将state返回就可以

public LifecycleState getState() {
    return state;
}
@Override
public String getStateName() {
    return getState().toString();
}
tomcat生命周期的管理——生命周期统一接口Lifecycle
seaboat——a free boat on the sea.（公众号：远洋号）
11-04 4763
我们知道Tomcat的架构设计是清晰的、模块化的，其拥有很多组件，假如我们要启动Tomcat，可以一个一个启动组件，但这样启动有很多缺点，不仅麻烦，而且容易漏了组件启动，还会对后面动态组件扩展带来麻烦。难不成真要我们一个一个启动吗？其实未必，Tomcat的设计者提供了一个解决方案：用Lifecycle管理启动、停止、关闭。 从第一节的架构图可以看到各个核心组件有包含与被包含的关系，例如Ser
Java Tomcat内存马——Servlet内存马
m0_61506558的博客
11-27 629
Java Servlet 是运行在 Web 服务器或应用服务器上的程序，它是作为来自 Web 浏览器或其他 HTTP 客户端的请求和 HTTP 服务器上的数据库或应用程序之间的中间层。使用 Servlet，您可以收集来自网页表单的用户输入，呈现来自数据库或者其他源的记录，还可以动态创建网页。Java Servlet 通常情况下与使用 CGI（Common Gateway Interface，公共网关接口）实现的程序可以达到异曲同工的效果
Tomcat的生命周期
胡咧咧丶的博客
07-24 1649
目录   Lifecycle接口 Lifecycle接口一共做了4件事 LifecycleBase 三个管理监听器的方法 四个生命周期方法 init方法 start方法 两个获取当前状态的方法 Lifecycle接口 Tomcat通过org.apache.catalina.Lifecycle接口统一管理生命周期，所以所有生命周期的组件都要实现Lifecycle接口 Life...
面试官:既然启动流程不太了解，那你知道Tomcat的生命周期是什么样子的么？
十指波课堂的博客
01-13 300
序言Tomcat的生命周期管理的话，我们不能总是从书中获取那些知识，而是结合实践，然后综合书中的内容，进行一层一层的深入分析，这样对自己记忆和理解都能更加的透彻。启动的时候的大家可以随便找一个zip版本的Tomcat，然后直接启动起来，我们来看看是个什么样子的，一月 11, 2021 10:16:24 上午 org.apache.coyote.AbstractProtocol init 信息: I...
tomcat 容器生命周期lifecycle
08-12 166
1.复习java的事件机制 java事件机制包括三个部分：事件、事件监听器、事件源。 事件：一般继承自java.util.EventObject类，封装了事件源对象及跟事件相关的信息。 事件监听器：实现java.util.EventListener接口,注册在事件源上,当事件源的属性或状态改变时,取得相应的监听器调用其内部的回调方法。 事件源：事件发生的地方，由于事件源的某项属性...
【Tomcat】生命周期
u010900754的专栏
04-25 569
tomcat4.0版本。生命周期在tomcat中由lifecycle接口表征，容器需要实现这个生命周期接口，这样每一个容器就可以由父容器来掌管生命周期，由父容器启动和终止。public interface Lifecycle { // ----------------------------------------------------- Manifest Constants ...
tomcat生命周期
secret_killer的专栏
11-04 2312
本文转自：http://www.iteye.com/topic/694644 在之前的 Tomcat 整体架构中可以看到 Tomcat 包含多个很多个组件 , 今天我们来看看， Tomcat 是如何管理这些组件的生命周期的。 我们知道，组件与组件之间，必须建立起相互的关系，才能做到同时启动与停止。 Tomcat 内部，使用一个观察者模式来组织这些组件之间的关系。 我们来看看， Tomca
tomcat 生命周期，和事件管理—— lifeCycle & event
03-18
在描述中提到的InstanceSupport.edx文件可能是一个教学资源，可能包含了关于Tomcat生命周期和事件管理的详细讲解和实例。通常，这种类型的文件可能是教育平台如EdX上的课程资料，用于辅助学习者理解相关概念。 了解...
Tomcat源码解析——启动过程分析
jimoluoxue2016的博客
12-18 357
最近面试一些1~3年的开发人员，问他们tomcat的基础架构发现都是一脸懵逼，这里开贴大概写一下tomcat的整体架构以及启动流程，版本基于7.0.85，后续会不断对文章进行更新。 一、tomcat基础架构 上个图，这张图算是说的比较明白的。 大家可以去翻一下server.xml，精简后会发现如下结构： &lt;?xml version='1.0' encoding='utf-8'?...
Tomcat的生命周期管理简要分析
徐刘根的博客
12-27 7054
在上一篇文章中：Tomcat服务器顶层结构和启动过程 对Tomcat的整体架构有了一个大致的了解，这一篇主要是学习一下Tomcat的整个生命周期的管理。Tomcat的生命周期管理使用了观察者模式，使Tomcat的生命周期管理机制设计的非常优雅，在Tomcat启动时，只需要启动一个Server组件，就会启动所有的容器及对应的组件，并且触发这些容器的监听者，完成启动过程的设置。可以说是“一键式”启动的。
Tomcat的生命周期管理
Ashley的猫
02-17 570
今天总结Tomcat的LifeCycle机制。首先先说容器们都实现了的Lifecycle接口。这个接口来控制容器的生命周期。首先，它定义了六个生命周期的状态，BEFORE_START_EVENT，AFTER_START_EVENT，START_EVENT，STOP_EVENT，BEFORE_STOP_EVENT，AFTER_STOP_EVENT来管理容器的生命周期。而且它里面定义了两个很重要的方法
3. TOMCAT学习——TOMCAT的生命周期
程序猿的日常笔记
04-26 684
TOMCAT包含很多组件。这些组件需要跟随TOMCAT一起启动和关闭。如何达到这种目的呢？TOMCAT引入了生命周期的概念。 生命周相关的接口和类包括 1. org.apache.catalina.Lifecycle 2. org.apache.catalina.LifecycleListener 3. org.apache.catalina.LifecycleEvent 4. org.apac...
Tomcat-生命周期管理
dark
08-13 552
看透SpringMVC源码分析 Lifecycle接口 Tomcat通过org.apache.catalina.Lifecycle接口统一管理生命周期，所有有生命周期的组件都实现了Lifecycle接口。 Lifecycle一共做了四件事： 定义了13个String类型常量，用于LifecycleEvent事件的type属性中，作用是区分组件发出的LifecycleEve...
Tomcat源码篇-生命周期的架构设计
波波烤鸭的博客
02-25 1784
Tomcat生命周期   在上篇文章中我们看到了Tomcat架构中的核心组件，而且各个组件都有各自的作用，各司其职，而且相互之间也有对应的父子关系，那么这些对象的创建，调用，销毁等操作是怎么处理呢？   也就是在Tomcat中的组件的对象生命周期是怎么管理的呢？针对这个问题，在Tomcat中设计了Lifecycle接口来统一管理Tomcat中的核心组件的生命周期，所以本文我们就系统的来介绍下Lifecycle接口的设计 一、LifeCycle接口设计   为了统一管理Tomcat中的核心组件的生命周期，.
Tomcat第四篇——生命周期
搬砖小松鼠的博客
05-10 315
Lifecycle Tomcat中进行生命周期管理的接口是Lifecycle，Tomcat中的组件基本都继承了该接口。 下面来看看该接口中生命周期方法的定义： Lifecycle定义了四种生命周期状态：init、start、stop、destroy，并且提供了四个方法，并且在接口中定义了关于这四个状态多包含的一些事件，整个状态流转如下图： * The valid state transitions for components that support {@link Lifecycle} *
Tomcat生命周期
最新发布
qq_45128800的博客
07-03 189
tomcat中包含了很多组件：Server、Connector、Service、Engine、Host、Context等等这些组件的生命周期是怎么样设计的呢？
Tomcat生命周期（Tomcat源码阅读系列之三）
WoodyOilove
08-25 749
在本文我们将会从Tomcat的生命周期管理、Tomcat的启动过程、Tomcat的关闭过程三个方面对Tomcat的生命周期进行阐述。
Tomcat生命周期剖析
菜鸡旭旭
01-14 281
LifeStyle接口同一管理生命周期 它定义了13个常量类型 定义了3个管理监听器的方法 添加查找删除 定义了4个生命周期的方法 定义了两个获取当前状态的方法 // public interface Lifecycle { public static final String BEFORE_INIT_EVENT = “before_init”; public s
深入探讨Tomcat的生命周期和事件管理机制
理解Tomcat生命周期，特别是源码层面的实现，对于深入分析Tomcat的工作机制、进行故障排除或开发新的功能和组件是十分关键的。Lifecycle接口和相关的生命周期管理类在Tomcat源码中扮演着核心角色。 #### 使用Tomcat...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值