下面接着分析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 （#改为@）
