jetty之HandlerWrapper与链式调用的实现

在以前读netty的代码的时候,有一个很重要的东西,那就是pipeline,在上面通过对参数的传递实现了handler的链式调用,在jetty中也涉及到链式的调用,不过它是基于装饰器模式来实现的...与netty的不一样...不过个人觉得还是netty的pipeline更加直观简洁吧.....

HanlderWrapper从类型的名字就大概知道了它是对handler的一种包装....它是jetty实现handler的链式调用的关键环节..

还是先来看看它的继承体系吧:

这里还是先从最开始的接口开始吧,abstractHandler以前已经说过了，这里就不说了。。。

那么直接来看看HandlerContainer的定义吧：

//handler的容器，用于添加以及移除handler
public interface HandlerContainer extends LifeCycle
{
    public void addHandler(Handler handler);  //添加handler
    public void removeHandler(Handler handler);  //移除handler

    public Handler[] getChildHandlers();   //获取所有额handler
    public Handler[] getChildHandlersByClass(Class byclass);  //获取某种类型的handler
    public Handler getChildHandlerByClass(Class byclass);   //一个
}

接口的实现还是比较的简单，无非就是一些添加，移除和获取handler的方法的定义。。。

这里abstractHnalderContainer没啥用。。就不看他了。。直接来看HandlerWrapper的定义吧：

//其实这是一张装饰器模式的实现，其实这里最终也是为了实现handler的链式调用，感觉还是netty的pipeline实现更为直观简洁
public class HandlerWrapper extends AbstractHandlerContainer
{
    private Handler _handler;  //用于内装饰的handler

    public HandlerWrapper() {
        super();
    }

    //返回内部的handler
    public Handler getHandler() {
        return _handler;
    }
    //设置handler，这里还需要在server上面激活一些事件
    public void setHandler(Handler handler) {
        try {
            Handler old_handler = _handler;  //这里保存以前的handler
            
            if (getServer()!=null)
                getServer().getContainer().update(this, old_handler, handler, "handler"); //这里其实相当于是激活事件
            
            if (handler!=null) {  //设置handler所属的server
                handler.setServer(getServer());
            }
            _handler = handler;  //保存新设置的handler
            
            if (old_handler!=null) {
                if (old_handler.isStarted()) //如果以前的handler是开启的，那么需要将其停止
                    old_handler.stop();
            }
        } catch(Exception e) {
            IllegalStateException ise= new IllegalStateException();
            ise.initCause(e);
            throw ise;
        }
    }

    //添加一个handler，如果以前已经有handler了，那么将原来那个handler加入到这个新的handler中，类似于形成一条链
    public void addHandler(Handler handler) {
        Handler old = getHandler();
        if (old!=null && !(handler instanceof HandlerContainer))
            throw new IllegalArgumentException("Cannot add");
        setHandler(handler);
        if (old!=null) {  //如果原来的handler不是空，那么将其放到新的handler当中，让其形成一条链
            ((HandlerContainer)handler).addHandler(old);
        }
    }
    
    //移除handler
    public void removeHandler (Handler handler) {
        Handler old = getHandler();
        if (old!=null && (old instanceof HandlerContainer)) {
            ((HandlerContainer)old).removeHandler(handler);
        } else if (old!=null && handler.equals(old)) {
            setHandler(null); 
        } else {
            throw new IllegalStateException("Cannot remove");
        }
    }
    
    
    //当前组件的启动，说白了就是handler的启动
    protected void doStart() throws Exception {
        if (_handler!=null)
            _handler.start();
        super.doStart();
    }
    
   //停止当前的组件
    protected void doStop() throws Exception {
        super.doStop();
        if (_handler!=null)
            _handler.stop();
    }
    
    //处理http请求，第一个参数其实就是http请求的path，然后后面是转发类型，这个方法在子类中一般都会重载
    public void handle(String target, HttpServletRequest request, HttpServletResponse response, int dispatch) throws IOException, ServletException {
        if (_handler!=null && isStarted())
            _handler.handle(target,request, response, dispatch);
    }
    

    //设置当前的server对象
    public void setServer(Server server)  {
        Server old_server=getServer();
        super.setServer(server);
        Handler h=getHandler();
        if (h!=null)
            h.setServer(server);
        
        if (server!=null && server!=old_server)
            server.getContainer().update(this, null,_handler, "handler");
    }
    

    /* ------------------------------------------------------------ */
    protected Object expandChildren(Object list, Class byClass)
    {
        return expandHandler(_handler,list,byClass);
    }

   
}

其实看到这里就能够看出来这就是装饰器模式的典型实现而已，，，，通过将handler一层又一层的包起来，调用的时候从外向里一层一层的调用。。。这样也就实现了handler的链式调用。。。

好了，对jetty的handler部分的一些调用有了基本的了解了，算是为以后进入更重要的内容打下了基础。。。