Tomcat源码解析：3、Tomcat生命周期Lifecycle

最新推荐文章于 2024-04-24 17:50:41 发布
最新推荐文章于 2024-04-24 17:50:41 发布
阅读量432 收藏
点赞数
分类专栏： Tomcat源码解析 Tomcat 文章标签： Tomcat Lifecycle Tomcat生命周期
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dk243553650/article/details/85286397
版权

Lifecycle

Lifecycle接口它是一个公用的接口，在Tomcat的组件中都直接或者间接的实现该类或者它的子类。所以它是一个非常重要的接口，定义了组件生命周期的一些方法，包括:init、start、stop、destroy，还有操作LifecycleListener的API，典型的观察者模式。所以它在Tomcat中起到了举足轻重的作用，熟悉它，对Tomcat的源码分析有非常大的帮助


public interface Lifecycle {


    // ----------------------------------------------------- Manifest Constants

	 // 各种Event事件说明
    public static final String BEFORE_INIT_EVENT = "before_init";


    public static final String AFTER_INIT_EVENT = "after_init";


    public static final String START_EVENT = "start";


    public static final String BEFORE_START_EVENT = "before_start";


    // 省略其他的事件。。。



	/**
	 * 注册一个LifecycleListener观察者	 
	 */
    public void addLifecycleListener(LifecycleListener listener);

	/**
	 * 获取所有注册的LifecycleListener
	 */	
    public LifecycleListener[] findLifecycleListeners();

	/**
	 * 移除指定的LifecycleListener
	 */
    public void removeLifecycleListener(LifecycleListener listener);
	
	/**
	 * 主键初始化方法
	 */
    public void init() throws LifecycleException;

	/**
	 * 主键开始加载方法
	 */
    public void start() throws LifecycleException;
	
	/**
	 * 主键停止方法
	 */
    public void stop() throws LifecycleException;

	/**
	 * 主键销毁方法
	 */
    public void destroy() throws LifecycleException;

    public LifecycleState getState();

	/**
	 * 获取state的文字说明
	 */
    public String getStateName();


    public interface SingleUse {
    }
}

Lifecycle主要子类

下面我们来看一下Lifecycle的主要子类：
在这里插入图片描述

LifecycleBase：它是Lifecycle的子类，它主要实现了Lifecycle的init、start、stop、destroy等一些通用的逻辑，向注册在LifecycleBase内部的LifecycleListener发出对应的事件，并且提供了initInternal、startInternal、stopInternal、destroyInternal模板方法，便于子类实现

LifecycleMBeanBase：通过重写了initInternal、destroyInternal方法，向JMX注册或者取消当前的实例。Tomcat提供了JMX进行实例管理，但是代码上强制子类调用super.initInternal

StandardServer、StandardService、Connector等容器都继承了LifecycleMBeanBase，上面截的图不太完整，所以这些容器都具有了生命周期并且可以通过JMX进行管理

下面简单介绍了LifecycleBase和LifecycleMBeanBase方法

LifecycleBase

在看LifecycleBase之前，我们首先了解下LifecycleState，定义了Lifecycle的各种状态和对应的事件

public enum LifecycleState {
	/*
	 * Lifecycle实例化完成时的状态
	 */
    NEW(false, null),
    /*
	 * Lifecycle正在初始化的状态
	 */
    INITIALIZING(false, Lifecycle.BEFORE_INIT_EVENT),
    /*
	 * Lifecycle初始化完成的状态
	 */
    INITIALIZED(false, Lifecycle.AFTER_INIT_EVENT),
    /*
	 * Lifecycle启动前的状态
	 */
    STARTING_PREP(false, Lifecycle.BEFORE_START_EVENT),
    /*
	 * Lifecycle启动中的状态
	 */
    STARTING(true, Lifecycle.START_EVENT),
    /*
	 * Lifecycle启动完成的状态
	 */
    STARTED(true, Lifecycle.AFTER_START_EVENT),
    /*
	 * Lifecycle停止前的状态
	 */
    STOPPING_PREP(true, Lifecycle.BEFORE_STOP_EVENT),
    /*
	 * Lifecycle停止中的状态
	 */
    STOPPING(false, Lifecycle.STOP_EVENT),
    /*
	 * Lifecycle停止完成的状态
	 */
    STOPPED(false, Lifecycle.AFTER_STOP_EVENT),
    /*
	 * Lifecycle销毁中的状态
	 */
    DESTROYING(false, Lifecycle.BEFORE_DESTROY_EVENT),
    /*
	 * Lifecycle销毁完成的状态
	 */
    DESTROYED(false, Lifecycle.AFTER_DESTROY_EVENT),
    /*
	 * Lifecycle启动、停止过程中出现异常
	 */
    FAILED(false, null),
    @Deprecated
    MUST_STOP(true, null),
    @Deprecated
    MUST_DESTROY(false, null);

