LifeCycle接口
每个组件都要经历创建、初始化、启动这个几个过程，这些状态以及状态的转化是不变的。变化点是每个具体组件的初始化方法，也就是启动方法是不一样的。
我们把这些不变点抽象为一个接口，来控制整个生命周期，就是LifeCycle(org.apache.catalina.Lifecycle)接口，接口定义如下:
public interface Lifecycle {
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";
public void addLifecycleListener(LifecycleListener listener);
public LifecycleListener[] findLifecycleListeners();
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();
public String getStateName();
public interface SingleUse {
}
}
我们可以看到，LifeCycle接口里有init()、start()、stop()和destory()方法，每个具体的组件会去实现这些方法。
在父组件的init()方法中会创建子组件，并调用子组件的init()方法。因此调用者可以无差别的调用各组件的init()方法，这就是组合模式的使用。并且只要调用最顶层组件，也就是Server组件的init()和start()方法，整个Tomcat就被启动起来了。
可扩展性：Lifecycle事件
因为各个组件init()和start()方法的具体实现是复杂多变的，比如在Host容器的启动方法里需要扫描wwbapps目录下的Web应用，创建相应的Context容器，如果将来需要增加新的逻辑，直接修改start()方法？这就会违反开闭原则。
我们发现，组件的init()和start()调用是由它的父组件的状态变化触发的，上层组件的初始化会触发子组件的初始化，上层组件的启动会触发子组件的启动，因此我们把组件的生命周期定义成一个个状态，把状态的转变看做成一个事件。而事件是有监听器的，在监听器里可以实现一些逻辑，并且监听器也可以方便的添加和删除，这就是典型的观察者模式。
具体来说就是在Lifecycle接口中加入两个方法：添加监听器和删除监听器，还需要定义一个Enum来表示组件有哪些转态，以及处在什么状态会触发什么事件。这就是枚举类LifecycleState：
public enum LifecycleState {
NEW(false, null),
INITIALIZING(false, Lifecycle.BEFORE_INIT_EVENT),
INITIALIZED(false, Lifecycle.AFTER_INIT_EVENT),
STARTING_PREP(false, Lifecycle.BEFORE_START_EVENT),
STARTING(true, Lifecycle.START_EVENT),
STARTED(true, Lifecycle.AFTER_START_EVENT),
STOPPING_PREP(true, Lifecycle.BEFORE_STOP_EVENT),
STOPPING(false, Lifecycle.STOP_EVENT),
STOPPED(false, Lifecycle.AFTER_STOP_EVENT),
DESTROYING(false, Lifecycle.BEFORE_DESTROY_EVENT),
DESTROYED(false, Lifecycle.AFTER_DESTROY_EVENT),
FAILED(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;
}
}
从上面代码可以看到，组件的生命周期有NEW、INITIALIZING、INITIALIZED等，一旦组件达到相应的状态就触发相应的事件，比如NEW状态表示组件刚刚被实例化；而当init()方法被调用时，状态就变成了INITIALIZING状态，这个时候，就会触发BEFORE_START_EVENT事件，如果有监听器在监听这个事件，它的方法就会被调用。
重用性：LifecycleBase抽象基类
Tomcat定义了一个基类LifecycleBase来实现Lifecycle接口，把一些公共的逻辑放到基类中去，比如生命状态的转变与维护、生命事件的触发以及监听器的添加和删除等，而子类就负责实现自己的初始化、启动和停止等方法。为了避免跟基类中的方法同名，我们把具体子类的实现方法改个名字，在后面加上Internal，叫initInternal()、startInternal()等。LifCycleBase:
public abstract class LifecycleBase implements Lifecycle {
@Override
public final synchronized void init() throws LifecycleException {
// 1.状态检查
if (!state.equals(LifecycleState.NEW)) {
invalidTransition(Lifecycle.BEFORE_INIT_EVENT);
}
try {
// 2.触发 INITIALIZING 事件的监听
setStateInternal(LifecycleState.INITIALIZING, null, false);
// 3.调用具体子类的初始化方法
initInternal();
// 4.触发 INITIALIZED 事件的监听器
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);
}
}
protected abstract void initInternal() throws LifecycleException;
protected abstract void startInternal() throws LifecycleException;
protected abstract void stopInternal() throws LifecycleException;
protected abstract void destroyInternal() throws LifecycleException;
}
LifecycleBase实现了Lifecycle接口中的所有方法，还定义了相应的抽象方法交给具体子类去实现，这是典型的模板设计模式。
我们来看看init()方法的实现：
- 第一步，检查状态的合法性，比如当期那状态必须是NEW然后才能初始化
- 第二步，触发 INITIALIZING 事件的监听器：
setStateInternal(LifecycleState.INITIALIZING, null, false);
在这个setStateInternal方法里，会调用监听器的业务代码。
- 第三步，调用具体子类实现的抽象方法initInternal()方法。为了实现一键式启动，具体组件在实现initInternal()方法时，又会调用它的子组件的init()方法。
- 第四步，子组件初始化后，触发 INITIALIZED 事件的监听器，相应监听器的业务方法就会被调用
setStateInternal(LifecycleState.INITIALIZED, null, false);
总之，LifecycleBase调用了抽象方法来实现骨架逻辑。那监听器的注册是怎么实现的呢？分为两种情况：
- Tomcat自定义了一些监听器，这些监听器是父组件在创建子组件的过程中注册到子组件的。比如 MemoryLeakTrackingListener 监听器，用来检测 Context 容器中的内存泄漏，这个监听器是Host容器在创建Context容器时注册到Context中的。
- 我们还可以在server.xml中定义自己的监听器，Tomcat在启东时会解析server.xml，创建监听器并注册到容器组件。
生命周期管理总体类图
图中的StandardServer、StandardService等是Server和Service组件的具体实现类，他们都继承了LifecycleBase。
StandardEngine、StandardHost、StandardContext和StandardWrapper是相应容器组件的具体实现类，因为他们都是容器，所以继承了ContainerBase抽象基类，而ContainerBase实现了Container接口，也继承了LifecycleBase类，它们的生命周期管理接口和功能接口是分开的，这也符合设计中的接口分离的原则。
