下面接着分析Context容器，该接口最重要的方法是addWrapper()方法与creatWrapper()方法，添加具体的子容器，这里是Wrapper容器实例
这里要分析的是一个简单的Context容器，它针对特定的客户端请求，通过映射器找到要处理该特定请求的子容器实例（Wrapper）
具体流程是，Context容器首先调用额外的阀，最后调用基础阀（这里是SimpleContextValve），在基础阀里面通过映射器找到要 处理该请求的子容器Wrapper实例，然后再调用子容器Wrapper实例的各个阀(本示例的Wrapper只有基础阀)（类似于composte模式 迭代）
下面是SimpleContext类的实现，SimpleContext实现org.apache.catalina.Context接口和org.apache.catalina.Pipeline接口
public
class
SimpleContext
implements
Context, Pipeline {
public
SimpleContext() {
pipeline.setBasic(
new
SimpleContextValve());
}
//
子容器名称与子容器实例映射
protected
HashMap children =
new
HashMap();
protected
Loader loader =
null
;
protected
SimplePipeline pipeline =
new
SimplePipeline(
this
);
//
servlet模式与子容器名称映射
protected
HashMap servletMappings =
new
HashMap();
//
映射器
protected
Mapper mapper =
null
;
//
映射器协议与映射器实例映射
protected
HashMap mappers =
new
HashMap();
private
Container parent =
null
;
/**
* 添加servlet模式与子容器名称（wrapper）到HashMap servletMappings容器
*
@param
pattern
*
@param
name
*/
public
void
addServletMapping(String pattern, String name) {
synchronized
(servletMappings) {
servletMappings.put(pattern, name);
}
}
/**
* 根据servlet模式找到对应的子容器名称（wrapper）（供映射器调用）
*
@param
pattern
*
@return
*/
public
String findServletMapping(String pattern) {
synchronized
(servletMappings) {
return
((String) servletMappings.get(pattern));
}
}
/**
* 获取加载器
*
@return
*/
public
Loader getLoader() {
if
(loader !=
null
)
return
(loader);
if
(parent !=
null
)
return
(parent.getLoader());
return
(
null
);
}
/**
* 设置加载器
*
@param
loader
*/
public
void
setLoader(Loader loader) {
this
.loader =
loader;
}
/**
* 添加子容器实例（wrapper）名称与子容器实例（wrapper）到HashMap children容器
*
@param
child
*/
public
void
addChild(Container child) {
child.setParent((Container)
this
);
children.put(child.getName(), child);
}
/**
* 根据名称查找子容器实例wrapper（供映射器调用）
*
@param
name
*
@return
*/
public
Container findChild(String name) {
if
(name ==
null
)
return
(
null
);
synchronized
(children) {
//
Required by post-start changes
return
((Container) children.get(name));
}
}
/**
* 查找子容器数组
*
@return
*/
public
Container[] findChildren() {
synchronized
(children) {
Container results[]
=
new
Container[children.size()];
return
((Container[]) children.values().toArray(results));
}
}
/**
* 添加映射器实例
*
@param
mapper
*/
public
void
addMapper(Mapper mapper) {
//
this method is adopted from addMapper in ContainerBase
//
the first mapper added becomes the default mapper
mapper.setContainer((Container)
this
);
//
May throw IAE
this
.mapper =
mapper;
synchronized
(mappers) {
if
(mappers.get(mapper.getProtocol()) !=
null
)
throw
new
IllegalArgumentException("addMapper: Protocol '"
+ mapper.getProtocol() + "' is not unique"
);
mapper.setContainer((Container)
this
);
//
May throw IAE
mappers.put(mapper.getProtocol(), mapper);
if
(mappers.size() == 1
)
this
.mapper =
mapper;
else
this
.mapper =
null
;
}
}
/**
* 根据协议查找映射器实例
*
@param
protocol
*
@return
*/
public
Mapper findMapper(String protocol) {
//
the default mapper will always be returned, if any,
//
regardless the value of protocol
if
(mapper !=
null
)
return
(mapper);
else
synchronized
(mappers) {
return
((Mapper) mappers.get(protocol));
}
}
public
Mapper[] findMappers() {
return
null
;
}
/**
* 根据请求找到子容器实例wrapper (供基础阀调用该方法)
*
@param
request
*
@param
update
*
@return
*/
public
Container map(Request request,
boolean
update) {
//
this method is taken from the map method in
//
org.apache.cataline.core.ContainerBase
//
the findMapper method always returns the default mapper, if any,
//
regardless the
//
request's protocol
Mapper mapper =
findMapper(request.getRequest().getProtocol());
if
(mapper ==
null
)
return
(
null
);
//
Use this Mapper to perform this mapping
//
具体过程 (回调该对象下面方法)
//
根据request找到处理该请求的子容器wrapper名称 调用方法 String findServletMapping(String pattern)
//
根据上面的子容器wrapper名称找到子容器wrapper 调用方法 Container findChild(String name)
return
(mapper.map(request, update));
}
public
void
invoke(Request request, Response response)
throws
IOException,
ServletException {
pipeline.invoke(request, response);
}
//
method implementations of Pipeline
public
Valve getBasic() {
return
pipeline.getBasic();
}
public
void
setBasic(Valve valve) {
pipeline.setBasic(valve);
}
public
synchronized
void
addValve(Valve valve) {
pipeline.addValve(valve);
}
public
Valve[] getValves() {
return
pipeline.getValves();
}
public
void
removeValve(Valve valve) {
pipeline.removeValve(valve);
}
}
下面我们来分析映射器SimpleContextMapper的实现
public
class
SimpleContextMapper
implements
Mapper {
/**
* The Container with which this Mapper is associated.
*/
private
SimpleContext context =
null
;
public
Container getContainer() {
return
(context);
}
public
void
setContainer(Container container) {
if
(!(container
instanceof
SimpleContext))
throw
new
IllegalArgumentException
(
"Illegal type of container"
);
context
=
(SimpleContext) container;
}
public
String getProtocol() {
return
null
;
}
public
void
setProtocol(String protocol) {
}
/**
* Return the child Container that should be used to process this Request,
* based upon its characteristics. If no such child Container can be
* identified, return <code>null</code> instead.
*
*
@param
request Request being processed
*
@param
update Update the Request to reflect the mapping selection?
*
*
@exception
IllegalArgumentException if the relative portion of the
* path cannot be URL decoded
*/
public
Container map(Request request,
boolean
update) {
//
Identify the context-relative URI to be mapped
String contextPath =
((HttpServletRequest) request.getRequest()).getContextPath();
String requestURI
=
((HttpRequest) request).getDecodedRequestURI();
String relativeURI
=
requestURI.substring(contextPath.length());
//
Apply the standard request URI mapping rules from the specification
Wrapper wrapper =
null
;
String servletPath
=
relativeURI;
String pathInfo
=
null
;
String name
=
context.findServletMapping(relativeURI);
if
(name !=
null
)
wrapper
=
(Wrapper) context.findChild(name);
return
(wrapper);
}
}
映射器SimpleContextMapper最重要的方法是Container map(Request request, boolean update)
即根据客户端请求找到对应的子容器实例wrapper，里面关键代码是回调context容器实例的方法（持有对SimpleContext实例的引用）
接下里分析基础阀的关键代码（管道持有对基础阀的引用）
public
class
SimpleContextValve
implements
Valve, Contained {
protected
Container container;
public
void
invoke(Request request, Response response, ValveContext valveContext)
throws
IOException, ServletException {
//
Validate the request and response object types
if
(!(request.getRequest()
instanceof
HttpServletRequest) ||
!(response.getResponse()
instanceof
HttpServletResponse)) {
return
;
//
NOTE - Not much else we can do generically
}
//
Disallow any direct access to resources under WEB-INF or META-INF
HttpServletRequest hreq =
(HttpServletRequest) request.getRequest();
String contextPath
=
hreq.getContextPath();
String requestURI
=
((HttpRequest) request).getDecodedRequestURI();
String relativeURI
=
requestURI.substring(contextPath.length()).toUpperCase();
Context context
=
(Context) getContainer();
//
Select the Wrapper to be used for this Request
Wrapper wrapper =
null
;
try
{
wrapper
= (Wrapper) context.map(request,
true
);
}
catch
(IllegalArgumentException e) {
badRequest(requestURI, (HttpServletResponse) response.getResponse());
return
;
}
if
(wrapper ==
null
) {
notFound(requestURI, (HttpServletResponse) response.getResponse());
return
;
}
//
Ask this Wrapper to process this Request
response.setContext(context);
wrapper.invoke(request, response);
}
public
Container getContainer() {
return
container;
}
public
void
setContainer(Container container) {
this
.container =
container;
}
private
void
badRequest(String requestURI, HttpServletResponse response) {
try
{
response.sendError(HttpServletResponse.SC_BAD_REQUEST, requestURI);
}
catch
(IllegalStateException e) {
;
}
catch
(IOException e) {
;
}
}
private
void
notFound(String requestURI, HttpServletResponse response) {
try
{
response.sendError(HttpServletResponse.SC_NOT_FOUND, requestURI);
}
catch
(IllegalStateException e) {
;
}
catch
(IOException e) {
;
}
}
}
基础阀持有对Context容器实例（SimpleContext）的引用，在它的关键方法void invoke(Request request, Response response, ValveContext valveContext)里面，先调用Context容器实例的Container map(Request request, boolean update)方法获取子容器实例wrapper，最后调用子容器实例wrapper的invoke(Request request, Response response)方法
至于管道类SimplePipeline与上文相同，此处不再描述
---------------------------------------------------------------------------
本系列How Tomcat Works系本人原创
转载请注明出处 博客园 刺猬的温驯
本人邮箱： chenying998179 # 163.com （ #改为@ ）