    private final boolean available;
    private final String lifecycleEvent;

    private LifecycleState(boolean available, String lifecycleEvent) {
        this.available = available;
        this.lifecycleEvent = lifecycleEvent;
    }
    public boolean isAvailable() {
        return available;
    }

    public String getLifecycleEvent() {
        return lifecycleEvent;
    }
}

public abstract class LifecycleBase implements Lifecycle {

    private static final Log log = LogFactory.getLog(LifecycleBase.class);

    private static final StringManager sm =
        StringManager.getManager("org.apache.catalina.util");

	/**
	 * 存储LifecycleListener的容器，里面封装了一个List集合，因为存在并发操做
	 * 所以使用了CopyOnWriteArrayList
	 * List<LifecycleListener> listeners = new CopyOnWriteArrayList<>();
	 */
    private final LifecycleSupport lifecycle = new LifecycleSupport(this);

    private volatile LifecycleState state = LifecycleState.NEW;

	/*
	 * 注册一个LifecycleListener
	 */
    @Override
    public void addLifecycleListener(LifecycleListener listener) {
        lifecycle.addLifecycleListener(listener);
    }	
    
	/*
	 * 获取注册的所有LifecycleListener
	 */
    @Override
    public LifecycleListener[] findLifecycleListeners() {
        return lifecycle.findLifecycleListeners();
    }

	/*
	 * 移除指定的LifecycleListener
	 */
    @Override
    public void removeLifecycleListener(LifecycleListener listener) {
        lifecycle.removeLifecycleListener(listener);
    }
    
	/*
	 * 触发事件，通知所有的LifecycleListener
	 */
    protected void fireLifecycleEvent(String type, Object data) {
        lifecycle.fireLifecycleEvent(type, data);
    }

	/*
	 * 设置state状态，不传数据，实际调用的是setStateInternal，第三个参数为true，表示需要校验state合法规则
	 * 这里使用了synchronized，因为可能存在并发操作
	 */
	protected synchronized void setState(LifecycleState state)
            throws LifecycleException {
        setStateInternal(state, null, true);
    }

	
	/*
	 * 设置state状态，并且传数据，实际调用的是setStateInternal，第三个参数为true，表示需要校验state合法规则
	 * 这里使用了synchronized，因为可能存在并发操作
	 */
    protected synchronized void setState(LifecycleState state, Object data)
            throws LifecycleException {
        setStateInternal(state, data, true);
    }
	
