第一次阅读Tomcat8源码，就以Lifecycle作为笔记阅读的开篇吧，一千个读者就有一千个哈姆雷特，每个人都Tomcat的理解都不同，如果不记录一次Tomcat源码可能忘了就忘了. 断断DEBUG了几天，决定从Lifecycle开始记录.
LifeCycle接口定义如下：
个人理解：Lifecycle接口定义了生命周期描述的字符常量，初始化之前、初始化之后、启动、启动之前、启动之后、停止、停止之前、停止之后、销毁之前、销毁之后等等；定义了生命周期监听器的三个方法，添加监听器、获得组件上监听器以及移除监听器；定义了组件的四个方法，初始化、启动、停止、销毁；定义了获取当前组件生命状态、生命状态名称；
LifecycleState是枚举，描述着声明周期的状态
Lifecycle接口实现类中比较重要LifecycleBase，以及LifecycleSupport类.
三者之间关系大概这样：LifecycleBase继承Lifecycle,且持有LifecycleSupport属性，LifecycleSupport也持有Lifecycle属性.
LifecycleBase抽象类
LifecycleBase持有LifecycleSupport实例lifecycle，而lifecycle本身持有的是Lifecycle类型，也就意味着如果有一个LifecycleBase的实例A，那A的lifecycle属性也持有A，我有你，你也有我. LifecycleBase实现了Lifecycle的监听器的方法，全部是对LifecycleSupport进行操作；LifecycleBase包括实现类默认创建的时候状态state都是LifecycleState.NEW.
LifecycleSupport类
LifecycleSupport持有Lifecycle实例，以及一个LifecycleListener集合listeners，所有添加、查找所有监听器、移除监听器、触发监听事件都是通过listeners来完成.
Tomcat的Lifecycle，如果要说设计模式，我觉得 观察者模式应该合适些. 观察者模式又被称为源-收听者模式(Listener),百度百科这么介绍该设计模式 ： 一个目标物件管理所有依赖于他的观察者物件，并且在他本身状态发生改变时主动发出通知，通常用于事件处理系统。所以，这是我觉得Lifecycle可以称为观察者模式的原因，下面是Tomcat中StandardServer启动的过程，fireLifecycleEvent，Server主动去通知它的LifecycleListener，执行相应处理逻辑。
简单写个类似的例子，描述下我认为的观察者模式，一个考试Exam,一个闹钟类RingBell，闹钟一直在走，当闹钟到11.25分就去通知考试开始，中间过程省略一直到收卷结束。
Exam考试类
public class Exam implements Lifecycle {
public void init() { System.out.println("监考老师分发考卷"); }
public void start() { System.out.println("监考老师: 考试开始,大家可以做题了"); }
public void stop() { System.out.println("监考老师:时间到,停止答题"); }
public void destroy(){ System.out.println("监考老师收完卷子走人"); }
private LifecycleSupport lifecycle=new LifecycleSupport(this);
public void addLifecycleListener(final LifecycleListener listener) {
lifecycle.addLifecycleListener(listener);
}
public LifecycleListener[] findLifecycleListeners() {
return lifecycle.findLifecycleListeners();
}
public void removeLifecycleListener(final LifecycleListener listener) {
lifecycle.removeLifecycleListener(listener);
}
public LifecycleState getState() {
return null;
}
public String getStateName() {
return null;
}
}
RingBell类
public class RingBell implements Lifecycle {
private boolean flag=true;
public void setFlag(final boolean flag) {
this.flag = flag;
}
private LifecycleSupport lifecycle=new LifecycleSupport(this);
public void addLifecycleListener(final LifecycleListener listener) {
lifecycle.addLifecycleListener(listener);
}
public LifecycleListener[] findLifecycleListeners() {
return lifecycle.findLifecycleListeners();
}
public void removeLifecycleListener(final LifecycleListener listener) {lifecycle.removeLifecycleListener(listener); }
public void start() throws LifecycleException { }
public void stop() throws LifecycleException { }
public void destroy() throws LifecycleException {}
public LifecycleState getState() { return null; }
public String getStateName() { return null; }
public void init() throws LifecycleException {
System.out.println("时钟慢慢走动.....");
while(flag){
Date now = new Date();
System.out.println(new SimpleDateFormat("hh:mm:ss").format(now));
if(now.getHours()==11 && now.getMinutes()== 25 && now.getSeconds()==0){
lifecycle.fireLifecycleEvent(Lifecycle.AFTER_INIT_EVENT,null);
}else if(now.getHours()==11 && now.getMinutes()== 25 && now.getSeconds()== 2){
lifecycle.fireLifecycleEvent(Lifecycle.START_EVENT,null);
}else if(now.getHours()==11 && now.getMinutes()== 25 && now.getSeconds()==4){
lifecycle.fireLifecycleEvent(Lifecycle.STOP_EVENT,null);
}else if(now.getHours()==11 && now.getMinutes()== 25 && now.getSeconds()== 6){
lifecycle.fireLifecycleEvent(Lifecycle.AFTER_DESTROY_EVENT,null);
}else if(now.getHours()==11 && now.getMinutes()== 25 && now.getSeconds()== 8){
lifecycle.fireLifecycleEvent(Lifecycle.AFTER_DESTROY_EVENT,null);
}
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("谁把时钟关了");
}
}
ExamListener
public class ExamListener implements LifecycleListener {
private Exam exam;
public ExamListener(final Exam exam) {
this.exam = exam;
}
public void lifecycleEvent(final LifecycleEvent event) {
if(event.getType().equals(Lifecycle.AFTER_INIT_EVENT)){
exam.init();
}else if(event.getType().equals(Lifecycle.START_EVENT)){
exam.start();
}else if(event.getType().equals(Lifecycle.STOP_EVENT)){
exam.stop();
}else if(event.getType().equals(Lifecycle.AFTER_DESTROY_EVENT)){
exam.destroy();
RingBell ringBell= (RingBell) event.getLifecycle();
ringBell.setFlag(false);
}
}
}
测试方法：
public static void main(String[] args) throws LifecycleException {
Exam exam = new Exam();
RingBell ringBell=new RingBell();
ringBell.addLifecycleListener(new ExamListener(exam));
ringBell.init();
}
解释说明： RingBell作为被观察对象，观察对象就是ExamListener， RingBell持有观察对象ExamListener，当RingBell状态改变(当前时间改变)，就去通知观察者们，观察者们就触发事件，开始考试啊、结束考试等等；
这里的观察者不是具象的观察者对象，而是监听器类型LifecycleListener，通过监听器来使Exam做出响应处理，事件驱动机制。测试效果如下：
注意 RingBell对象 不合适 直接持有Exam的引用， 耦合性太高，假如再来一个观察者监考老师，监考老师需要考试期间来巡查，那我们只需要添加一个LifecycleListener实现类即可，不需要让RingBell持有这个监考老师监听器。
Lifecycle代表了Tomcat的组件的生命周期，定义过init、start、stop、destroy等四个重要的方法。而Tomcat的重要组件全部都实现了LifecycleBase接口，继承了LifecycleBase接口，下图是利用IDEA画出来的继承关系:
LifecycleBase抽象类采用了模板设计模式，听说过采用了模板设计模式的有Arrays.sort方法、Servlet的service方法，模板设计模式的好处就是 统一按照模板执行，共性的基础上个性的地方，再各自处理。
LifecycleBase的init模板方法:
state默认为LifecycleState.NEW，所以第一步的目的是为了防止多次调用init方法，Tomcat组件基本上初始化一次就够了。
init模板共性的地方就是设置当前组件状态，LifecycleState.INITIALIZING以及LifecycleState.INITIALIZED，个性之处在于initInternal，不同组件实现逻辑就是这里体现的。
而共性的设置组件状态的目的呢？接着往下看。
设置组件状态，check为true会再次校验组件状态，一般check都为false. 更新组件的状态，之后就是观察者模式的应用，主动通知组件上左右的监听器LifecycleListener，触发相应的事件。
通过上面两段代码分析，一个组件init初始化大致过程：组件上所有监听器，如果有的话触发LifecycleState.INITIALIZING，也就是before_init， 接着initInternal，就是组件自己会重写的方法，接着触发组件上监听器的LifecycleState.INITIALIZED，也就是after_init类型事件！
LifecycleBase的start模板方法
首先检查组件状态，如果已经处于启动相关状态，before_start/after_start/start状态的话，打印日志并且不再启动；
组件如果还没初始化呢，那赶紧初始化；组件初始化、启动失败了，赶紧停止组件；到这里，如果组件不是初始化完成或者停止的状态，那就有问题了，启动中？启动了？ 正要启动组件，你启动好了，抛出异常；
上述检查都没问题，那设置状态LifecycleState.STARTING_PREP，也就是before_start，目的不用多说了吧，启动组件上监听器，触发before_start的事件啊，接着才是各个组件个性的startInternal，启动完成没有问题，那就设置状态LifecycleState.STARTED，也就是after_start，目的同样启动组件监听器触发after_start事件。
剩下两个stop 、destory模板方法，不用我说肯定是类似的，这里就不多此一举了，毕竟我们连Tomcat启动干了啥都不知道，相比于分析停止、摧毁的模板方法，还是留时间分析Tomcat的启动吧。
总结
感觉自己这样一整理舒畅多了，见识两种设计模式，也请求了Tomcat的组件的初始化、启动流程要干啥，从哪里分析了，核心就是Lifecycle接口以及LifecycleBase以及LifecycleListener，接下来，只需要关注组件上有哪些监听器、初始化initInternal、启动startInternal过程干了啥。