Tomcat生命周期

来源

本文整理自 <Tomcat内核设计剖析>、<Tomcat结构解析>

Lifecycle接口

​ Lifecycle接口统一管理Tomcat生命周期。一共做了4件事：

• 定义13个string类型常量，用于LifecycleEvent时间的type属性中，用于区分组件发出的LifecycleEvent事件时的状态。

• 定义三个管理监听器的方法，addLifecycleListener、findLifecycleListeners、removeLifecycleListener。

• 定义4个生命周期的方法，init、start、stop、destory，用于执行生命周期的各个阶段的操作。

• 定义了获取当前状态的两个方法，getState、getStateName、用于获取当前的状态。

public 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();

生命周期的状态转化

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

生命周期事件监听机制

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

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

LifecyleBase类

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

生命周期方法

@Override
public final synchronized void init() throws LifecycleException {
    // 通过设置不同的启动状态
    try {
        setStateInternal(LifecycleState.INITIALIZING, null, false);
        initInternal();
        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);
    }
}

// 不同状态时，触发不同事件
private synchronized void setStateInternal(LifecycleState state,
                                           Object data, boolean check) {
    this.state = state;
    String lifecycleEvent = state.getLifecycleEvent();
    if (lifecycleEvent != null) {
        fireLifecycleEvent(lifecycleEvent, data);
    }
}

// 调用注册的监听器的 lifecycleEvent 方法
protected void fireLifecycleEvent(String type, Object data) {
    LifecycleEvent event = new LifecycleEvent(this, type, data);
    for (LifecycleListener listener : lifecycleListeners) {
        listener.lifecycleEvent(event);
    }
}

@Override
public final synchronized void start() throws LifecycleException {
    // 验证生命周期状态
    if (LifecycleState.STARTING_PREP.equals(state) || LifecycleState.STARTING.equals(state) ||
        LifecycleState.STARTED.equals(state)) {
        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);
    }

    // 设置生命周期状态 STARTING_PREP， 并调用 startInternal方法。
    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) {
        ExceptionUtils.handleThrowable(t);
        setStateInternal(LifecycleState.FAILED, null, false);
    }
}

监听管理方法

// 由 standardContext#startInternal来注入监听器
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);
}

状态管理方法

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

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

监听机制

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

• 事件对象---用于封装事件的信息，在事件监听器接口的统一方法中作为参数，一般继承 java.util.EventObjecct类。
• 事件源---触发事件对的源头，不同事件源触发不同事件。
• 事件监听器---负责监听事件源发出的事件，发生事件时，事件源调用事件监听器的统一方法处理。监听器一般实现java.util.EventListener接口。

public final class LifecycleEvent extends java.util.EventObject {
    public LifecycleEvent(Lifecycle lifecycle, String type, Object data) {
        super(lifecycle);
        this.type = type;
        this.data = data;
    }
}

public interface LifecycleListener {
    public void lifecycleEvent(LifecycleEvent event);
}

public 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();
        }
    }
}

// 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);
    }
}