Jetty - LifeCycle源码分析
1. 描述
基于Jetty-9.4.8.v20171121。java
LifeCycle主要管理Jetty里面通用组件的生命周期，好比组件启动中、启动、运行、中止中、中止等，实现该接口就能够定义一套生命周期。算法
其中通用组件好比Server，Connector，Handler等，Jetty把不少对象当成组件来管理而且都是LifeCycle的子类。设计模式
1.1 API
LifeCycle与其内部类LifeCycle.Listener是一个典型的观察者设计模式，LifeCycle是被观察者，LifeCycle.Listener是观察者。并发
其中也透漏一种编码范式：观察者模式的编码范式，Jetty里面Container组件与其内部类Container.Listener也是观察者设计模式也遵循这样的编码范式。框架
@ManagedObject("Lifecycle Interface for startable components")
public interface LifeCycle
{
// 启动组件
@ManagedOperation(value="Starts the instance", impact="ACTION")
public void start()
throws Exception;
// 中止组件，组件能够等待当前的活动正常完成，可是它能够被中断。
@ManagedOperation(value="Stops the instance", impact="ACTION")
public void stop()
throws Exception;
// 若是组件在启动中或已经启动
public boolean isRunning();
// 若是组件已经启动
public boolean isStarted();
// 若是组件启动中
public boolean isStarting();
// 若是组件中止中
public boolean isStopping();
// 若是组件已经中止
public boolean isStopped();
// 若是组件启动失败或中止失败
public boolean isFailed();
/* ------------------------------------------------------------ */
public void addLifeCycleListener(LifeCycle.Listener listener);
/* ------------------------------------------------------------ */
public void removeLifeCycleListener(LifeCycle.Listener listener);
// 监听器，监听Lifecycle事件
public interface Listener extends EventListener
{
public void lifeCycleStarting(LifeCycle event);
public void lifeCycleStarted(LifeCycle event);
public void lifeCycleFailure(LifeCycle event,Throwable cause);
public void lifeCycleStopping(LifeCycle event);
public void lifeCycleStopped(LifeCycle event);
}
// 若是object实例是一个Lifecycle对象，则启动。若是异常统一转换为RuntimeException
public static void start(Object object)
{
if (object instanceof LifeCycle)
{
try
{
((LifeCycle)object).start();
}
catch(Exception e)
{
throw new RuntimeException(e);
}
}
}
// 若是object实例是一个Lifecycle对象，则中止。若是异常统一转换为RuntimeException
public static void stop(Object object)
{
if (object instanceof LifeCycle)
{
try
{
((LifeCycle)object).stop();
}
catch(Exception e)
{
throw new RuntimeException(e);
}
}
}
}
1.2 类图
LifeCycle是Jetty主要类的基本特征。ide
将这些接口，抽象类，类分为3层方便理解：源码分析
（1）组件接口层：主要包括LifeCycle，Connector，Handler，Container这些组件的高层接口定义；学习
（2）组件实现层：主要包括各个组件的默认实现；this
（3）组件应用层：主要涉及具体的应用，如：ServerConnector负责HTTP等协议的链接，Server是Jetty中惟一的服务。编码
类图以下：
Jetty重要的组件Server，Handler，Connector和Container都是LifeCycle子类。
沿着组件的继承关系，能够看出都有一个默认实现AbstractXXX类，这些默认实现已经帮咱们完成了大部分功能，差别性都放在子类中实现。
因为咱们主要关心LifeCycle，因此咱们重点源码分析AbstractLifeCycle的实现。
2. AbstractLifeCycle抽象类
从上面LifeCycle的API能够看出，具备生命周期的类主要具备的能力是：启动、中止和注册LifeCycle状态变化的监听器，主要有5种状态须要监听：启动中，启动，失败，中止中，中止。其中，失败包括启动失败和中止失败。
2.1 API
// 组件生命周期的基本实现
@ManagedObject("Abstract Implementation of LifeCycle")
public abstract class AbstractLifeCycle implements LifeCycle
// 6种状态定义
public static final String STOPPED="STOPPED";
public static final String FAILED="FAILED";
public static final String STARTING="STARTING";
public static final String STARTED="STARTED";
public static final String STOPPING="STOPPING";
public static final String RUNNING="RUNNING";
// 保存关心该组件声明周期变化的监听器；
// 这个是典型观察者模式（AbstractLifeCycle是被观察者，Listener是观察者）
private final CopyOnWriteArrayList<LifeCycle.Listener> _listeners=new CopyOnWriteArrayList<LifeCycle.Listener>();
// 锁对象，与组件实例绑定，用于组件的启停等同步操做
private final Object _lock = new Object();
private final int __FAILED = -1, __STOPPED = 0, __STARTING = 1, __STARTED = 2, __STOPPING = 3;
private volatile int _state = __STOPPED;
private long _stopTimeout = 30000;
// AbstractLifeCycle对象提供的两个方法，这两个方法默认是个空实现
// 实际上，继承AbstractLifeCycle多是具体的组件，只有这个具体的组件才清楚本身的真实启停过程；因此须要子类本身实现
protected void doStart() {}
protected void doStop() {}
// AbstractLifeCycle实际提供的是一个模板式的启停步骤，具体的步骤是放在子类的doStart和doStop中实现的，也就是上面定义的两个方法
// 此处是个典型的模板方法设计模式：模板方法模式是结构最简单的行为型设计模式，在其结构中只存在父类与子类之间的继承关系。
// 经过使用模板方法模式，能够将一些复杂流程的实现步骤封装在一系列基本方法中，在抽象父类中提供一个称之为模板方法的方法来定义这些基本方法的执行次序，而经过其子类来覆盖某些步骤，从而使得相同的算法框架能够有不一样的执行结果。
// 模板方法模式提供了一个模板方法来定义算法框架，而某些具体步骤的实现能够在其子类中完成。
// 本身的感悟：设计模式贵在积累，不存在一步就位，各类源代码是最直接的学习资料，第一步就是要善于在源码中正确的识别各类设计模式。
@Override
public final void start() throws Exception
{
synchronized (_lock)
{
try
{
if (_state == __STARTED || _state == __STARTING)
return;
setStarting();
doStart();
setStarted();
}
catch (Throwable e)
{
setFailed(e);
throw e;
}
}
}
@Override
public final void stop() throws Exception
{
synchronized (_lock)
{
try
{
if (_state == __STOPPING || _state == __STOPPED)
return;
setStopping();
doStop();
setStopped();
}
catch (Throwable e)
{
setFailed(e);
throw e;
}
}
}
// 单独提这个方法：这个方法在判断是否运行，为啥须要用一个变量先引用_state，而不是直接判断，主要是为了并发的问题，Jetty里有不少这样的用法。
@Override
public boolean isRunning()
{
final int state = _state;
return state == __STARTED || state == __STARTING;
}
@Override
public void addLifeCycleListener(LifeCycle.Listener listener)
{
_listeners.add(listener);
}
@Override
public void removeLifeCycleListener(LifeCycle.Listener listener)
{
_listeners.remove(listener);
}
// 以下是设置组件状态，而且通知相关的监听器
private void setStarted()
{
_state = __STARTED;
if (LOG.isDebugEnabled())
LOG.debug(STARTED+" @{}ms {}",Uptime.getUptime(),this);
for (Listener listener : _listeners)
listener.lifeCycleStarted(this);
}
private void setStarting()
{
if (LOG.isDebugEnabled())
LOG.debug("starting {}",this);
_state = __STARTING;
for (Listener listener : _listeners)
listener.lifeCycleStarting(this);
}
private void setStopping()
{
if (LOG.isDebugEnabled())
LOG.debug("stopping {}",this);
_state = __STOPPING;
for (Listener listener : _listeners)
listener.lifeCycleStopping(this);
}
private void setStopped()
{
_state = __STOPPED;
if (LOG.isDebugEnabled())
LOG.debug("{} {}",STOPPED,this);
for (Listener listener : _listeners)
listener.lifeCycleStopped(this);
}
private void setFailed(Throwable th)
{
_state = __FAILED;
if (LOG.isDebugEnabled())
LOG.warn(FAILED+" " + this+": "+th,th);
for (Listener listener : _listeners)
listener.lifeCycleFailure(this,th);
}
}
从LifeCycle接口的API和AbstractLifeCycle抽象类的实现来看，AbstractLifeCycle已经基本实现了LifeCycle的所有功能。