jetty之ContextHandler

这篇文章要分析的类型是非常重要的一个类型...

ContextHandler,从名字上来看就是上下文的handler...

这里普及一下知识:每一个WebApp都对应相应一个context,那么也就对应一个contextHandler当servlet容器收到外部的http请求之后，会根据其请求的path信息来找到相应的webapplication来处理，也就是要找到对应的contextHandler来处理 ，这里也就知道了contextHandler的最重要的作用，那就是将属于当前web的http请求交由内部对应的servlet来处理。。。

由于这个类型的代码比较多，那么就不贴出所有的代码了。。。将其中一些重要的属性和方法抽出来分析一下就好了。。。（ContextHandler继承自HandlerWrapper）

首先来看一个线程变量的定义：

private static ThreadLocal __context=new ThreadLocal();  //当前的线程变量，用于保存到当前的servletContext

这个线程变量用于储存当前的servletContext，这个是在servlet标准中定义的接口，jetty中有自己的实现。。其定义就在ContextHandler类型中，一个内部类。。。

接下来是另外的属性定义：

    protected SContext _scontext;   //相应的servletcontext        private AttributesMap _attributes;  //属性，    private AttributesMap _contextAttributes;  //context的属性    private ClassLoader _classLoader;  //用于加载app的class    private String _contextPath="/";  //例如/manager什么的    private Map _initParams;  //初始化参数    private String _displayName;    private Resource _baseResource;    //app部署的根目录 file:/C:/Users/js/AppData/Local/Temp/Jetty_127_0_0_1_80_manager.war__manager__.24ly2g/webapp/    private MimeTypes _mimeTypes;  //文件类型对应    private Map _localeEncodingMap;    private String[] _welcomeFiles;  //首页的路径    private ErrorHandler _errorHandler;   //错误handler    private String[] _vhosts;  //虚拟主机名    private Set _connectors;   //其所用的connector    private EventListener[] _eventListeners;    private Logger _logger;    private boolean _shutdown;    private boolean _allowNullPathInfo;    private int _maxFormContentSize=Integer.getInteger("org.mortbay.jetty.Request.maxFormContentSize",200000).intValue();    private boolean _compactPath=false;    //一些lisntener的定义    private Object _contextListeners;    //contextListener    private Object _contextAttributeListeners;    private Object _requestListeners;    private Object _requestAttributeListeners;    private Set _managedAttributes;

这里的scontext就是servlet的servlContext，contextPath是当前web的path，我们如果在servlet容器中启动多个app，那么每个webapplication的名字就是它的contextPath。。。。另外还有一些其他的属性，例如当前部署的根目录，一些初始化参数什么的。。。。

还有就是一些listener，例如contextListener什么的。。。

