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 changesreturn ((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 mappermapper.setContainer((Container) this); // May throw IAEthis.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;elsethis.mapper = null;}}/*** 根据协议查找映射器实例* @param protocol* @return*/public Mapper findMapper(String protocol) {// the default mapper will always be returned, if any,// regardless the value of protocolif (mapper != null)return (mapper);elsesynchronized (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 protocolMapper 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 Pipelinepublic 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);}}

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 mappedString 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 specificationWrapper wrapper = null;String servletPath = relativeURI;String pathInfo = null;String name = context.findServletMapping(relativeURI);if (name != null)wrapper = (Wrapper) context.findChild(name);return (wrapper);}
}

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 typesif (!(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-INFHttpServletRequest 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 RequestWrapper 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) {;}}}