Tomcat生命周期详解_Tomcat

引言

在上篇文章中我们看到了tomcat架构中的核心组件，而且各个组件都有各自的作用，各司其职，而且相互之间也有对应的父子关系，那么这些对象的创建，调用，销毁等操作是怎么处理呢？

也就是在tomcat中的组件的对象生命周期是怎么管理的呢？针对这个问题，在tomcat中设计了lifecycle接口来统一管理tomcat中的核心组件的生命周期，所以本文我们就系统的来介绍下lifecycle接口的设计

1、lifecycle接口设计

为了统一管理tomcat中的核心组件的生命周期，而专门设计了lifecycle接口来统一管理，我们来看看在lifecycle接口中声明了哪些内容。

1.1 生命周期的方法

在lifecycle中声明了和生命周期相关的方法，包括init(),start(),stop(),destory()等方法。

在声明的方法执行的过程中会涉及到对应的状态的转换，在lifecycle接口的头部文档中很清楚的说了。

1.2 相关的状态处理

通过上图我们可以很清楚的看到相关的方法执行会涉及到的相关状态的转换，比如init()会从new这个状态开始，然后会进入 initializing 和 initialized 等。因为这块涉及到了对应的状态转换，在lifecycle中声明了相关的状态和事件的生命周期字符串。

    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";
    /**
     * the lifecycleevent type for the "periodic" event.
     * 周期性事件（后台线程定时执行一些事情，比如：热部署、热替换）
     */
    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";

在lifecyclestate中建立了对应关系

针对特定的事件就会有相关的监听器来监听处理。在lifecycle中定义了相关的处理方法。

    public void addlifecyclelistener(lifecyclelistener listener);
    public lifecyclelistener[] findlifecyclelisteners();
    public void removelifecyclelistener(lifecyclelistener listener);

通过方法名称我们就能很清楚该方法的相关作用，就不过程介绍了。然后来看下对应的监听器和事件接口的对应设计。

2.监听器和事件的设计

接下来看下lifecyclelistener的设计。其实代码非常简单。

public interface lifecyclelistener {
    /**
     * acknowledge the occurrence of the specified event.
     *  触发监听器后要执行逻辑的方法
     * @param event lifecycleevent that has occurred
     */
    public void lifecycleevent(lifecycleevent event);
}

然后来看下事件的接口

public final class lifecycleevent extends eventobject {
    private static final long serialversionuid = 1l;
    /**
     * construct a new lifecycleevent with the specified parameters.
     *
     * @param lifecycle component on which this event occurred
     * @param type event type (required)
     * @param data event data (if any)
     */
    public lifecycleevent(lifecycle lifecycle, string type, object data) {
        super(lifecycle); // 向上转型，可接受一切实现了生命周期的组件
        this.type = type;
        this.data = data;
    }
    /**
     * the event data associated with this event.
     * 携带的额外的数据，传递给监听器的数据
     */
    private final object data;
    /**
     * the event type this instance represents.
     * 事件类型
     */
    private final string type;
    /**
     * @return the event data of this event.
     */
    public object getdata() {
        return data;
    }
    /**
     * @return the lifecycle on which this event occurred.
     */
    public lifecycle getlifecycle() {
        return (lifecycle) getsource();
    }
    /**
     * @return the event type of this event.
     */
    public string gettype() {
        return this.type;
    }
}

也是非常简单，不过多的赘述。

3.lifecyclebase

通过上面的介绍我们可以看到在tomcat中设计了lifecycle和lifecyclelistener和lifecycleevent来管理核心组件的生命周期，那么我们就需要让每一个组件都实现相关的接口。这时你会发现交给子类的工作量其实是比较大的，不光要完成各个组件的核心功能，还得实现生命周期的相关处理，耦合性很强，这时在tomcat中给我们提供了一个lifecyclebase的抽象类，帮助我们实现了很多和具体业务无关的处理，来简化了具体组件的业务。

3.1 事件处理

在上面的接口设计中对于监听对应的事件处理是没有实现的，在lifecyclebase把这块很好的实现了，我们来看下。首先定义了一个容器来存储所有的监听器

// 存储了所有的实现了lifecyclelistener接口的监听器 
private final list&lt;lifecyclelistener&gt; lifecyclelisteners = new copyonwritearraylist&lt;&gt;();

同时提供了触发监听的相关的方法，绑定了对应的事件。

    /**
     * allow sub classes to fire {@link lifecycle} events.
     *     监听器触发相关的事件
     * @param type  event type  事件类型
     * @param data  data associated with event.
     */
    protected void firelifecycleevent(string type, object data) {
        lifecycleevent event = new lifecycleevent(this, type, data);
        for (lifecyclelistener listener : lifecyclelisteners) {
            listener.lifecycleevent(event);
        }
    }

已经针对listener相关的处理方法

 
    // 添加监听器
    @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);
    }

3.2 生命周期方法

在lifecyclebase中最核心的还是实现了lifecycle中的生命周期方法，以init方法为例我们来看。

    /**
     * 实现了 lifecycle 中定义的init方法
     * 该方法和对应的组件的状态产生的关联
     * @throws lifecycleexception
     */
    @override
    public final synchronized void init() throws lifecycleexception {
        if (!state.equals(lifecyclestate.new)) {
            // 无效的操作  只有状态为 new 的才能调用init方法进入初始化
            invalidtransition(lifecycle.before_init_event);
        }
        try {
            // 设置状态为初始化进行中....同步在方法中会触发对应的事件
            setstateinternal(lifecyclestate.initializing, null, false);
            initinternal(); // 交给子类具体的实现 初始化操作
            // 更新状态为初始化完成 同步在方法中会触发对应的事件
            setstateinternal(lifecyclestate.initialized, null, false);
        } catch (throwable t) {
            handlesubclassexception(t, "lifecyclebase.initfail", tostring());
        }
    }

源码解析：

我们看到首先会判断当前对象的state状态是否为new,因为init方法只能在new状态下才能开始初始化
如果1条件满足则会更新state的状态为 initialized 同时会触发这个事件
然后initinternale()方法会交给子类具体去实现，
等待子类处理完成后会把状态更新为 initialized。

我们可以进入setstateinternal方法查看最后的关键代码：

        // ....
        this.state = state; // 更新状态
        // 根据状态和事件的绑定关系获取对应的事件
        string lifecycleevent = state.getlifecycleevent();
        if (lifecycleevent != null) {
            // 发布对应的事件
            firelifecycleevent(lifecycleevent, data);
        }

可以看到和对应的事件关联起来了。init方法的逻辑弄清楚后，你会发现start方法，stop方法，destory方法的处理逻辑都是差不多的，可自行观看。

而对应的 initinternal()方法的逻辑我们需要在 server service engine connector等核心组件中再看，这个我们会结合tomcat的启动流程来带领大家一起查看。

以上就是tomcat生命周期详解的详细内容，更多关于tomcat生命周期的资料请关注代码网其它相关文章！