	/*
	 * 真正修改state状态的方法
	 */
    private synchronized void setStateInternal(LifecycleState state,
            Object data, boolean check) throws LifecycleException {

        if (log.isDebugEnabled()) {
            log.debug(sm.getString("lifecycleBase.setState", this, state));
        }
		
		 /*
		  * 如果check为true，则需要校验state是否合法
		  */
        if (check) {
            /*
             * 如果设置的state为Null，抛出异常
             */
            if (state == null) {
                invalidTransition("null");
                return;
            }
            
            /*
             * 下面是state合法校验规则
             * 出现下面一种情况都会调用invalidTransition抛出异常
             * 1、如果当前state是LifecycleState.STARTING_PREP,那么修改的state一定要是LifecycleState.STARTING,要不抛出异常
             * 2、如果当前state是LifecycleState.STOPPING_PREP，那么修改的state一定要是 LifecycleState.STOPPING，要不抛出异常
             * 3、如果当前state是LifecycleState.FAILED，那么修改的state一定是LifecycleState.STOPPING，要不抛出异常               
             */
            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());
            }
        }
		 // 设置修改的state
        this.state = state;
        // 获取state的事件描述
        String lifecycleEvent = state.getLifecycleEvent();
        if (lifecycleEvent != null) {
        	  // 触发lifecycleEvent事件，并且通知所有注册的监听者
            fireLifecycleEvent(lifecycleEvent, data);
        }
    }

	
	/*
	 * 初始化方法
	 */
    @Override
    public final synchronized void init() throws LifecycleException {    
        /*
         * 如果当前state不是LifecycleState.NEW，则调用invalidTransition抛出异常
         */  	 
        if (!state.equals(LifecycleState.NEW)) {
            invalidTransition(Lifecycle.BEFORE_INIT_EVENT);
        }
  
        try {
        	  /*
        	   * 调用setStateInternal修改state为LifecycleState.INITIALIZING
        	   * 并且第三个参数为false，则不需要校验state合法规则，之前setStateInternal有说过     	  
        	   */
            setStateInternal(LifecycleState.INITIALIZING, null, false);
            /*
             * 调用initInternal模板方法，这个由子类实现
             */
            initInternal();
            /*
        	   * 调用setStateInternal修改state为LifecycleState.INITIALIZED
        	   * 并且第三个参数为false，则不需要校验state合法规则，之前setStateInternal有说过     	  
        	   */
            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);
        }
    }

	/*
	 * initInternal模板方法，由子类实现
	 */
    protected abstract void initInternal() throws LifecycleException;


	/*
	 * 启动方法
	 */
    @Override
    public final synchronized void start() throws LifecycleException {
		
		 /*
		  * 如果当前state是
		  * LifecycleState.STARTING_PREP、LifecycleState.STARTING、LifecycleState.STARTED，
		  * 说明已经启动过了，那么直接抛出异常
		  */
        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;
        }
		
		 /*
		  * 如果当前state是LifecycleState.NEW，那么调用 init();
		  */
        if (state.equals(LifecycleState.NEW)) {
            init();
        /*
		  * 如果当前state是LifecycleState.FAILED，那么调用 stop();
		  */
        } else if (state.equals(LifecycleState.FAILED)) {
            stop();
        /*
		  * 如果当前state不是LifecycleState.INITIALIZED或者LifecycleState.STOPPED，则直接抛出异常
		  */
        } else if (!state.equals(LifecycleState.INITIALIZED) &&
                !state.equals(LifecycleState.STOPPED)) {
            invalidTransition(Lifecycle.BEFORE_START_EVENT);
        }

        try {
			 /*
        	  * 调用setStateInternal修改state为LifecycleState.STARTING_PREP
        	  * 并且第三个参数为false，则不需要校验state合法规则，之前setStateInternal有说过     	  
        	  */
            setStateInternal(LifecycleState.STARTING_PREP, null, false);
            /*
             * 调用startInternal模板方法
             */
            startInternal();
            /*
             * 如果调用startInternal后，state为LifecycleState.FAILED
             * 那么调用stop();
             */
            if (state.equals(LifecycleState.FAILED)) {
                // This is a 'controlled' failure. The component put itself into the
                // FAILED state so call stop() to complete the clean-up.
                stop();
            /*
             * 如果调用startInternal后，
             * state不是LifecycleState.STARTING
             * 那么调用 invalidTransition抛出异常，            
             */
            } else if (!state.equals(LifecycleState.STARTING)) {
                // Shouldn't be necessary but acts as a check that sub-classes are
                // doing what they are supposed to.
                invalidTransition(Lifecycle.AFTER_START_EVENT);
                /*                
                 *  如果调用startInternal后，
                 *  state是LifecycleState.STARTING，
             	   *  那么调用setStateInternal(LifecycleState.STARTED, null, false);
                 */
            } else {
                setStateInternal(LifecycleState.STARTED, null, false);
            }
        } catch (Throwable t) {
            // This is an 'uncontrolled' failure so put the component into the
            // FAILED state and throw an exception.
            ExceptionUtils.handleThrowable(t);
            setStateInternal(LifecycleState.FAILED, null, false);
            throw new LifecycleException(sm.getString("lifecycleBase.startFail", toString()), t);
        }
    }

    /*
     *startInternal模板方法
     */
    protected abstract void startInternal() throws LifecycleException;

	/*
	 * 停止方法，逻辑跟start()差不多，就不分析了
	 */
    @Override
    public final synchronized void stop() throws LifecycleException {

        if (LifecycleState.STOPPING_PREP.equals(state) || LifecycleState.STOPPING.equals(state) ||
                LifecycleState.STOPPED.equals(state)) {

            if (log.isDebugEnabled()) {
                Exception e = new LifecycleException();
                log.debug(sm.getString("lifecycleBase.alreadyStopped", toString()), e);
            } else if (log.isInfoEnabled()) {
                log.info(sm.getString("lifecycleBase.alreadyStopped", toString()));
            }

            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)) {
                // Don't transition to STOPPING_PREP as that would briefly mark the
                // component as available but do ensure the BEFORE_STOP_EVENT is
                // fired
                fireLifecycleEvent(BEFORE_STOP_EVENT, null);
            } else {
                setStateInternal(LifecycleState.STOPPING_PREP, null, false);
            }

            stopInternal();

            // Shouldn't be necessary but acts as a check that sub-classes are
            // doing what they are supposed to.
            if (!state.equals(LifecycleState.STOPPING) && !state.equals(LifecycleState.FAILED)) {
                invalidTransition(Lifecycle.AFTER_STOP_EVENT);
            }

            setStateInternal(LifecycleState.STOPPED, null, false);
        } catch (Throwable t) {
            ExceptionUtils.handleThrowable(t);
            setStateInternal(LifecycleState.FAILED, null, false);
            throw new LifecycleException(sm.getString("lifecycleBase.stopFail",toString()), t);
        } finally {
            if (this instanceof Lifecycle.SingleUse) {
                // Complete stop process first
                setStateInternal(LifecycleState.STOPPED, null, false);
                destroy();
            }
        }
    }


    protected abstract void stopInternal() throws LifecycleException;

	
	/*
	 * 销毁方法，逻辑跟start()差不多，就不分析了
	 */
    @Override
    public final synchronized void destroy() throws LifecycleException {
        if (LifecycleState.FAILED.equals(state)) {
            try {
                // Triggers clean-up
                stop();
            } catch (LifecycleException e) {
                // Just log. Still want to destroy.
                log.warn(sm.getString(
                        "lifecycleBase.destroyStopFail", toString()), e);
            }
        }

        if (LifecycleState.DESTROYING.equals(state) ||
                LifecycleState.DESTROYED.equals(state)) {

            if (log.isDebugEnabled()) {
                Exception e = new LifecycleException();
                log.debug(sm.getString("lifecycleBase.alreadyDestroyed", toString()), e);
            } else if (log.isInfoEnabled() && !(this instanceof Lifecycle.SingleUse)) {
                // Rather than have every component that might need to call
                // destroy() check for SingleUse, don't log an info message if
                // multiple calls are made to destroy()
                log.info(sm.getString("lifecycleBase.alreadyDestroyed", toString()));
            }

            return;
        }

        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) {
            ExceptionUtils.handleThrowable(t);
            setStateInternal(LifecycleState.FAILED, null, false);
            throw new LifecycleException(
                    sm.getString("lifecycleBase.destroyFail",toString()), t);
        }
    }


    protected abstract void destroyInternal() throws LifecycleException;

    /**
     * {@inheritDoc}
     */
    @Override
    public LifecycleState getState() {
        return state;
    }


    /**
     * {@inheritDoc}
     */
    @Override
    public String getStateName() {
        return getState().toString();
    }


    
}

