关于java:你可能不那么知道的Tomcat生命周期管理-博学谷狂野架构师

Tomcat生命周期治理

各种组件如何对立治理

Tomcat的架构设计是清晰的、模块化、它领有很多组件，退出在启动Tomcat时一个一个组件启动，很容易脱漏组件，同时还会对前面的动静组件拓展带来麻烦。如果采纳咱们传统的形式的话，组件在启动过程中如果产生异样，会很难治理，比方你的下一个组件调用了start办法，然而如果它的下级组件还没有start甚至还没有init的话，Tomcat的启动会十分难治理，因而，Tomcat的设计者提出一个解决方案：用Lifecycle治理启动，进行、敞开。

生命周期对立接口

Tomcat外部架构中各个外围组件有蕴含与被蕴含关系，例如：Server蕴含了Service.Service又蕴含了Container和Connector,这个构造有一点像数据结构中的树，树的根结点没有父节点，其余节点有且仅有一个父节点，每一个父节点有0至多个子节点。所以，咱们能够通过父容器启动它的子容器，这样只有启动根容器，就能够把其余所有的容器都启动，从而达到了对立的启动，进行、敞开的成果。

所有所有组件有一个对立的接口——Lifecycle,把所有的启动、进行、敞开、生命周期相干的办法都组织到一起，就能够很方便管理Tomcat各个容器组件的生命周期。

Lifecycle其实就是定义了一些状态常量和几个办法，次要办法是init,start,stop三个办法。

例如：Tomcat的Server组件的init负责遍历调用其蕴含所有的Service组件的init办法。

留神：Server只是一个接口，实现类为StandardServer,有意思的是，StandardServer没有init办法，init办法是在哪里，其实是在它的父类LifecycleBase中，这个类就是对立的生命周期治理。

COPYpublic class StandardService extends LifecycleMBeanBase implements Service
    
public abstract class LifecycleMBeanBase extends LifecycleBase
        implements JmxEnabled

LifecycleBase

COPYpublic abstract class LifecycleBase implements Lifecycle {
      @Override
    public final synchronized void init() throws LifecycleException {
        //这个就是为了避免 组件启动的程序不对
        if (!state.equals(LifecycleState.NEW)) {
            invalidTransition(Lifecycle.BEFORE_INIT_EVENT);
        }

        try {
            //只打印外围组件
            if(this.getClass().getName().startsWith("org.apache.catalina.core")||this.getClass().getName().startsWith("org.apache.catalina.connector")){
                System.out.println(this.getClass()+"--init()");
            }
            setStateInternal(LifecycleState.INITIALIZING, null, false);
            //调用子类的initInternal办法
            initInternal();
            setStateInternal(LifecycleState.INITIALIZED, null, false);
        } catch (Throwable t) {
            handleSubClassException(t, "lifecycleBase.initFail", toString());
        }
    }
   
}

所以StandardServer最终只会调用到initInternal办法，这个办法会初始化子容器Service的init办法

为什么LifecycleBase这么玩，其实很多架构源码都是这么玩的，包含JDK的容器源码都是这么玩的，一个类，有一个接口，同时形象一个形象骨架类，把通用的实现放在形象骨架类中，这样设计就不便组件的治理，应用LifecycleBase骨架抽象类，在形象办法中就能够进行对立的解决。

LifeCycle源码剖析

作用

组件生命周期办法的通用接口。 Catalina组件能够实现此接口（以及它们反对的性能的适当接口），以便提供统一的机制来启动和进行组件

状态图

Tomcat中的事件触发是通过这些状态来断定的。

COPY*            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()                             |
 * ----»-----------------------------»------------------------------

接口定义

Lifecycle接口对立治理Tomcat生命周期。一共做了4件事：

