jetty之AbstractHandler

来源：互联网发布：webstorm破解版 mac 编辑：程序博客网时间：2024/06/10 18:27

因为要弄清楚java Web那一套东西，所以就要弄懂整个servlet定义的一些东西，那么就需要搞清楚servlet的容器是怎么搞的，其实最出名的servlet容器应该是tomcat吧，不过我准备拿jetty的源码开刀，因为它更轻量。。。

这篇文章来看看AbstractHandler的定义吧，因为jetty可以说是面向handler的服务器，这一点课netty很相似。。。先来看看它的继承体系：

在jetty中也有lifecycle的概念，它用于维护组件的状态，组件的启动，停止什么的，，是比较重要的一个概念。。

这里先来看看Handler接口是怎么定义的吧：

public interface Handler extends LifeCycle{    //转发的类型    public static final int DEFAULT=0;    public static final int REQUEST=1;    public static final int FORWARD=2;    public static final int INCLUDE=4;    public static final int ERROR=8;    public static final int ALL=15;            //用于处理http请求，target一般是url，dispatch是转发的类型    public void handle(String target, HttpServletRequest request, HttpServletResponse response, int dispatch)        throws IOException, ServletException;    //设置当前handler的server    public void setServer(Server server);    public Server getServer();        public void destroy();    }

这里handler的接口定义还是很简单的，handler方法就是用于处理http请求的，另外还可以看出每一个handler都应该关联一个server。。

接下来来看看LifeCycle接口的定义：

//用于维护组件的生命周期public interface LifeCycle{//start这个组件    public void start()        throws Exception;    //停止这个组件    public void stop()        throws Exception;    //是否已经started或者正在start    public boolean isRunning();    //判断是否已经开启    public boolean isStarted();   //是否正在开启    public boolean isStarting();    //是否正在停止    public boolean isStopping();    //是否已经停止    public boolean isStopped();    //当前组件是否启动失败    public boolean isFailed();        //为当前的组就爱你添加一个listener    public void addLifeCycleListener(LifeCycle.Listener listener);    //删除一个listener，当当前组件的状态发生改变的时候会调用    public void removeLifeCycleListener(LifeCycle.Listener listener);        //listener接口的定义    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);    }}

本身这个接口的定义也很简单，无非就是一些start，stop方法，以及判断当前组件的状态，另外还定义了listener，用于监听当前组件的装填，当组件的状态发生变化的时候就会调用listener相应的方法。。这个很容易就能够看明白。。。

接下来来看看AbstractLifeCycle的定义吧：

public abstract class AbstractLifeCycle implements LifeCycle{    private Object _lock = new Object();   //用于加锁    private final int FAILED = -1, STOPPED = 0, STARTING = 1, STARTED = 2, STOPPING = 3;    private transient int _state = STOPPED;   //当前组件的状态，那么刚开始肯定是stopped的    protected LifeCycle.Listener[] _listeners;  //当前塑件的所有listener    //用于组件的启动，这个方法一般会在子类中重载    protected void doStart() throws Exception    {    }    //在子类中一般重载这个方法    protected void doStop() throws Exception    {    }    //这里对doStart方法做了一个代理，因为实在线程池中运行，所以考虑到并发问题。。。，并要更改当前组件的状态    public final void start() throws Exception    {        synchronized (_lock)        {            try            {                if (_state == STARTED || _state == STARTING)  //避免重复启动                    return;                setStarting();                doStart();                Log.debug("started {}",this);                setStarted();            }            catch (Exception e)            {                Log.warn("failed " + this,e);                setFailed(e);                throw e;            }            catch (Error e)            {                Log.warn("failed " + this,e);                setFailed(e);                throw e;            }        }    }    //与上面start类似    public final void stop() throws Exception    {        synchronized (_lock)        {            try            {                if (_state == STOPPING || _state == STOPPED)                    return;                setStopping();                doStop();                Log.debug("stopped {}",this);                setStopped();            }            catch (Exception e)            {                Log.warn("failed " + this,e);                setFailed(e);                throw e;            }            catch (Error e)            {                Log.warn("failed " + this,e);                setFailed(e);                throw e;            }        }    }    public boolean isRunning()    {        return _state == STARTED || _state == STARTING;    }    public boolean isStarted()    {        return _state == STARTED;    }    public boolean isStarting()    {        return _state == STARTING;    }    public boolean isStopping()    {        return _state == STOPPING;    }    public boolean isStopped()    {        return _state == STOPPED;    }    public boolean isFailed()    {        return _state == FAILED;    }    //添加listener    public void addLifeCycleListener(LifeCycle.Listener listener)    {        _listeners = (LifeCycle.Listener[])LazyList.addToArray(_listeners,listener,LifeCycle.Listener.class);    }    public void removeLifeCycleListener(LifeCycle.Listener listener)    {        LazyList.removeFromArray(_listeners,listener);    }    private void setStarted()    {        _state = STARTED;  //表示当前组件已经启动了        if (_listeners != null)  //激活所有的listener方法        {            for (int i = 0; i < _listeners.length; i++)            {                _listeners[i].lifeCycleStarted(this);            }        }    }    private void setStarting()    {        _state = STARTING;        if (_listeners != null)        {            for (int i = 0; i < _listeners.length; i++)            {                _listeners[i].lifeCycleStarting(this);            }        }    }    private void setStopping()    {        _state = STOPPING;        if (_listeners != null)        {            for (int i = 0; i < _listeners.length; i++)            {                _listeners[i].lifeCycleStopping(this);            }        }    }    //更改当前组件的装填，并且激活listener相应的方法    private void setStopped()    {        _state = STOPPED;        if (_listeners != null)        {            for (int i = 0; i < _listeners.length; i++)            {                _listeners[i].lifeCycleStopped(this);            }        }    }    private void setFailed(Throwable error)    {        _state = FAILED;        if (_listeners != null)        {            for (int i = 0; i < _listeners.length; i++)            {                _listeners[i].lifeCycleFailure(this,error);            }        }    }}

代码虽然还挺长的，不过其实很简单，实现了LifeCycle中定义的方法，另外还定义了doStart和doStop两个方法，留给子类来实现。。。

最后来看看AbstractHandler的定义：

public abstract class AbstractHandler extends AbstractLifeCycle implements Handler{    protected String _string;    private Server _server;   //当前handler所属的server        public AbstractHandler()    {    }    protected void doStart() throws Exception    {        Log.debug("starting {}",this);    }    protected void doStop() throws Exception    {        Log.debug("stopping {}",this);    }    /* ------------------------------------------------------------ */    public String toString()    {        if (_string==null)        {            _string=super.toString();            _string=_string.substring(_string.lastIndexOf('.')+1);        }        return _string;    }    //设置当前handler关联的server    public void setServer(Server server)    {        Server old_server=_server;        if (old_server!=null && old_server!=server)            old_server.getContainer().removeBean(this);        _server=server;        if (_server!=null && _server!=old_server)            _server.getContainer().addBean(this);    }    public Server getServer()    {        return _server;    }    public void destroy()    {        if (!isStopped())            throw new IllegalStateException("!STOPPED");        if (_server!=null)            _server.getContainer().removeBean(this);    }}

其实它的定义也很简单吧，大多数都是实现了空方法，留给子类来实现。。。

好了jetty的第一篇文章还是很轻松愉快的。。。