webappservlet.java

用java开发的

				if (sad.instance == null && sad.loadOnStart == false)
					try {
						synchronized (sad) {
							if (sad.instance == null)
								newInstance(sad);
						}
					} catch (ServletException se) {
						log(String.format("Can't instantiate instance %s exception %s", sad, se));
					}
				if (sad.instance != null)
					return new SimpleDispatcher(sad.instance, sad.mapping[patIndex].servPath, path);
				else
					return null; // servlet not working
			}
		}
		// no matching servlets, check for resources
		try {
			if (_DEBUG)
				System.err.printf("Dispatching to resource %s%n", path);
			if (getResource(path) == null)
				throw new MalformedURLException(); // check path is valid
			return new SimpleDispatcher(new HttpServlet() {
				public void service(ServletRequest req, ServletResponse res) throws ServletException, IOException {
					String path;
					if (((HttpServletRequest) req).getAttribute("javax.servlet.include.request_uri") != null)
						path = req.getRealPath((String) req.getAttribute("javax.servlet.include.path_info"));
					else
						path = ((HttpServletRequest) req).getPathTranslated();
					if (_DEBUG)
						System.err.printf("Dispatched file servlet for %s translated %s%n", path,
								((HttpServletRequest) req).getPathTranslated());
					returnFileContent(path, (HttpServletRequest) req, (HttpServletResponse) res);
				}
			}, path);
		} catch (MalformedURLException mfe) {
		}
		return null;
	}

	public java.io.InputStream getResourceAsStream(java.lang.String path) {
		try {
			return getResource(path).openStream();
		} catch (NullPointerException npe) {
			if (_DEBUG)
				System.err.println("URL can't be created for :" + path);
		} catch (IOException ioe) {
			if (_DEBUG)
				ioe.printStackTrace();
		}
		return null;
	}

	public java.net.URL getResource(java.lang.String path) throws java.net.MalformedURLException {
		if (path.charAt(0) != '/')
			throw new MalformedURLException("Path: " + path + " has to start with '/'");
		int pp = path.indexOf('?');
		// no check for # ?
		try {
			return new File(getRealPath((pp > 0 ? path.substring(0, pp) : path))).getCanonicalFile().toURL();
		} catch (IOException io) {
		}
		return null;
	}

	public java.util.Set getResourcePaths(java.lang.String path) {
		if (path.charAt(0) != '/')
			throw new IllegalArgumentException("getResourcePaths: path parameters must begin with '/'");
		int pp = path.indexOf('?');
		if (pp > 0)
			path = path.substring(0, pp);
		File dir = new File(getRealPath(path));
		if (dir.exists() == false || dir.isDirectory() == false)
			return null;
		Set<String> set = new TreeSet<String>();
		String[] els = dir.list();
		for (String el : els) {
			String fp = path + "/" + el;
			if (new File(getRealPath(fp)).isDirectory())
				fp += "/";
			set.add("/" + fp);
		}
		return set;
	}

	public java.lang.String getMimeType(java.lang.String file) {
		if (mimes != null && file != null) {
			int p = file.lastIndexOf('.');
			if (p > 0) {
				String result = mimes.get(file.substring(p).toLowerCase());
				if (result != null)
					return result;
			}
		}
		return server.getMimeType(file);
	}

	public int getMinorVersion() {
		return 5;
	}

	public int getMajorVersion() {
		return 2;
	}

	public ServletContext getContext(java.lang.String uripath) {
		Servlet servlet = server.getServlet(uripath);
		if (servlet != null)
			return servlet.getServletConfig().getServletContext();
		return null;
	}

	public java.lang.String getInitParameter(java.lang.String name) {
		return contextParameters.get(name);
	}

	public java.util.Enumeration getInitParameterNames() {
		return contextParameters.keys();
	}

	protected void setErrorAttributes(ServletRequest req, int status, String msg, String servletName,
			String requestURI, Throwable t, Class eclass) {
		req.setAttribute("javax.servlet.error.status_code", status);
		req.setAttribute("javax.servlet.error.exception_type ", eclass);
		req.setAttribute("javax.servlet.error.message", msg);
		req.setAttribute("javax.servlet.error.exception", t);
		req.setAttribute("javax.servlet.error.request_uri", requestURI);
		req.setAttribute("javax.servlet.error.servlet_name", servletName);
	}

	public static String validatePath(String path) {
		return Utils.canonicalizePath(path);
	}

	public void destroy() {
		Thread.currentThread().setContextClassLoader(ucl);
		if (filters != null)
			for (FilterAccessDescriptor fad : filters)
				if (fad.filterInstance != null)
					fad.filterInstance.destroy();
		for (ServletAccessDescr sad : servlets)
			if (sad.instance != null)
				sad.instance.destroy();
		if (listeners != null)
			for (int i = listeners.size() - 1; i > -1; i--) {
				EventListener listener = listeners.get(i);
				if (listener instanceof ServletContextListener)
					((ServletContextListener) listener).contextDestroyed(new ServletContextEvent(this));
			}
		Enumeration e = getAttributeNames();
		while (e.hasMoreElements())
			removeAttribute((String) e.nextElement());
		// log("Destroy");
	}

	protected class SimpleDispatcher implements RequestDispatcher {
		HttpServlet servlet;

		String servletPath;

		String path;

		String named;

		SimpleDispatcher(HttpServlet s, String p) {
			this(s, null, p);
		}

		SimpleDispatcher(String n, HttpServlet s) {
			this(s, null, null);
			named = n;
		}

		SimpleDispatcher(HttpServlet s, String sp, String p) {
			servlet = s;
			path = p;
			servletPath = sp;
		}

		// //////////////////////////////////////////////////////////////////
		// interface RequestDispatcher

		public void forward(ServletRequest request, ServletResponse response) throws ServletException,
				java.io.IOException {
			if (_DEBUG)
				System.err.printf("FORWARD path: %s, servlet: %s%n", path, servlet);
			response.reset(); // drop all previously putting data and headers
			SimpleFilterChain sfc = buildFilterChain(named, path, request
					.getAttribute("javax.servlet.error.status_code") == null ? DispatchFilterType.FORWARD
					: DispatchFilterType.ERROR);
			sfc.setServlet(servlet);
			sfc.reset();
			sfc.doFilter(new DispatchedRequest((HttpServletRequest) request, true), response);
			// servlet.service(new DispatchedRequest((HttpServletRequest) request, true), response);
			if (response instanceof Serve.ServeConnection)
				((Serve.ServeConnection) response).close();
		}

		public void include(ServletRequest request, final ServletResponse response) throws ServletException,
				java.io.IOException {
			if (response instanceof Serve.ServeConnection)
				((Serve.ServeConnection) response).setInInclude(true);
			if (_DEBUG)
				System.err.printf("INCLUDE path: %s, servlet: %s, servlet path %s%n", path, servlet, servletPath);
			try {
				SimpleFilterChain sfc = buildFilterChain(named, path, DispatchFilterType.INCLUDE);
				sfc.setServlet(servlet);
				sfc.reset();
				sfc.doFilter(new DispatchedRequest((HttpServletRequest) request, false),
						new HttpServletResponseWrapper((HttpServletResponse) response) {
							public void addDateHeader(java.lang.String name, long date) {
							}

							public void setDateHeader(java.lang.String name, long date) {
							}

							public void setHeader(java.lang.String name, java.lang.String value) {
							}

							public void addHeader(java.lang.String name, java.lang.String value) {
							}

							public void setIntHeader(java.lang.String name, int value) {
							}

							public void addIntHeader(java.lang.String name, int value) {
							}

							public void setStatus(int sc) {
							}

							public void setStatus(int sc, java.lang.String sm) {
							}

							public void sendRedirect(java.lang.String location) throws java.io.IOException {
							}

							public void sendError(int sc) throws java.io.IOException {
							}

							public void sendError(int sc, java.lang.String msg) throws java.io.IOException {
							}

							public void reset() {
							}

							public void setLocale(java.util.Locale loc) {
							}

							public void resetBuffer() {
							}

							public void setContentType(java.lang.String type) {
							}

							public void setContentLength(int len) {
							}

							public void setCharacterEncoding(java.lang.String charset) {
							}
						});
			} finally {
				if (response instanceof Serve.ServeConnection)
					((Serve.ServeConnection) response).setInInclude(false);
			}
		}

		class DispatchedRequest extends HttpServletRequestWrapper {
			boolean forward;

			DispatchedRequest(HttpServletRequest request, boolean forward) {
				super(request);
				this.forward = forward;
			}

			public java.lang.String getPathInfo() {
				if (forward)
					return getPathInfo1();
				return super.getPathInfo();
			}

			public java.lang.String getPathInfo1() {
				if (path == null)
					return super.getPathInfo();
				if (path.equals("/") || "/".equals(servletPath))
					return null;
				int qp = path.indexOf('?');
				int sp = servletPath == null ? -1 : path.indexOf(servletPath);
				if (sp >= 0)
					sp += servletPath.length();
				if (sp > 0)
					if (qp > sp)
						return path.substring(sp, qp);
					else
						return path.substring(sp);
				return path;
			}

			public java.lang.String getPathTranslated() {
				return getRealPath(getPathInfo());
			}

			public java.lang.String getRealPath(java.lang.String path) {
				return WebAppServlet.this.getRealPath(path);
			}

			public String getServletPath() {
				if (forward)
					return getServletPath1();
				return super.getServletPath();
			}

			public String getServletPath1() {
				if (servletPath != null)
					if (servletPath.equals("/"))
						return path;
					else
						return servletPath;
				return super.getServletPath();
			}

			public String getRequestURI1() {
				if (path == null)
					if (servletPath != null)
						return servletPath;
					else
						return null;
				int qp = path.indexOf('?');
				if (qp > 0)
					return path.substring(0, qp);
				return path;
			}

			public String getRequestURI() {
				if (forward)
					return getRequestURI1();
				return super.getRequestURI();
			}

			public String getContextPath() {
				return contextPath;
			}

			public String getQueryString1() {
				if (path == null)
					return null;
				int qp = path.indexOf('?');
				if (qp > 0 && qp < path.length() - 1)
					return path.substring(qp + 1);
				return null;
			}

			public String getQueryString() {
				if (forward)
					return getQueryString1();
				return super.getQueryString();
			}

			public java.util.Enumeration getAttributeNames() {
				List<String> attributes = new ArrayList<String>(10);
				if (named == null) {
					if (forward) {
						attributes.add("javax.servlet.forward.request_uri");
						attributes.add("javax.servlet.forward.context_path");
						attributes.add("javax.servlet.forward.servlet_path");
						attributes.add("javax.servlet.forward.path_info");