定义13个string类型常量，用于LifecycleEvent工夫的type属性中，用于辨别组件收回的LifecycleEvent事件时的状态。
定义三个治理监听器的办法，addLifecycleListener、findLifecycleListeners、removeLifecycleListener。
定义4个生命周期的办法，init、start、stop、destory，用于执行生命周期的各个阶段的操作。
定义了获取以后状态的两个办法，getState、getStateName、用于获取以后的状态。

COPYpublic interface Lifecycle {
    // 13个状态常量值
    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";
    public static final String AFTER_START_EVENT = "after_start";
    public static final String STOP_EVENT = "stop";
    public static final String BEFORE_STOP_EVENT = "before_stop";
    public static final String AFTER_STOP_EVENT = "after_stop";
    public static final String AFTER_DESTROY_EVENT = "after_destroy";
    public static final String BEFORE_DESTROY_EVENT = "before_destroy";
    public static final String PERIODIC_EVENT = "periodic";
    public static final String CONFIGURE_START_EVENT = "configure_start";
    public static final String CONFIGURE_STOP_EVENT = "configure_stop";
    // 3个监听器办法
    public void addLifecycleListener(LifecycleListener listener);
    public LifecycleListener[] findLifecycleListeners();
    public void removeLifecycleListener(LifecycleListener listener);
    // 4个生命周期办法
    public void init() throws LifecycleException;
    public void start() throws LifecycleException;
    public void stop() throws LifecycleException;
    public void destroy() throws LifecycleException;
    // 2个以后状态办法
    public LifecycleState getState();
    public String getStateName();
}

默认实现类

COPYpublic abstract class LifecycleBase implements Lifecycle {
    // 源组件的以后状态,不同状态触发不同事件
    private volatile LifecycleState state = LifecycleState.NEW;
}

监听器相干办法

事件监听器须要三个参与者：

事件对象：用于封装事件的信息，在事件监听器接口的同一办法中作为参数应用，继承自java.util.EventObject类。
事件源：触发事件的源头，不同事件源触发不同事件类型。
事件监听器：负责监听事件源收回的事件。实现 java.util.EventListener 接口。

COPY// 用于事件告诉的已注册LifecycleListener列表
private final List<LifecycleListener> lifecycleListeners = 
    new CopyOnWriteArrayList<>();

@Override
public void addLifecycleListener(LifecycleListener listener) {
    lifecycleListeners.add(listener);
}

@Override
public LifecycleListener[] findLifecycleListeners() {
    return lifecycleListeners.toArray(new LifecycleListener[0]);
}

@Override
public void removeLifecycleListener(LifecycleListener listener) {
    lifecycleListeners.remove(listener);
}

// 子类依据以后状态触发不同事件，实现不同操作
protected void fireLifecycleEvent(String type, Object data) {
    LifecycleEvent event = new LifecycleEvent(this, type, data);
    for (LifecycleListener listener : lifecycleListeners) {
        listener.lifecycleEvent(event);
    }
}

生命周期办法

LifecycleBase 类是Lifecycle 接口的默认实现，所有实现了生命周期的组件都间接或者间接的继承自LifecycleBase。

init办法

COPY@Override
public final synchronized void init() throws LifecycleException {
    // 只有 NEW 状态能够调用
    if (!state.equals(LifecycleState.NEW)) {
        invalidTransition(Lifecycle.BEFORE_INIT_EVENT);
    }
    // 设置 生命周期状态 -- INITIALIZING，触发相应事件
    setStateInternal(LifecycleState.INITIALIZING, null, false);
    // 模板办法，由具体子类实现
    initInternal();
    // 执行实现，设置生命周期状态 -- INITIALIZED，触发相应事件
    setStateInternal(LifecycleState.INITIALIZED, null, false);
}

Start办法

