webappservlet.java

用java开发的

						attributes.add("javax.servlet.forward.query_string");
					} else {
						attributes.add("javax.servlet.include.request_uri");
						attributes.add("javax.servlet.include.path_info");
						attributes.add("javax.servlet.include.context_path");
						attributes.add("javax.servlet.include.servlet_path");
						attributes.add("javax.servlet.include.query_string");
					}
				}
				Enumeration e = super.getAttributeNames();
				while (e.hasMoreElements())
					attributes.add((String) e.nextElement());
				return Collections.enumeration(attributes);
			}

			public Object getAttribute(String name) {
				if (named == null) {
					if (forward) {
						if ("javax.servlet.forward.request_uri".equals(name))
							return super.getRequestURI();
						else if ("javax.servlet.forward.context_path".equals(name))
							return super.getContextPath();
						else if ("javax.servlet.forward.servlet_path".equals(name))
							return super.getServletPath();
						else if ("javax.servlet.forward.path_info".equals(name))
							return super.getPathInfo();
						else if ("javax.servlet.forward.query_string".equals(name))
							return super.getQueryString();
					} else {
						if ("javax.servlet.include.request_uri".equals(name))
							return getRequestURI1();
						else if ("javax.servlet.include.path_info".equals(name))
							return getPathInfo1();
						else if ("javax.servlet.include.context_path".equals(name))
							return getContextPath();
						else if ("javax.servlet.include.query_string".equals(name))
							return getQueryString1();
						else if ("javax.servlet.include.servlet_path".equals(name))
							return getServletPath1();
					}
				}
				// System.err.printf("!!!return attr:%s=%s%n", name, super.getAttribute(name));
				return super.getAttribute(name);
			}

			// @Override
			// public void setAttribute(String name, Object value) {
			// System.err.printf("!!!Set attr %s=%s%n", name, value);
			// super.setAttribute(name, value);
			// }

			@Override
			public RequestDispatcher getRequestDispatcher(String path) {
				if (path.charAt(0) != '/')
					path = getServletPath() + '/' + path;
				return WebAppServlet.this.getRequestDispatcher(path);
			}

			public String getParameter(String name) {
				Map<String, String[]> params = createParameters();
				String[] result = params.get(name);
				if (result != null)
					return result[0];
				return super.getParameter(name);
			}

			public Map getParameterMap() {
				Map result = super.getParameterMap();
				result.putAll(createParameters());
				return result;
			}

			public Enumeration getParameterNames() {
				Map params = getParameterMap();
				Hashtable result = new Hashtable();
				result.putAll(params);
				return result.keys();
			}

			public String[] getParameterValues(String name) {
				Map<String, String[]> params = createParameters();
				String[] result = params.get(name);
				if (result != null)
					return result;
				return super.getParameterValues(name);
			}

			protected Map<String, String[]> createParameters() {
				String query = getQueryString();
				if (query != null)
					return Acme.Utils.parseQueryString(query, null);
				return new Hashtable<String, String[]>();
			}
		}
	}

	// ////////////// Filter methods /////////////////////
	protected class WebAppContextFilter implements Filter {
		String servPathHolder;

		WebAppContextFilter(String servletPath) {
			if (servletPath != null)
				servPathHolder = servletPath;
			else
				throw new NullPointerException("Servlet path is null");
		}

		WebAppContextFilter() {
			this("/");
		}

		public void init(FilterConfig filterConfig) throws ServletException {
		}

		public void doFilter(final ServletRequest request, ServletResponse response, FilterChain chain)
				throws java.io.IOException, ServletException {
			final HttpServletRequest hreq = (HttpServletRequest) request;
			final HttpServletResponse hres = (HttpServletResponse) response;
			chain.doFilter((HttpServletRequest) Proxy.newProxyInstance(javax.servlet.http.HttpServletRequest.class
					.getClassLoader(), new Class[] { javax.servlet.http.HttpServletRequest.class },
					new InvocationHandler() {
						public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
							String mn = method.getName();
							if (mn.equals("getServletPath")) {
								if (_DEBUG)
									System.err.println("getServletPath() "
											+ extractPath(hreq.getRequestURI(), contextPath, servPathHolder, false));
								return extractPath(hreq.getRequestURI(), contextPath, servPathHolder, false);
							} else if (mn.equals("getPathInfo")) {
								if (_DEBUG)
									System.err.println("getPathInfo() "
											+ extractPath(hreq.getRequestURI(), contextPath, servPathHolder, true));
								return extractPath(hreq.getRequestURI(), contextPath, servPathHolder, true);
							} else if (mn.equals("getRealPath")) {
								if (_DEBUG)
									System.err.println("Path:" + args[0]);
								return getRealPath((String) args[0]);
							} else if (mn.equals("getPathTranslated")) {
								return getRealPath(hreq.getPathInfo());
							} else if (mn.equals("getRequestDispatcher")) {
								String url = (String) args[0];
								if (url.charAt(0) != '/')
									url = extractPath(hreq.getRequestURI(), contextPath, servPathHolder, false) + '/'
											+ url;
								// System.err.printf("req.getDispatcher(%s), %s%n", url, extractPath(hreq.getRequestURI(), contextPath, servPathHolder, false));
								return getRequestDispatcher(url);
							} else if (mn.equals("getContextPath")) {
								return contextPath;
							} else if (mn.equals("getSession")) {
								// System.err.println("getsession");
								HttpSession session = (HttpSession) method.invoke(hreq, args);
								// TODO some overhead is here, context and listeners will be overloaded each time
								// time of accessing session while it's new
								if (session instanceof Serve.AcmeSession
										&& (session.getServletContext() == null || session.isNew())) {
									// System.err.println("set listeners & context");
									((Serve.AcmeSession) session).setListeners(WebAppServlet.this.sessionListeners);
									((Serve.AcmeSession) session).setServletContext(WebAppServlet.this);
									if (sessionTimeout > 0)
										session.setMaxInactiveInterval(sessionTimeout);
								}
								return session;
							}
							return method.invoke(hreq, args);
						}
					}), // response);
					(HttpServletResponse) Proxy.newProxyInstance(javax.servlet.http.HttpServletResponse.class
							.getClassLoader(), new Class[] { javax.servlet.http.HttpServletResponse.class },
							new InvocationHandler() {
								public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
									String mn = method.getName();
									if (mn.equals("sendError")) {
										if (errorPages != null)
											for (ErrorPageDescr epd : errorPages)
												if (epd.errorCode == ((Integer) args[0]).intValue()) {
													setErrorAttributes(hreq, (Integer) args[0],
															args.length > 1 ? (String) args[1] : "", getServletName(),
															hreq.getRequestURI(), null, null);
													// System.err.printf("Forwarding to %s for %d%n",epd.errorPage, args[0]);
													getRequestDispatcher(epd.errorPage).forward(hreq, hres);
													return null;
												}
									} // else if (mn.equals("sendRedirect")) {
									// System.err.printf("Redirect to:%s%n",args[0]);
									// }
									return method.invoke(hres, args);
								}
							}));
		}

		public void destroy() {
			// destroy context filter
		}
	}

	static public String extractPath(String uri, String context, String servlet, boolean info) {
		if (_DEBUG)
			System.err.printf("Extract path URI: %s, context: %s, servlet: %s, action %b\n", uri, context, servlet,
					info);
		int sp = uri.indexOf(servlet, context.length());
		if (sp < 0) {
			sp = context.length();
			/*
			 * if (_DEBUG) System.err.printf("servlet pos: -1 %n"); if (info) return null; // invalid URI or too short return uri.substring(context.length());
			 */
		}
		int pp = uri.indexOf('?', sp);
		int ip = servlet.endsWith("/") ? sp + servlet.length() - 1 : uri.indexOf('/', sp + servlet.length());
		if (_DEBUG)
			System.err.printf("servlet pos %d, info pos: %d, param pos: %d %n", sp, ip, pp);
		if (info == false) {
			if (servlet.equals("/") || ip < 0)
				if (pp > 0)
					return uri.substring(sp, pp);
				else
					return uri.substring(sp);
			if (pp < 0)
				return uri.substring(sp, ip);

			return uri.substring(sp, pp);
		}
		if (servlet.equals("/") || ip < 0 || (pp > 0 && ip > pp))
			return null;
		if (pp < 0)
			return uri.substring(ip);
		return uri.substring(ip, pp);
	}

	protected class SimpleFilterChain implements FilterChain {
		List<FilterAccessDescriptor> filters;

		Iterator<FilterAccessDescriptor> iterator;

		HttpServlet servlet;

		Filter filter;

		Filter nextFilter;

		ServletAccessDescr sad;

		SimpleFilterChain() {
			filters = new ArrayList<FilterAccessDescriptor>();
		}

		public void setFilter(Filter filter) {
			this.filter = filter;
		}

		public void doFilter(ServletRequest request, ServletResponse response) throws java.io.IOException,
				ServletException {

			if (nextFilter != null) {
				nextFilter = null;
				filter.doFilter(request, response, this);
			} else if (iterator.hasNext()) {
				FilterAccessDescriptor fad = iterator.next();
				try {
					fad.filterInstance.doFilter(request, response, this);
				} catch (UnavailableException ue) {
					if (ue.isPermanent()) {
						synchronized(fad) {
							if (fad.filterInstance != null) {
								fad.filterInstance.destroy();
								fad.filterInstance = null;
							}
						}
					} else {
						fad.timeToReactivate = System.currentTimeMillis() + ue.getUnavailableSeconds() * 1000l;
					}
					doFilter(request, response);
					// iterator.remove();
				}
			} else
				// TODO figure out error handler needed for filters, it should also handle UnavailableException
				// call sevlet
				try {
					servlet.service(request, response);
				} catch (IOException ioe) {
					if (handleError(ioe, request, response) == false)
						throw ioe;
				} catch (UnavailableException ue) {
					// log("Servlet " + servlet + " asked to be unavailable", ue);
					if (sad != null) {
						if (ue.isPermanent()) {
							synchronized (sad) {
								if (sad.instance != null) {
									sad.instance.destroy();
									sad.instance = null;
								}
							}
						} else {
							sad.timeToReactivate = System.currentTimeMillis() + ue.getUnavailableSeconds() * 1000l;
						}
					}
					((HttpServletResponse) response).sendError(HttpServletResponse.SC_SERVICE_UNAVAILABLE, ue
							.getMessage());
					// allowing custom handling?
					// eating an exception to avoid removing entire webapp servlet throw ue;
				} catch (ServletException se) {
					if (handleError(se, request, response) == false)
						throw se;
				} catch (Throwable re) {
					if (handleError(re, request, response) == false)
						throw new RuntimeException(re);
				}
		}

		protected boolean handleError(Throwable t, ServletRequest request, ServletResponse response)
				throws java.io.IOException, ServletException {
			if (errorPages != null) {
				Class eclass = t.getClass();
				for (ErrorPageDescr epd : errorPages) {
					if (epd.exception != null && eclass.equals(epd.exception)) {
						log("forward to " + epd.errorPage, t);
						((HttpServletResponse) response).sendRedirect(epd.errorPage);
						setErrorAttributes(request, -1, t.getMessage(), getServletName(),
								((HttpServletRequest) request).getRequestURI(), t, t.getClass());
						getRequestDispatcher(epd.errorPage).forward(request, response);
						return true;
					}
				}
				Class[] peclasses = eclass.getClasses();
				for (Class peclass : peclasses)
					for (ErrorPageDescr epd : errorPages) {
						if (epd.exception != null && peclass.equals(epd.exception)) {
							log("forward to " + epd.errorPage, t);
							((HttpServletResponse) response).sendRedirect(epd.errorPage);
							setErrorAttributes(request, -1, t.getMessage(), getServletName(),
									((HttpServletRequest) request).getRequestURI(), t, t.getClass());
							getRequestDispatcher(epd.errorPage).forward(request, response);
							return true;
						}
					}

			}
			return false;
		}

		protected void reset() {
			iterator = filters.iterator();
			nextFilter = filter;
		}

		protected void add(FilterAccessDescriptor fad) {
			if (fad.timeToReactivate > 0 && fad.timeToReactivate > System.currentTimeMillis())
				return;
			if (filters.contains(fad) == false)
				filters.add(fad);
		}

		protected void setServlet(HttpServlet servlet) {
			this.servlet = servlet;
		}

		protected void setServlet(ServletAccessDescr sad) {
			this.servlet = sad.instance;
			this.sad = sad;
		}
	}

	private final static boolean _DEBUG = false;
}