filterdispatcher.java

struts 2 核心包 的源码 有错误是难免的

// Decompiled by Jad v1.5.8e2. Copyright 2001 Pavel Kouznetsov.
// Jad home page: http://kpdus.tripod.com/jad.html
// Decompiler options: packimports(3) fieldsfirst ansi space 
// Source File Name:   FilterDispatcher.java

package org.apache.struts2.dispatcher;

import com.opensymphony.xwork2.util.ClassLoaderUtil;
import com.opensymphony.xwork2.util.profiling.UtilTimerStack;
import java.io.*;
import java.net.URLDecoder;
import java.util.*;
import javax.servlet.*;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.struts2.RequestUtils;
import org.apache.struts2.StrutsStatics;
import org.apache.struts2.dispatcher.mapper.ActionMapper;

// Referenced classes of package org.apache.struts2.dispatcher:
//			Dispatcher, ActionContextCleanUp

public class FilterDispatcher
	implements StrutsStatics, Filter
{

	private static final Log LOG = LogFactory.getLog(org/apache/struts2/dispatcher/FilterDispatcher);
	private String pathPrefixes[];
	private final Calendar lastModifiedCal = Calendar.getInstance();
	private static boolean serveStatic;
	private static boolean serveStaticBrowserCache;
	private static String encoding;
	private static ActionMapper actionMapper;
	private FilterConfig filterConfig;
	protected Dispatcher dispatcher;

	public FilterDispatcher()
	{
	}

	public void init(FilterConfig filterConfig)
		throws ServletException
	{
		this.filterConfig = filterConfig;
		dispatcher = createDispatcher(filterConfig);
		dispatcher.init();
		String param = filterConfig.getInitParameter("packages");
		String packages = "org.apache.struts2.static template org.apache.struts2.interceptor.debugging";
		if (param != null)
			packages = (new StringBuilder()).append(param).append(" ").append(packages).toString();
		pathPrefixes = parse(packages);
	}

	public void destroy()
	{
		if (dispatcher == null)
			LOG.warn("something is seriously wrong, Dispatcher is not initialized (null) ");
		else
			dispatcher.cleanup();
	}

	protected Dispatcher createDispatcher(FilterConfig filterConfig)
	{
		Map params = new HashMap();
		String name;
		String value;
		for (Enumeration e = filterConfig.getInitParameterNames(); e.hasMoreElements(); params.put(name, value))
		{
			name = (String)e.nextElement();
			value = filterConfig.getInitParameter(name);
		}

		return new Dispatcher(filterConfig.getServletContext(), params);
	}

	public static void setServeStaticContent(String val)
	{
		serveStatic = "true".equals(val);
	}

	public static void setServeStaticBrowserCache(String val)
	{
		serveStaticBrowserCache = "true".equals(val);
	}

	public static void setEncoding(String val)
	{
		encoding = val;
	}

	public static void setActionMapper(ActionMapper mapper)
	{
		actionMapper = mapper;
	}

	protected ServletContext getServletContext()
	{
		return filterConfig.getServletContext();
	}

	protected FilterConfig getFilterConfig()
	{
		return filterConfig;
	}

	protected HttpServletRequest prepareDispatcherAndWrapRequest(HttpServletRequest request, HttpServletResponse response)
		throws ServletException
	{
		Dispatcher du = Dispatcher.getInstance();
		if (du == null)
		{
			Dispatcher.setInstance(dispatcher);
			dispatcher.prepare(request, response);
		} else
		{
			dispatcher = du;
		}
		try
		{
			request = dispatcher.wrapRequest(request, getServletContext());
		}
		catch (IOException e)
		{
			String message = "Could not wrap servlet request with MultipartRequestWrapper!";
			LOG.error(message, e);
			throw new ServletException(message, e);
		}
		return request;
	}

	protected String[] parse(String packages)
	{
		if (packages == null)
			return null;
		List pathPrefixes = new ArrayList();
		String pathPrefix;
		for (StringTokenizer st = new StringTokenizer(packages, ", \n\t"); st.hasMoreTokens(); pathPrefixes.add(pathPrefix))
		{
			pathPrefix = st.nextToken().replace('.', '/');
			if (!pathPrefix.endsWith("/"))
				pathPrefix = (new StringBuilder()).append(pathPrefix).append("/").toString();
		}

		return (String[])pathPrefixes.toArray(new String[pathPrefixes.size()]);
	}

	public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain)
		throws IOException, ServletException
	{
		HttpServletRequest request;
		HttpServletResponse response;
		ServletContext servletContext;
		String timerKey;
		request = (HttpServletRequest)req;
		response = (HttpServletResponse)res;
		servletContext = getServletContext();
		timerKey = "FilterDispatcher_doFilter: ";
		org.apache.struts2.dispatcher.mapper.ActionMapping mapping;
		UtilTimerStack.push(timerKey);
		request = prepareDispatcherAndWrapRequest(request, response);
		try
		{
			mapping = actionMapper.getMapping(request, dispatcher.getConfigurationManager());
			break MISSING_BLOCK_LABEL_114;
		}
		catch (Exception ex)
		{
			LOG.error("error getting ActionMapping", ex);
			dispatcher.sendError(request, response, servletContext, 500, ex);
		}
		ActionContextCleanUp.cleanUp(req);
		UtilTimerStack.pop(timerKey);
		break MISSING_BLOCK_LABEL_113;
		Exception exception;
		exception;
		UtilTimerStack.pop(timerKey);
		throw exception;
		return;
		if (mapping != null)
			break MISSING_BLOCK_LABEL_230;
		String resourcePath = RequestUtils.getServletPath(request);
		if ("".equals(resourcePath) && null != request.getPathInfo())
			resourcePath = request.getPathInfo();
		if (serveStatic && resourcePath.startsWith("/struts"))
		{
			String name = resourcePath.substring("/struts".length());
			findStaticResource(name, request, response);
		} else
		{
			chain.doFilter(request, response);
		}
		ActionContextCleanUp.cleanUp(req);
		UtilTimerStack.pop(timerKey);
		break MISSING_BLOCK_LABEL_229;
		Exception exception1;
		exception1;
		UtilTimerStack.pop(timerKey);
		throw exception1;
		return;
		dispatcher.serviceAction(request, response, servletContext, mapping);
		ActionContextCleanUp.cleanUp(req);
		UtilTimerStack.pop(timerKey);
		break MISSING_BLOCK_LABEL_297;
		Exception exception2;
		exception2;
		UtilTimerStack.pop(timerKey);
		throw exception2;
		Exception exception3;
		exception3;
		ActionContextCleanUp.cleanUp(req);
		UtilTimerStack.pop(timerKey);
		break MISSING_BLOCK_LABEL_294;
		Exception exception4;
		exception4;
		UtilTimerStack.pop(timerKey);
		throw exception4;
		throw exception3;
	}

	protected void findStaticResource(String name, HttpServletRequest request, HttpServletResponse response)
		throws IOException
	{
		if (name.endsWith(".class")) goto _L2; else goto _L1
_L1:
		String arr$[];
		int len$;
		int i$;
		arr$ = pathPrefixes;
		len$ = arr$.length;
		i$ = 0;
_L3:
		InputStream is;
		if (i$ >= len$)
			break; /* Loop/switch isn't completed */
		String pathPrefix = arr$[i$];
		is = findInputStream(name, pathPrefix);
		if (is == null)
			break MISSING_BLOCK_LABEL_323;
		Calendar cal = Calendar.getInstance();
		long ifModifiedSince = 0L;
		try
		{
			ifModifiedSince = request.getDateHeader("If-Modified-Since");
		}
		catch (Exception e)
		{
			LOG.warn((new StringBuilder()).append("Invalid If-Modified-Since header value: '").append(request.getHeader("If-Modified-Since")).append("', ignoring").toString());
		}
		long lastModifiedMillis = lastModifiedCal.getTimeInMillis();
		long now = cal.getTimeInMillis();
		cal.add(5, 1);
		long expires = cal.getTimeInMillis();
		if (ifModifiedSince > 0L && ifModifiedSince <= lastModifiedMillis)
		{
			response.setDateHeader("Expires", expires);
			response.setStatus(304);
			is.close();
			return;
		}
		String contentType = getContentType(name);
		if (contentType != null)
			response.setContentType(contentType);
		if (serveStaticBrowserCache)
		{
			response.setDateHeader("Date", now);
			response.setDateHeader("Expires", expires);
			response.setDateHeader("Retry-After", expires);
			response.setHeader("Cache-Control", "public");
			response.setDateHeader("Last-Modified", lastModifiedMillis);
		} else
		{
			response.setHeader("Cache-Control", "no-cache");
			response.setHeader("Pragma", "no-cache");
			response.setHeader("Expires", "-1");
		}
		copy(is, response.getOutputStream());
		is.close();
		break MISSING_BLOCK_LABEL_322;
		Exception exception;
		exception;
		is.close();
		throw exception;
		return;
		i$++;
		if (true) goto _L3; else goto _L2
_L2:
		response.sendError(404);
		return;
	}

	protected String getContentType(String name)
	{
		if (name.endsWith(".js"))
			return "text/javascript";
		if (name.endsWith(".css"))
			return "text/css";
		if (name.endsWith(".html"))
			return "text/html";
		if (name.endsWith(".txt"))
			return "text/plain";
		if (name.endsWith(".gif"))
			return "image/gif";
		if (name.endsWith(".jpg") || name.endsWith(".jpeg"))
			return "image/jpeg";
		if (name.endsWith(".png"))
			return "image/png";
		else
			return null;
	}

	protected void copy(InputStream input, OutputStream output)
		throws IOException
	{
		byte buffer[] = new byte[4096];
		int n;
		while (-1 != (n = input.read(buffer))) 
			output.write(buffer, 0, n);
		output.flush();
	}

	protected InputStream findInputStream(String name, String packagePrefix)
		throws IOException
	{
		String resourcePath;
		if (packagePrefix.endsWith("/") && name.startsWith("/"))
			resourcePath = (new StringBuilder()).append(packagePrefix).append(name.substring(1)).toString();
		else
			resourcePath = (new StringBuilder()).append(packagePrefix).append(name).toString();
		resourcePath = URLDecoder.decode(resourcePath, encoding);
		return ClassLoaderUtil.getResourceAsStream(resourcePath, getClass());
	}

}