COPY@Override
public final synchronized void start() throws LifecycleException {
    // 此三种状态不执行
    if (LifecycleState.STARTING_PREP.equals(state) ||      
        LifecycleState.STARTING.equals(state) ||
        LifecycleState.STARTED.equals(state)) {
        return;
    }
    // NEW 状态 执行 init 办法
    if (state.equals(LifecycleState.NEW)) {
        init();
    // 启动失败，调用 stop 办法
    } else if (state.equals(LifecycleState.FAILED)) {
        stop();
    // 其它状态，非法操作
    } else if (!state.equals(LifecycleState.INITIALIZED) &&
            !state.equals(LifecycleState.STOPPED)) {
        throw new LifecycleException()
    }
    // 设置启动状态为 STARTING_PREP【开始筹备】
    setStateInternal(LifecycleState.STARTING_PREP, null, false);
    startInternal();
    // 调用实现后判断组件启动状态
    if (state.equals(LifecycleState.FAILED)) {
        stop();
    } else if (!state.equals(LifecycleState.STARTING)) {
        throw new LifecycleException();
    } else {
        setStateInternal(LifecycleState.STARTED, null, false);
    }
}

stop办法

COPY@Override
public final synchronized void stop() throws LifecycleException {
    // STOPPING_PREP、STOPPING、STOPPED此三种状态不予执行
    if (LifecycleState.STOPPING_PREP.equals(state) || 
        LifecycleState.STOPPING.equals(state) ||
        LifecycleState.STOPPED.equals(state)) {
        return;
    }
    // 如果状态为 NEW、批改为 STOPPED
    if (state.equals(LifecycleState.NEW)) {
        state = LifecycleState.STOPPED;
        return;
    }
    // 不为 STARTED、FAILED 2种状态，抛出异样
    if (!state.equals(LifecycleState.STARTED) && 
        !state.equals(LifecycleState.FAILED)) {
        throw new LifecycleException();
    }
    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)) {
            throw new LifecycleException();
        }
        setStateInternal(LifecycleState.STOPPED, null, false);
    } catch (Throwable t) {
        setStateInternal(LifecycleState.FAILED, null, false);
        throw new LifecycleException();
    } finally {
        if (this instanceof Lifecycle.SingleUse) {
            setStateInternal(LifecycleState.STOPPED, null, false);
            destroy();
        }
    }
}

destroy办法

COPY@Override
public final synchronized void destroy() throws LifecycleException {
    // 启动失败，先调用 stop 办法
    if (LifecycleState.FAILED.equals(state)) {
        stop();
    }
    // DESTROYING、DESTROYED不执行了
    if (LifecycleState.DESTROYING.equals(state) ||
        LifecycleState.DESTROYED.equals(state)) {
        return;
    }
    // 非法状态
    if (!state.equals(LifecycleState.STOPPED) &&
        !state.equals(LifecycleState.FAILED) &&
        !state.equals(LifecycleState.NEW) &&
        !state.equals(LifecycleState.INITIALIZED)) {
        throw new LifecycleException();
    }

    try {
        setStateInternal(LifecycleState.DESTROYING, null, false);
        destroyInternal();
        setStateInternal(LifecycleState.DESTROYED, null, false);
    } catch (Throwable t) {
        setStateInternal(LifecycleState.FAILED, null, false);
        throw new LifecycleException();
    }
}

设置状态办法

COPYprivate synchronized void setStateInternal(LifecycleState state,
        Object data, boolean check) throws LifecycleException {

    // 查看参数
    if (check) {
        if (state == null) {
            throw new LifecycleException();
            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))) {
            throw new LifecycleException();
        }
    }
    this.state = state;
    String lifecycleEvent = state.getLifecycleEvent();
    if (lifecycleEvent != null) {
        fireLifecycleEvent(lifecycleEvent, data);
    }
}

监听机制

事件监听器须要三个参与者：

事件对象—用于封装事件的信息，在事件监听器接口的对立办法中作为参数，个别继承 java.util.EventObjecct类。
事件源—触发事件对的源头，不同事件源触发不同事件。
事件监听器—负责监听事件源收回的事件，产生事件时，事件源调用事件监听器的对立办法解决。监听器个别实现java.util.EventListener接口。