整个init、start、stop、destroy方法state状态改变顺序，可以看下Lifecycle接口里有个官方注释

 *            start()
 *  -----------------------------
 *  |                           |
 *  | init()                    |
 * NEW -»-- INITIALIZING        |
 * | |           |              |     ------------------«-----------------------
 * | |           |auto          |     |                                        |
 * | |          \|/    start() \|/   \|/     auto          auto         stop() |
 * | |      INITIALIZED --»-- STARTING_PREP --»- STARTING --»- STARTED --»---  |
 * | |         |                                                            |  |
 * | |destroy()|                                                            |  |
 * | --»-----«--    ------------------------«--------------------------------  ^
 * |     |          |                                                          |
 * |     |         \|/          auto                 auto              start() |
 * |     |     STOPPING_PREP ----»---- STOPPING ------»----- STOPPED -----»-----
 * |    \|/                               ^                     |  ^
 * |     |               stop()           |                     |  |
 * |     |       --------------------------                     |  |
 * |     |       |                                              |  |
 * |     |       |    destroy()                       destroy() |  |
 * |     |    FAILED ----»------ DESTROYING ---«-----------------  |
 * |     |                        ^     |                          |
 * |     |     destroy()          |     |auto                      |
 * |     --------»-----------------    \|/                         |
 * |                                 DESTROYED                     |
 * |                                                               |
 * |                            stop()                             |
 * ----»-----------------------------»------------------------------

