Jetty - LifeCycle源碼分析

1. 描述

基於Jetty-9.4.8.v20171121。

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主要類的基本特徵。

將這些接口，抽象類，類分爲3層方便理解：

（1）組件接口層：主要包括LifeCycle，Connector，Handler，Container這些組件的高層接口定義；

（2）組件實現層：主要包括各個組件的默認實現；

（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的所有功能。