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