LifecycleMBeanBase

继承了LifecycleBase类，实现了initInternal和destroyInternal方法，提供子类统一注册JMX实例的方法，所以代码上强制子类调用super.initInternal往JMX中注册实例。

public abstract class LifecycleMBeanBase extends LifecycleBase
        implements JmxEnabled {

    private ObjectName oname = null;
    protected MBeanServer mserver = null;

    @Override
    protected void initInternal() throws LifecycleException {

        // If oname is not null then registration has already happened via
        // preRegister().
        if (oname == null) {
            mserver = Registry.getRegistry(null, null).getMBeanServer();

            oname = register(this, getObjectNameKeyProperties());
        }
    }
    @Override
    protected void destroyInternal() throws LifecycleException {
        unregister(oname);
    }
	
	/*
	 * 模板方法，子类注册到JMX的实例名称
	 */
    protected abstract String getObjectNameKeyProperties();
	
	// 省略其他的方法

}
dk2077
关注
专栏目录
Tomcat 8（九）解读Tomcat组件的生命周期(Lifecycle)
flyliuweisky547的专栏
04-24 4382
Tomcat 8（七）解读Bootstrap介绍过，执行startup.bat，将引发Tomcat一连串组件的启动。其实这一连串启动是通过组件的生命周期(Lifecycle)实现的 今天来看看Lifecycle设计。解读Lifecycle，涉及到如下几个类 Lifecycle、LifecycleState、LifecycleEvent、LifecycleListener(位于org.apach
Tomcat中Lifecycle详解（源码阅读）
fj_ding的专栏
05-06 2266
在tomcat中，每一个组件生命周期都是需要统一管理的，一般是由调用该组件的组件来启动或停止当前组建，如connector组件控制processor组件启动和停止，因此每个组件主要类都会继承Lifecycle接口。tomcat中周期控制采用观察者模式来设计。
TOMCAT-生命周期模型：Lifecycle
在路上
12-13 225
TOMCAT是基于容器进行构建的，所有容器的基础为：Lifecycle， 其中继承关系如下： Lifecycle的启动流程如下： init状态，start状态，stop状态，destroy状态，每个状态都有对应的监听事件， init状态对应的监听事件为：BEFORE_INIT_EVENT，AFTER_INIT_EVENT start状态对应的监听事件为：START_EVEN...
tomcat之LifeCycle
qq_32868023的博客
10-19 190
tomcat里几乎所有组件都实现了LifeCycle接口，例如Server、Service、Connector、Executor、Engine、Host、Context、Wrapper LifeCycle接口定义了这些组件的声明周期管理，包括四个声明周期方法与一系列的状态
Tomcat中Lifecycle
weixin_30556959的博客
05-04 142
LifeCycle 节选部分源码、源码版本 Tomcat8.5 作用 ​ 组件生命周期方法的通用接口。 Catalina组件可以实现此接口（以及它们支持的功能的适当接口），以便提供一致的机制来启动和停止组件 状态图 接口定义 public interface Lifecycle { // 13个状态常量值 public static final String BEFORE_I...
Tomcat源码解析：Server与Service的生命周期
生命周期管理是Tomcat设计的重要部分，体现在Lifecycle接口上。这个接口规定了启动、停止、关闭等操作，确保所有组件能统一、有序地执行这些动作。同时，对于监控管理，Tomcat利用MBeanRegistration实现了JMX（Java ...
Tomcat源码解析：组件架构与JMX
每个组件都实现了Lifecycle接口，当组件经历启动、停止、暂停和恢复等生命周期状态变化时，会触发LifecycleEvent，允许其他模块通过注册监听器来响应这些事件，进行相应的处理。 关键类的职责如下： - **Catalina*...
Tomcat源码解析(三)：LifeCycle生命周期管理
从基础到源码解析的学习记录
03-05 1941
在前文中我们介绍了tomcat的启动类加载核心内容就是getServer().init()组件的初始化和getServer().start()启动服务由于所有的组件均存在初始化启动停止等生命周期方法，拥有生命周期管理的特性基于生命周期管理抽象成了一个接口Lifecycle组件Server、Service、Container、Executor、Connector组件，都实现生命周期的接口监听器处理生命周期方法生命周期状态。
tomcat源码解析
01-20
### tomcat源码解析 #### 简介与概览 Tomcat作为一款开源的Servlet容器，被广泛应用于Java Web应用的开发与部署环境中。它不仅支持Servlet API，还支持JSP规范，使得开发者能够轻松地构建动态网页。本文旨在深入...
Tomcat源码| 生命周期相关Lifecycle
YvesHe的专栏
08-27 144
package org.apache.catalina; //定义用于重大事件（包括由实现Lifecycle接口的组件生成的“组件开始”和“组件停止”）的侦听器的接口。 //在发生关联的状态更改后，将触发该侦听器。 public interface LifecycleListener { //确定指定时间的发生 //event: 发生的LifecycleEvent public void lifecycleEvent(LifecycleEvent event); } ...
Tomcat的生命周期管理
benewu的专栏
12-02 179
Servlet规范中定义了一个Servlet的生命周期， Tomcat使用事件方式管理Servlet的生命周期。 Tomcat定义了一个Lifecycle接口统一管理在容器内发生的所有事件。 [img]http://www.iteye.com/topics/download/9631d8bc-7053-4b1b-afad-7e8e0f973596[/img] Lifecycle接定...
tomcat 容器生命周期lifecycle
08-12 137
1.复习java的事件机制 java事件机制包括三个部分：事件、事件监听器、事件源。 事件：一般继承自java.util.EventObject类，封装了事件源对象及跟事件相关的信息。 事件监听器：实现java.util.EventListener接口,注册在事件源上,当事件源的属性或状态改变时,取得相应的监听器调用其内部的回调方法。 事件源：事件发生的地方，由于事件源的某项属性...
Tomcat Lifecycle
看风人Z的博客
02-20 625
Catalina 由多个组件组成，当 Catalina 启动的时候，这些组件也会启动。当Catalina 停止的时候，这些组件也必须有机会被清除。例如，当一个容器停止工作的时候，它必须唤醒所有加载的 servlet 的 destroy 方法，而 session 管理器要保存 session 到二级存储器中。保持组件启动和停止一致的的机制通过实现org.apache.catalina.Lifecyc...
tomcat lifecycle
flyingzc的博客
12-19 200
LifeCycle LifeCycle 相关类 LifeCycle 接口中的状态扭转注释,如下: * start() * ----------------------------- * | | * | init() | * NEW -»-- INITIALIZING ...
Tomcat源码解析系列一：Tomcat的整体架构
Running666的博客
05-21 943
Acceptor接收到请求封装成一个SocketProcessor扔进线程池Executor后，会调用Processor从操作系统底层读取、过滤字节流，对应用层协议（HTTP/AJP）进行解析封装，生成org.apache.coyote.Request和org.apache.coyote.Response对象。[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8bARZsoh-1684648768857)(assets/image-20220719102639459.png)]
Tomcat源码分析 （三）----- 生命周期机制 Lifecycle
最新发布
smart_an的专栏
04-24 703
Lifecycle，其实就是一个状态机，对组件的由生到死状态的管理。当组件在STARTING或STARTED时，调用start()方法没有任何效果当组件在NEW状态时，调用start()方法会导致init()方法被立刻执行，随后start()方法被执行当组件在STOPPING或STOPPED时，调用stop()方法没有任何效果当一个组件在NEW状态时，调用stop()方法会将组件状态变更为STOPPED，比较典型的场景就是组件启动失败，其子组件还没有启动。
Tomcat生命周期
qq_45128800的博客
07-03 166
tomcat中包含了很多组件：Server、Connector、Service、Engine、Host、Context等等这些组件的生命周期是怎么样设计的呢？
tomcat生命周期
secret_killer的专栏
11-04 2280
本文转自：http://www.iteye.com/topic/694644 在之前的 Tomcat 整体架构中可以看到 Tomcat 包含多个很多个组件 , 今天我们来看看， Tomcat 是如何管理这些组件的生命周期的。 我们知道，组件与组件之间，必须建立起相互的关系，才能做到同时启动与停止。 Tomcat 内部，使用一个观察者模式来组织这些组件之间的关系。 我们来看看， Tomca
Tomcat的生命周期
胡咧咧丶的博客
07-24 1618
目录   Lifecycle接口 Lifecycle接口一共做了4件事 LifecycleBase 三个管理监听器的方法 四个生命周期方法 init方法 start方法 两个获取当前状态的方法 Lifecycle接口 Tomcat通过org.apache.catalina.Lifecycle接口统一管理生命周期，所以所有生命周期的组件都要实现Lifecycle接口 Life...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值