Jetty之AbstractHandler

来源：互联网发布：知乎周刊plus网盘编辑：程序博客网时间：2024/06/05 00:20

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

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

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

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

[java] view plaincopy

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接口的定义：

[java] view plaincopy

//用于维护组件的生命周期
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的定义吧：

[java] view plaincopy

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的定义：

[java] view plaincopy

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的第一篇文章还是很轻松愉快的。。。

0 0