jetty介绍之handler

嵌入一个jetty服务一般会有下面几步，创建Server,加载Connectors，加载handlers,加载Servlets等，启动服务start，最后加入服务器join。

一个Jetty Server可以看成由一下几部分组成，其中Connector负责接收客户端的HTTP请求，请求的处理是由Handler来完成的。


Handler在Jetty中是一个非常重要的东西，Jetty内部实现了一些Handler，可以分为一下几类：

1.协调Handler：负责将request路由到其他Handler的Handler（如：HandlerConnection, ContextHandlerConnection）

2.过滤Handler：负责向request中设置一些参数，然后再把请求转交给其他Handler（如：HandlerWapper, ContextHandler, SessionHandler）

3.生成Handler：负责生成响应的内容（如：ResourceHandler, ServletHandler）
   当jetty只起一个服务，没有任何handlers和Connectors等时，浏览器访问会返回404。很容易理解，就是有服务，但是服务没有返回response，所以会返回404。

Java代码 收藏代码

public static void main(String[] args) throws Exception  
{  
    Server server = new Server(8081);  
   // server.setHandler(new HelloHandler());  

    server.start();  
    server.join();  
} 

该服务启动后，由于没有任何针对服务的操作，会对所有request返回404。

再看一个简单HelloHandler的介绍和handle方法的参数介绍：

Java代码 收藏代码

    public class HelloHandler extends AbstractHandler  
    {  
        public void handle(String target,Request baseRequest,HttpServletRequest request,HttpServletResponse response)   
            throws IOException, ServletException  
        {  
            response.setContentType("text/html;charset=utf-8");  
            response.setStatus(HttpServletResponse.SC_OK);  
            baseRequest.setHandled(true);  
            response.getWriter().println("<h1>Hello World2</h1>");  
        }  
    }  

target——request的目标，可以是一个url或者一个适配器。

baseRequest——jetty可变的request对象，可以不封装。

request——不可变的request对象，可以被封装。

response——response对象，可以被封装

如上代码handle设置response的状态，ContentType和标记request是否被处理等。。复杂的处理可以用多个Handler结合使用，达到复杂的处理结果。jetty的一些handler可以在org.eclipse.jetty.server.handler中查找



Handler的强大的地方是可以为Jetty Server设置若干Handler，每个Handler完成自己的功能，Handler的处理过程如下：



HandlerList和HandlerConnection内部都可以设置若干Handler， Handler按顺序一个接一个的执行。对于HandlerList而言，只要有一个Handler将请求标记为已处理，或抛出异常，Handler的调用就到此结束。而HandlerConnection则不会结束，一直调用到最后一个Handler。

多个handler的处理：
Java代码 收藏代码

public static void main(String[] args) throws Exception  
{  
    Server server = new Server(8081);  
    server.setHandler(new HelloHandler());//无效的  
    server.setHandler(new HelloHandler());//两次setHandler只有后面这次有用  
    server.start();  
    server.join();  
}  

server调用了两次setHandler，但是只有最后一次setHandler有效，所以上面代码是不行的。

针对多个handler的处理，如下方才是正道：

1、HandlerCollection会按照顺序分别执行每个handler，并把结果拼凑到response，返回。如下：
Java代码 收藏代码

public static void main(String[] args) throws Exception  
{  
    Server server = new Server(8081);  
    HandlerCollection hc =new HandlerCollection();  
    hc.setHandlers(new Handler[]{new HelloHandler(),new HelloHandlerScond()});  
    server.setHandler(hc);  
    server.start();  
    server.join();  
}  

2、HandlerList顺序执行handler,如果抛出错误才执行下一个handler,否则不执行。如：
Java代码 收藏代码

public static void main(String[] args) throws Exception  
{  
    Server server = new Server();  
    SelectChannelConnector connector = new SelectChannelConnector();  
    connector.setPort(8080);  
    server.addConnector(connector);  

    ResourceHandler resource_handler = new ResourceHandler();  
    resource_handler.setDirectoriesListed(true);  
    resource_handler.setWelcomeFiles(new String[]{ "index.html" });  

    resource_handler.setResourceBase(".");  

    HandlerList handlers = new HandlerList();  
    handlers.setHandlers(new Handler[] { resource_handler, new DefaultHandler() });  
    server.setHandler(handlers);  

    server.start();  
    server.join();  
}  

下面以一个具体的例子来说明，需要注意HandlerList和HandlerConnection的区别，代码里有注释：

Java代码 收藏代码

package hb.jetty;  

import java.io.File;  
import java.io.IOException;  
import java.util.Map;  

import javax.servlet.ServletException;  
import javax.servlet.http.HttpServletRequest;  
import javax.servlet.http.HttpServletResponse;  

import org.eclipse.jetty.server.NCSARequestLog;  
import org.eclipse.jetty.server.Request;  
import org.eclipse.jetty.server.Handler;  
import org.eclipse.jetty.server.Server;  
import org.eclipse.jetty.server.handler.AbstractHandler;  
import org.eclipse.jetty.server.handler.DefaultHandler;  
import org.eclipse.jetty.server.handler.HandlerCollection;  
import org.eclipse.jetty.server.handler.HandlerList;  
import org.eclipse.jetty.server.handler.HandlerWrapper;  
import org.eclipse.jetty.server.handler.RequestLogHandler;  

public class ManyHandlers {  
    public static void main(String[] args) throws Exception {  
        Server server = new Server(8080);  

        // create the handlers  
        Handler param = new ParamHandler();  
        HandlerWrapper wrapper = new HandlerWrapper() {  
            @Override  
            public void handle(String target, Request baseRequest, HttpServletRequest request, HttpServletResponse response)  
                    throws IOException, ServletException {  
                request.setAttribute("welcome", "Wylazy");  
                super.handle(target, baseRequest, request, response);  
            }  
        };  

        Handler hello = new HelloHandler();  
        wrapper.setHandler(hello);  
        Handler dft = new DefaultHandler();  

//HandlerList会依次调用每一个Handler，直到某个Handler将请求标记为已处理，即setHandled(true);  
        HandlerList list = new HandlerList();  
        list.setHandlers(new Handler[] { param, wrapper, dft });  
        server.setHandler(list);  

        RequestLogHandler log = new RequestLogHandler();  
        log.setRequestLog(new NCSARequestLog(File.createTempFile("demo", "log").getAbsolutePath()));  

        //HandlerCollection会依次调用每一个Handler，即使请求已经被处理了  
//      HandlerCollection handlers = new HandlerCollection();  
//      handlers.setHandlers(new Handler[] { list, log });  
//      server.setHandler(handlers);  

        server.start();  
        server.join();  
    }  

    public static class ParamHandler extends AbstractHandler {  
        public void handle(String target, Request baseRequest, HttpServletRequest request, HttpServletResponse response)  
                throws IOException, ServletException {  
            Map params = request.getParameterMap();  
            if (params.size() > 0) {  
                response.setContentType("text/plain");  
                response.getWriter().println(params);  
                baseRequest.setHandled(true);  
            }  
//          baseRequest.setHandled(true);  
        }  
    }  

    public static class HelloHandler extends AbstractHandler {    
        public void handle(String target, Request baseRequest, HttpServletRequest request, HttpServletResponse response)    
                throws IOException, ServletException {    
            response.setContentType("text/html;charset=utf-8");    
            response.setStatus(HttpServletResponse.SC_OK);    
            baseRequest.setHandled(true);    
            response.getWriter().println("<h1>Hello World1</h1>");    
            response.getWriter().println("Request url: " + target);    
        }    
    }    

}