Jetty之ContextHandler

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

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

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

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

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

[java] view
plaincopy

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

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

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

[java] view
plaincopy

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方法：

[java] view
plaincopy

//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的基本的一些了解就算差不多了。。。起码算是知道它用来干嘛的了。。至于说它的一些细节，就交给以后的运行分析再来说吧。。。