Jetty之ContextHandler

最新推荐文章于 2024-04-03 08:45:00 发布

kobejayandy

最新推荐文章于 2024-04-03 08:45:00 发布

阅读量7k

点赞数 1

分类专栏：网络编程

网络编程专栏收录该内容

83 篇文章 9 订阅

订阅专栏

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

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);   
         }  
     }  
 }  