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