1. 描述

基于Jetty-9.4.8.v20171121。

Handler是Jetty服务处理器，用户Server处理HTTP请求。

Handler可以做如下处理：

（1）完全生成HTTP响应；

（2）检查或修改请求然后调用其他Handler，比如HandlerWrapper；

（3）传递请求给一个或多个Handlers，比如HandlerCollection；

1.1 类图

（1）AbstractHandler继承ContainerLifeCycle提供：

　　（a）启停行为

　　（b）bean容器

　　（c）基本的dump支持

　　（d）Server引用

　　（e）ErrorDispatchHandler处理错误

（2）实现HandlerContainer接口的Handler可以包含其他Handlers，可以是一个HandlerWrapper或多个HandlerList/HandlerCollection；

（3）HandlerWapper是一个装饰器模式的装饰类，其子类如GzipHandler，ResourceHandler实现不同的装饰效果，如下类图：

// 装饰器模式 -- 核心类

class Decorator implements Component

{

       private Component component;  // 维持一个对抽象构件对象的引用

       public Decorator(Component component)  // 注入一个抽象构件类型的对象

       {

              this.component=component;

       }

       public void operation()

       {

              component.operation();  //调用原有业务方法

       }

}

（4）HandlerCollection和HandlerList包含多个Handler。

1.2 API

@ManagedObject("Jetty Handler")

public interface Handler extends LifeCycle, Destroyable

{

    /**

     * Handle a request.

     *

     * @param target

     *            The target of the request - either a URI or a name.

     * @param baseRequest

     *            The original unwrapped request object.

     * @param request

     *            The request either as the {@link Request} object or a wrapper of that request. The

     *            <code>{@link HttpConnection#getCurrentConnection()}.{@link HttpConnection#getHttpChannel() getHttpChannel()}.{@link HttpChannel#getRequest() getRequest()}</code>

     *            method can be used access the Request object if required.

     * @param response

     *            The response as the {@link Response} object or a wrapper of that request. The

     *            <code>{@link HttpConnection#getCurrentConnection()}.{@link HttpConnection#getHttpChannel() getHttpChannel()}.{@link HttpChannel#getResponse() getResponse()}</code>

     *            method can be used access the Response object if required.

     * @throws IOException

     *             if unable to handle the request or response processing

     * @throws ServletException

     *             if unable to handle the request or response due to underlying servlet issue

     */

    public void handle(String target, Request baseRequest, HttpServletRequest request, HttpServletResponse response)

        throws IOException, ServletException;

    public void setServer(Server server);

    @ManagedAttribute(value="the jetty server for this handler", readonly=true)

    public Server getServer();

    @ManagedOperation(value="destroy associated resources", impact="ACTION")

    public void destroy();

}

2. AbstractHandler

AbstractHandler是Handler的基本实现。

// 实现ContainerLifeCycle提供基本能力：（1）启停行为（2）bean容器化（3）基本的dump支持（4）Server引用（5）错误处理Handler

@ManagedObject("Jetty Handler")

public abstract class AbstractHandler extends ContainerLifeCycle implements Handler

{

    private static final Logger LOG = Log.getLogger(AbstractHandler.class);

    private Server _server; // Server

    public AbstractHandler()

    {

    }

    @Override