COPYpublic final class LifecycleEvent extends java.util.EventObject {
    public LifecycleEvent(Lifecycle lifecycle, String type, Object data) {
        super(lifecycle);
        this.type = type;
        this.data = data;
    }
}
COPYpublic interface LifecycleListener {
    public void lifecycleEvent(LifecycleEvent event);
}
COPYpublic class HostConfig implements LifecycleListener {
    @Override
    public void lifecycleEvent(LifecycleEvent event) {
        try {
            host = (Host) event.getLifecycle();
            if (host instanceof StandardHost) {
                setCopyXML(((StandardHost) host).isCopyXML());
                setDeployXML(((StandardHost) host).isDeployXML());
                setUnpackWARs(((StandardHost) host).isUnpackWARs());
                setContextClass(((StandardHost) host).getContextClass());
            }
        } catch (ClassCastException e) {
            return;
        }

        // Process the event that has occurred
        if (event.getType().equals(Lifecycle.PERIODIC_EVENT)) {
            check();
        } else if (event.getType().equals(Lifecycle.BEFORE_START_EVENT)) {
            beforeStart();
        } else if (event.getType().equals(Lifecycle.START_EVENT)) {
            start();
        } else if (event.getType().equals(Lifecycle.STOP_EVENT)) {
            stop();
        }
    }
}
COPY// LifecycleBase.startInternal
this.state = state;
String lifecycleEvent = state.getLifecycleEvent();
if (lifecycleEvent != null) {
    fireLifecycleEvent(lifecycleEvent, data);
}

protected void fireLifecycleEvent(String type, Object data) {
    LifecycleEvent event = new LifecycleEvent(this, type, data);
    for (LifecycleListener listener : lifecycleListeners) {
        listener.lifecycleEvent(event);
    }
}

模板办法

四个模板办法，由子类具体实现

COPYprotected abstract void initInternal() throws LifecycleException;
protected abstract void startInternal() throws LifecycleException;
protected abstract void stopInternal() throws LifecycleException;
protected abstract void destroyInternal() throws LifecycleException;

总结

通过提供init、start、stop、destory办法，通过相应的模板办法【模板设计模式】，提供组件的对立生命周期的治理、事件调度。

本文由传智教育博学谷狂野架构师教研团队公布。

如果本文对您有帮忙，欢送关注和点赞；如果您有任何倡议也可留言评论或私信，您的反对是我保持创作的能源。

转载请注明出处！

关于java:你可能不那么知道的Tomcat生命周期管理-博学谷狂野架构师

Tomcat生命周期治理

各种组件如何对立治理

生命周期对立接口

LifecycleBase

LifeCycle源码剖析

作用

状态图

接口定义

默认实现类

监听器相干办法

生命周期办法

init办法

Start办法

stop办法

destroy办法

设置状态办法

监听机制

模板办法

总结

评论

发表回复取消回复

更多文章

DDN HPC 存储硬件架构设计深度分析

探秘IO500：从Lustre并行文件系统出发，开启HPC存储性能新征程

苹果iOS打包的ipa应用无法安装？一篇文章带你了解可能的原因及排查方法

图解Golang：从零开始实现简易版过期LRU缓存

关于java:你可能不那么知道的Tomcat生命周期管理-博学谷狂野架构师

Tomcat生命周期治理

各种组件如何对立治理

生命周期对立接口

LifecycleBase

LifeCycle源码剖析

作用

状态图

接口定义

默认实现类

监听器相干办法

生命周期办法

init办法

Start办法

stop办法

destroy办法

设置状态办法

监听机制

模板办法

总结

评论

发表回复 取消回复

更多文章

DDN HPC 存储硬件架构设计深度分析

探秘IO500：从Lustre并行文件系统出发，开启HPC存储性能新征程

苹果iOS打包的ipa应用无法安装？一篇文章带你了解可能的原因及排查方法

图解Golang：从零开始实现简易版过期LRU缓存

发表回复取消回复