那么接下来我们来看看它的最重要的方法，handle方法：

    //handle方法，用于处理远程的http请求，这里的target就是http请求的path，例如/manager/hello，这里其实是用于判断当前请求的path什么的，如果属于当前的webapp，那么进行处理    public void handle(String target, HttpServletRequest request, HttpServletResponse response, int dispatch)            throws IOException, ServletException  {        boolean new_context=false;        SContext old_context=null;        String old_context_path=null;        String old_servlet_path=null;        String old_path_info=null;        ClassLoader old_classloader=null;        Thread current_thread=null;        //获取当前的http请求        Request base_request=(request instanceof Request)?(Request)request:HttpConnection.getCurrentConnection().getRequest();        if( !isStarted() || _shutdown || (dispatch==REQUEST && base_request.isHandled()))            return;                old_context=base_request.getContext();  //获取servletContext，这里一般情况下都是null，因为新建的socket连接发起的http请求                // Are we already in this context?        if (old_context!=_scontext) {            new_context=true;            //如果有配置虚拟服务器名字，那么需要判断            if (_vhosts!=null && _vhosts.length>0)            {                String vhost = normalizeHostname( request.getServerName());                boolean match=false;                                // TODO non-linear lookup                for (int i=0;!match && i<_vhosts.length;i++)                {                    String contextVhost = _vhosts[i];                    if(contextVhost==null) continue;                    if(contextVhost.startsWith("*.")) {                        // wildcard only at the beginning, and only for one additional subdomain level                        match=contextVhost.regionMatches(true,2,vhost,vhost.indexOf(".")+1,contextVhost.length()-2);                    } else                        match=contextVhost.equalsIgnoreCase(vhost);                }                if (!match)                    return;            }                       //检查connector            if (_connectors!=null && _connectors.size()>0)            {                String connector=HttpConnection.getCurrentConnection().getConnector().getName();                if (connector==null || !_connectors.contains(connector))                    return;            }                        // Nope - so check the target.            if (dispatch==REQUEST)            {                if (_compactPath) {                    target=URIUtil.compactPath(target);                }                                if (target.equals(_contextPath)){ //如果这里http请求的path等于contextPath，那么表示真正的pathinfo是空的，例如/manager，（启动多个app的话，会自动用app的名字来作为contextPath的前缀）                    if (!_allowNullPathInfo && !target.endsWith(URIUtil.SLASH)) { //判断是否运行空的path                        base_request.setHandled(true);                        if (request.getQueryString()!=null)                            response.sendRedirect(URIUtil.addPaths(request.getRequestURI(),URIUtil.SLASH)+"?"+request.getQueryString());                        else                             response.sendRedirect(URIUtil.addPaths(request.getRequestURI(),URIUtil.SLASH));                        return;                    }                    if (_contextPath.length()>1)                    {                        target=URIUtil.SLASH;                        request.setAttribute("org.mortbay.jetty.nullPathInfo",target);                    }                } else if (target.startsWith(_contextPath) && (_contextPath.length()==1 || target.charAt(_contextPath.length())=='/')){                   //这里看http的请求path是否已当前的contextPaht开始                if (_contextPath.length()>1)                        target=target.substring(_contextPath.length());                } else  {                    //不是这个context该处理的，也就是不是这个webapplication该处理的                    return;                }            }        }                try        {            old_context_path=base_request.getContextPath();  //这里一般是空，因为刚开始没有设置            old_servlet_path=base_request.getServletPath();            old_path_info=base_request.getPathInfo();                        //设置servletContext            base_request.setContext(_scontext);  //为当前的http请求设置servletContext            if (dispatch!=INCLUDE && target.startsWith("/"))            {                if (_contextPath.length()==1)                    base_request.setContextPath("");                else                    base_request.setContextPath(_contextPath);  //设置contextPath                base_request.setServletPath(null);                base_request.setPathInfo(target);  //设置pathInfo            }            ServletRequestEvent event=null;            if (new_context) {                // Set the classloader            //设置当前的classLoader                if (_classLoader!=null)                {                    current_thread=Thread.currentThread();                    old_classloader=current_thread.getContextClassLoader();                    current_thread.setContextClassLoader(_classLoader);                }                                // Handle the REALLY SILLY request events!                if (_requestListeners!=null)                {                    event = new ServletRequestEvent(_scontext,request);                    for(int i=0;i<LazyList.size(_requestListeners);i++)                        ((ServletRequestListener)LazyList.get(_requestListeners,i)).requestInitialized(event);                }                //设置当前request的attributelistener                for(int i=0;i<LazyList.size(_requestAttributeListeners);i++)                    base_request.addEventListener(((EventListener)LazyList.get(_requestAttributeListeners,i)));            }                        // Handle the request            try  {                if (dispatch==REQUEST && isProtectedTarget(target))  //判断是否访问的是保护的资源，如果是的话，返回notfound，WEB-INF文件夹下面是保护资源                    throw new HttpException(HttpServletResponse.SC_NOT_FOUND);                //获取内部的handler来处理                Handler handler = getHandler();                //处理当前的http请求，这里其实是jetty.servlet.SessionHandler，不过最终还是调用ServletHandler                if (handler!=null)                    handler.handle(target, request, response, dispatch);            }            catch(HttpException e)            {                Log.debug(e);                response.sendError(e.getStatus(), e.getReason());            }            finally            {                // Handle more REALLY SILLY request events!                if (new_context)                {                    for(int i=LazyList.size(_requestListeners);i-->0;)                        ((ServletRequestListener)LazyList.get(_requestListeners,i)).requestDestroyed(event);                                        for(int i=0;i<LazyList.size(_requestAttributeListeners);i++)                        base_request.removeEventListener(((EventListener)LazyList.get(_requestAttributeListeners,i)));                }            }        }        finally        {            if (old_context!=_scontext)            {                // reset the classloader                if (_classLoader!=null)                {                    current_thread.setContextClassLoader(old_classloader);                }                                // reset the context and servlet path.                base_request.setContext(old_context);                base_request.setContextPath(old_context_path);                base_request.setServletPath(old_servlet_path);                base_request.setPathInfo(old_path_info);             }        }    }

这个方法就最终将会用于将http请求交给对应的servlet来处理。。。

这里的处理流程如下：

（1）判断当前的http请求的path与当前web程序的contextPath是否对应，如果不对应的话那么说明这个http请求不该由当前来处理。。。

（2）如果对应的话，那么设置当前这个request的servletContext，当前线程的classLoader等，

（3）调用内部的handler来处理这个request，这里一般情况下都是SessionHandler，不过SessionHandler其实最终也会调用ServletHandler来处理这个request，将其交给最终的servlet来处理。。。其实这也是jetty的链式调用的最重要利用。

（4）一些收尾的工作。。。。

好了，这里其实对整个ContextHandler的基本的一些了解就算差不多了。。。起码算是知道它用来干嘛的了。。至于说它的一些细节，就交给以后的运行分析再来说吧。。。