Jetty之AbstractHandler

因为要弄清楚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的第一篇文章还是很轻松愉快的。。。