    public abstract void handle(String target, Request baseRequest, HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException;

    // 生成错误页面，当DispatchType.ERROR，handle可以调用该方法

    protected void doError(String target, Request baseRequest, HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException

    {

        Object o = request.getAttribute(RequestDispatcher.ERROR_STATUS_CODE);

        int code = (o instanceof Integer)?((Integer)o).intValue():(o!=null?Integer.valueOf(o.toString()):500);

        o = request.getAttribute(RequestDispatcher.ERROR_MESSAGE);

        String reason = o!=null?o.toString():null;

        response.sendError(code,reason);

    }

    /*

     * @see org.eclipse.thread.LifeCycle#start()

     */

    @Override

    protected void doStart() throws Exception

    {

        if (LOG.isDebugEnabled())

            LOG.debug("starting {}",this);

        if (_server==null)

            LOG.warn("No Server set for {}",this);

        super.doStart();

    }

    /*

     * @see org.eclipse.thread.LifeCycle#stop()

     */

    @Override

    protected void doStop() throws Exception

    {

        if (LOG.isDebugEnabled())

            LOG.debug("stopping {}",this);

        super.doStop();

    }

    @Override

    public void setServer(Server server)

    {

        if (_server==server)

            return;

        if (isStarted())

            throw new IllegalStateException(STARTED);

        _server=server;

    }

    @Override

    public Server getServer()

    {

        return _server;

    }

    @Override

    public void destroy()

    {

        if (!isStopped())

            throw new IllegalStateException("!STOPPED");

        super.destroy();

    }

    @Override

    public void dumpThis(Appendable out) throws IOException

    {

        out.append(toString()).append(" - ").append(getState()).append('\n');

    }

     // 处理DispatcherType.ERROR的分发

    public static abstract class ErrorDispatchHandler extends AbstractHandler

    {

        @Override

        public final void handle(String target, Request baseRequest, HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException

        {

            if (baseRequest.getDispatcherType()==DispatcherType.ERROR)

                doError(target,baseRequest,request,response);

            else

                doNonErrorHandle(target,baseRequest,request,response);

        }

        // 处理所有非DispatcherType.ERROR

        protected abstract void doNonErrorHandle(String target, Request baseRequest, HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException;

    }

}

3. HandlerWrapper　

HandlerWrapper实现的是一个典型的装饰器模式。

 @Override

    public void handle(String target, Request baseRequest, HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException

    {

        Handler handler=_handler; // 被装饰对象的handle方法

        if (handler!=null)

            handler.handle(target,baseRequest, request, response);

    }

4. HandlerCollection

Handlers集合，默认实现是按照顺序执行所有handle方法，不管响应码和异常。子类可以改变调用顺序或者调用规则　

@ManagedObject("Handler of multiple handlers")

public class HandlerCollection extends AbstractHandlerContainer

{

    private final boolean _mutableWhenRunning;

    private volatile Handler[] _handlers;

    @Override

    public void handle(String target, Request baseRequest, HttpServletRequest request, HttpServletResponse response)

        throws IOException, ServletException

    {

        if (_handlers!=null && isStarted())

        {

            MultiException mex=null;

            for (int i=0;i<_handlers.length;i++) // 依次调用handle方法

            {

                try

                {

                    _handlers[i].handle(target,baseRequest, request, response);

                }

                catch(IOException e)

                {

                    throw e;

                }

                catch(RuntimeException e)

                {

                    throw e;

                }

                catch(Exception e)

                {

                    if (mex==null)

                        mex=new MultiException();

                    mex.add(e);

                }

            }

            if (mex!=null)

            {

                if (mex.size()==1)

                    throw new ServletException(mex.getThrowable(0));

                else

                    throw new ServletException(mex);

            }

        }

    }

}

5. HandlerList

继承HandlerCollection，调用每一个Handler，遇到3种情况会退出：（1）抛出异常（2）响应被提交（3）整数的响应状态　　

@Override

    public void handle(String target, Request baseRequest, HttpServletRequest request, HttpServletResponse response)

        throws IOException, ServletException // 异常退出

    {

        Handler[] handlers = getHandlers();

        if (handlers!=null && isStarted())

        {

            for (int i=0;i<handlers.length;i++)

            {

                handlers[i].handle(target,baseRequest, request, response);

                if ( baseRequest.isHandled()) // 退出

                    return;

            }

        }

    }

总的来说，Handler采用装饰器模式，通过继承父装饰类，自定义不同的handlr处理逻辑。

巴特西

Jetty - Handler源码分析