下面接着分析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与上文相同,此处不再描述