/*
    * Copyright 2002-2015 the original author or authors.
    *
    * Licensed under the Apache License, Version 2.0 (the "License");
    * you may not use this file except in compliance with the License.
    * You may obtain a copy of the License at
    *
    *      http://www.apache.org/licenses/LICENSE-2.0
    *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  
  package org.springframework.web.portlet;
  
  import java.io.IOException;
  import java.util.ArrayList;
  import java.util.Collections;
  import java.util.Enumeration;
  import java.util.Iterator;
  import java.util.LinkedList;
  import java.util.List;
  import java.util.Map;
  import java.util.Properties;
  import javax.portlet.ActionRequest;
  import javax.portlet.ActionResponse;
  import javax.portlet.EventRequest;
  import javax.portlet.EventResponse;
  import javax.portlet.MimeResponse;
  import javax.portlet.PortletException;
  import javax.portlet.PortletRequest;
  import javax.portlet.PortletRequestDispatcher;
  import javax.portlet.PortletResponse;
  import javax.portlet.PortletSession;
  import javax.portlet.RenderRequest;
  import javax.portlet.RenderResponse;
  import javax.portlet.ResourceRequest;
  import javax.portlet.ResourceResponse;
  import javax.portlet.StateAwareResponse;
  
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  
  import org.springframework.beans.factory.BeanFactoryUtils;
  import org.springframework.beans.factory.BeanInitializationException;
  import org.springframework.beans.factory.NoSuchBeanDefinitionException;
  import org.springframework.context.ApplicationContext;
  import org.springframework.core.OrderComparator;
  import org.springframework.core.io.ClassPathResource;
  import org.springframework.core.io.support.PropertiesLoaderUtils;
  import org.springframework.core.style.StylerUtils;
  import org.springframework.util.ClassUtils;
  import org.springframework.util.StringUtils;
  import org.springframework.web.multipart.MultipartException;
  import org.springframework.web.portlet.multipart.MultipartActionRequest;
  import org.springframework.web.portlet.multipart.PortletMultipartResolver;
  import org.springframework.web.servlet.View;
  import org.springframework.web.servlet.ViewRendererServlet;
  import org.springframework.web.servlet.ViewResolver;
  
  /**
   * Central dispatcher for use within the Portlet MVC framework, e.g. for web UI
   * controllers. Dispatches to registered handlers for processing a portlet request.
   *
   * <p>This portlet is very flexible: It can be used with just about any workflow,
   * with the installation of the appropriate adapter classes. It offers the following
   * functionality that distinguishes it from other request-driven Portlet MVC frameworks:
   *
   * <ul>
   * <li>It is based around a JavaBeans configuration mechanism.
   *
   * <li>It can use any {@link HandlerMapping} implementation - pre-built or provided
   * as part of an application - to control the routing of requests to handler objects.
   * Default is a {@link org.springframework.web.portlet.mvc.annotation.DefaultAnnotationHandlerMapping}.
   * HandlerMapping objects can be defined as beans in the portlet's application context,
   * implementing the HandlerMapping interface, overriding the default HandlerMapping
   * if present. HandlerMappings can be given any bean name (they are tested by type).
   *
   * <li>It can use any {@link HandlerAdapter}; this allows for using any handler interface.
   * The default adapter is {@link org.springframework.web.portlet.mvc.SimpleControllerHandlerAdapter}
   * for Spring's {@link org.springframework.web.portlet.mvc.Controller} interface.
   * A default {@link org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter}
   * will be registered as well. HandlerAdapter objects can be added as beans in the
   * application context, overriding the default HandlerAdapter. Like HandlerMappings,
   * HandlerAdapters can be given any bean name (they are tested by type).
   *
   * <li>The dispatcher's exception resolution strategy can be specified via a
   * {@link HandlerExceptionResolver}, for example mapping certain exceptions to
   * error pages. Default is none. Additional HandlerExceptionResolvers can be added
   * through the application context. HandlerExceptionResolver can be given any
   * bean name (they are tested by type).
   *
   * <li>Its view resolution strategy can be specified via a {@link ViewResolver}
   * implementation, resolving symbolic view names into View objects. Default is
   * {@link org.springframework.web.servlet.view.InternalResourceViewResolver}.
   * ViewResolver objects can be added as beans in the application context,
  * overriding the default ViewResolver. ViewResolvers can be given any bean name
  * (they are tested by type).
  *
  * <li>The dispatcher's strategy for resolving multipart requests is determined by a
  * {@link org.springframework.web.portlet.multipart.PortletMultipartResolver}
  * implementation. An implementations for Apache Commons FileUpload is included:
  * {@link org.springframework.web.portlet.multipart.CommonsPortletMultipartResolver}.
  * The MultipartResolver bean name is "portletMultipartResolver"; default is none.
  * </ul>
  *
  * <p><b>NOTE: The {@code @RequestMapping} annotation will only be processed if a
  * corresponding {@code HandlerMapping} (for type-level annotations) and/or
  * {@code HandlerAdapter} (for method-level annotations) is present in the dispatcher.</b>
  * This is the case by default. However, if you are defining custom {@code HandlerMappings}
  * or {@code HandlerAdapters}, then you need to make sure that a corresponding custom
  * {@code DefaultAnnotationHandlerMapping} and/or {@code AnnotationMethodHandlerAdapter}
  * is defined as well - provided that you intend to use {@code @RequestMapping}.
  *
  * <p><b>A web application can define any number of DispatcherPortlets.</b>
  * Each portlet will operate in its own namespace, loading its own application context
  * with mappings, handlers, etc. Only the root application context as loaded by
  * {@link org.springframework.web.context.ContextLoaderListener}, if any, will be shared.
  *
  * <p>Thanks to Rainer Schmitz, Nick Lothian and Eric Dalquist for their suggestions!
  *
  * @author William G. Thompson, Jr.
  * @author John A. Lewis
  * @author Juergen Hoeller
  * @since 2.0
  * @see org.springframework.web.portlet.mvc.Controller
  * @see org.springframework.web.servlet.ViewRendererServlet
  * @see org.springframework.web.context.ContextLoaderListener
  */
 public class DispatcherPortlet extends FrameworkPortlet {
 
 	/**
 	 * Well-known name for the PortletMultipartResolver object in the bean factory for this namespace.
 	 */
 	public static final String MULTIPART_RESOLVER_BEAN_NAME = "portletMultipartResolver";
 
 	/**
 	 * Well-known name for the HandlerMapping object in the bean factory for this namespace.
 	 * Only used when "detectAllHandlerMappings" is turned off.
 	 * @see #setDetectAllViewResolvers
 	 */
 	public static final String HANDLER_MAPPING_BEAN_NAME = "handlerMapping";
 
 	/**
 	 * Well-known name for the HandlerAdapter object in the bean factory for this namespace.
 	 * Only used when "detectAllHandlerAdapters" is turned off.
 	 * @see #setDetectAllHandlerAdapters
 	 */
 	public static final String HANDLER_ADAPTER_BEAN_NAME = "handlerAdapter";
 
 	/**
 	 * Well-known name for the HandlerExceptionResolver object in the bean factory for this
 	 * namespace. Only used when "detectAllHandlerExceptionResolvers" is turned off.
 	 * @see #setDetectAllViewResolvers
 	 */
 	public static final String HANDLER_EXCEPTION_RESOLVER_BEAN_NAME = "handlerExceptionResolver";
 
 	/**
 	 * Well-known name for the ViewResolver object in the bean factory for this namespace.
 	 */
 	public static final String VIEW_RESOLVER_BEAN_NAME = "viewResolver";
 
 	/**
 	 * Default URL to ViewRendererServlet. This bridge servlet is used to convert
 	 * portlet render requests to servlet requests in order to leverage the view support
 	 * in the {@code org.springframework.web.view} package.
 	 */
 	public static final String DEFAULT_VIEW_RENDERER_URL = "/WEB-INF/servlet/view";
 
 	/**
 	 * Unlike the Servlet version of this class, we have to deal with the
 	 * two-phase nature of the portlet request. To do this, we need to pass
 	 * forward any exception that occurs during the action phase, so that
 	 * it can be displayed in the render phase. The only direct way to pass
 	 * things forward and preserve them for each render request is through
 	 * render parameters, but these are limited to String objects and we need
 	 * to pass the Exception itself. The only other way to do this is in the
 	 * session. The bad thing about using the session is that we have no way
 	 * of knowing when we are done re-rendering the request and so we don't
 	 * know when we can remove the objects from the session. So we will end
 	 * up polluting the session with an old exception when we finally leave
 	 * the render phase of one request and move on to something else.
 	 */
 	public static final String ACTION_EXCEPTION_SESSION_ATTRIBUTE =
 			DispatcherPortlet.class.getName() + ".ACTION_EXCEPTION";
 
 	/**
 	 * This render parameter is used to indicate forward to the render phase
 	 * that an exception occurred during the action phase.
 	 */
 	public static final String ACTION_EXCEPTION_RENDER_PARAMETER = "actionException";
 
 	/**
 	 * Log category to use when no mapped handler is found for a request.
 	 */
 	public static final String PAGE_NOT_FOUND_LOG_CATEGORY = "org.springframework.web.portlet.PageNotFound";
 
 	/**
 	 * Name of the class path resource (relative to the DispatcherPortlet class)
 	 * that defines DispatcherPortet's default strategy names.
 	 */
 	private static final String DEFAULT_STRATEGIES_PATH = "DispatcherPortlet.properties";
 
 
 	/**
 	 * Additional logger to use when no mapped handler is found for a request.
 	 */
 	protected static final Log pageNotFoundLogger = LogFactory.getLog(PAGE_NOT_FOUND_LOG_CATEGORY);
 
 	private static final Properties defaultStrategies;
 
 	static {
 		// Load default strategy implementations from properties file.
 		// This is currently strictly internal and not meant to be customized
 		// by application developers.
 		try {
 			ClassPathResource resource = new ClassPathResource(DEFAULT_STRATEGIES_PATH, DispatcherPortlet.class);
 			defaultStrategies = PropertiesLoaderUtils.loadProperties(resource);
 		}
 		catch (IOException ex) {
 			throw new IllegalStateException("Could not load 'DispatcherPortlet.properties': " + ex.getMessage());
 		}
 	}
 
 
 	/** Detect all HandlerMappings or just expect "handlerMapping" bean? */
 	private boolean detectAllHandlerMappings = true;
 
 	/** Detect all HandlerAdapters or just expect "handlerAdapter" bean? */
 	private boolean detectAllHandlerAdapters = true;
 
 	/** Detect all HandlerExceptionResolvers or just expect "handlerExceptionResolver" bean? */
 	private boolean detectAllHandlerExceptionResolvers = true;
 
 	/** Detect all ViewResolvers or just expect "viewResolver" bean? */
 	private boolean detectAllViewResolvers = true;
 
 	/** Whether exceptions thrown during doAction should be forwarded to doRender */
 	private boolean forwardActionException = true;
 
 	/** Whether exceptions thrown during doEvent should be forwarded to doRender */
 	private boolean forwardEventException = false;
 
 	/** URL that points to the ViewRendererServlet */
 	private String viewRendererUrl = DEFAULT_VIEW_RENDERER_URL;
 
 
 	/** MultipartResolver used by this portlet */
 	private PortletMultipartResolver multipartResolver;
 
 	/** List of HandlerMappings used by this portlet */
 	private List<HandlerMapping> handlerMappings;
 
 	/** List of HandlerAdapters used by this portlet */
 	private List<HandlerAdapter> handlerAdapters;
 
 	/** List of HandlerExceptionResolvers used by this portlet */
 	private List<HandlerExceptionResolver> handlerExceptionResolvers;
 
 	/** List of ViewResolvers used by this portlet */
 	private List<ViewResolver> viewResolvers;
 
 
 	/**
 	 * Set whether to detect all HandlerMapping beans in this portlet's context.
 	 * Else, just a single bean with name "handlerMapping" will be expected.
 	 * <p>Default is true. Turn this off if you want this portlet to use a
 	 * single HandlerMapping, despite multiple HandlerMapping beans being
 	 * defined in the context.
 	 */
 	public void setDetectAllHandlerMappings(boolean detectAllHandlerMappings) {
 		this.detectAllHandlerMappings = detectAllHandlerMappings;
 	}
 
 	/**
 	 * Set whether to detect all HandlerAdapter beans in this portlet's context.
 	 * Else, just a single bean with name "handlerAdapter" will be expected.
 	 * <p>Default is "true". Turn this off if you want this portlet to use a
 	 * single HandlerAdapter, despite multiple HandlerAdapter beans being
 	 * defined in the context.
 	 */
 	public void setDetectAllHandlerAdapters(boolean detectAllHandlerAdapters) {
 		this.detectAllHandlerAdapters = detectAllHandlerAdapters;
 	}
 
 	/**
 	 * Set whether to detect all HandlerExceptionResolver beans in this portlet's context.
 	 * Else, just a single bean with name "handlerExceptionResolver" will be expected.
 	 * <p>Default is true. Turn this off if you want this portlet to use a
 	 * single HandlerExceptionResolver, despite multiple HandlerExceptionResolver
 	 * beans being defined in the context.
 	 */
 	public void setDetectAllHandlerExceptionResolvers(boolean detectAllHandlerExceptionResolvers) {
 		this.detectAllHandlerExceptionResolvers = detectAllHandlerExceptionResolvers;
 	}
 
 	/**
 	 * Set whether to detect all ViewResolver beans in this portlet's context.
 	 * Else, just a single bean with name "viewResolver" will be expected.
 	 * <p>Default is true. Turn this off if you want this portlet to use a
 	 * single ViewResolver, despite multiple ViewResolver beans being
 	 * defined in the context.
 	 */
 	public void setDetectAllViewResolvers(boolean detectAllViewResolvers) {
 		this.detectAllViewResolvers = detectAllViewResolvers;
 	}
 
 	/**
 	 * Set whether to forward exceptions thrown during the action phase
 	 * to the render phase via a session attribute.
 	 * <p>Default is true. Turn this off if you want the portlet container
 	 * to provide immediate exception handling for action requests.
 	 * @see #exposeActionException(javax.portlet.PortletRequest, javax.portlet.StateAwareResponse, Exception)
 	 */
 	public void setForwardActionException(boolean forwardActionException) {
 		this.forwardActionException = forwardActionException;
 	}
 
 	/**
 	 * Set whether to forward exceptions thrown during the event phase
 	 * to the render phase via a session attribute.
 	 * <p>Default is false. Turn this on if you want the {@link DispatcherPortlet}
 	 * to forward the exception to the render phase, similar to what it does
 	 * for {@link #setForwardActionException action exceptions} by default.
 	 */
 	public void setForwardEventException(boolean forwardEventException) {
 		this.forwardEventException = forwardEventException;
 	}
 
 	/**
 	 * Set the URL to the ViewRendererServlet. That servlet is used to
 	 * ultimately render all views in the portlet application.
 	 */
 	public void setViewRendererUrl(String viewRendererUrl) {
 		this.viewRendererUrl = viewRendererUrl;
 	}
 
 
 	/**
 	 * This implementation calls {@link #initStrategies}.
 	 */
 	@Override
 	public void onRefresh(ApplicationContext context) {
 		initStrategies(context);
 	}
 
 	/**
 	 * Refresh the strategy objects that this portlet uses.
 	 * <p>May be overridden in subclasses in order to initialize
 	 * further strategy objects.
 	 */
 	protected void initStrategies(ApplicationContext context) {
 		initMultipartResolver(context);
 		initHandlerMappings(context);
 		initHandlerAdapters(context);
 		initHandlerExceptionResolvers(context);
 		initViewResolvers(context);
 	}
 
 	/**
 	 * Initialize the PortletMultipartResolver used by this class.
 	 * <p>If no valid bean is defined with the given name in the BeanFactory
 	 * for this namespace, no multipart handling is provided.
 	 */
 	private void initMultipartResolver(ApplicationContext context) {
 		try {
 			this.multipartResolver = context.getBean(MULTIPART_RESOLVER_BEAN_NAME, PortletMultipartResolver.class);
 			if (logger.isDebugEnabled()) {
 				logger.debug("Using MultipartResolver [" + this.multipartResolver + "]");
 			}
 		}
 		catch (NoSuchBeanDefinitionException ex) {
 			// Default is no multipart resolver.
 			this.multipartResolver = null;
 			if (logger.isDebugEnabled()) {
 				logger.debug("Unable to locate PortletMultipartResolver with name '"	+ MULTIPART_RESOLVER_BEAN_NAME +
 						"': no multipart request handling provided");
 			}
 		}
 	}
 
 	/**
 	 * Initialize the HandlerMappings used by this class.
 	 * <p>If no HandlerMapping beans are defined in the BeanFactory
 	 * for this namespace, we default to PortletModeHandlerMapping.
 	 */
 	private void initHandlerMappings(ApplicationContext context) {
 		this.handlerMappings = null;
 
 		if (this.detectAllHandlerMappings) {
 			// Find all HandlerMappings in the ApplicationContext, including ancestor contexts.
 			Map<String, HandlerMapping> matchingBeans = BeanFactoryUtils.beansOfTypeIncludingAncestors(
 					context, HandlerMapping.class, true, false);
 			if (!matchingBeans.isEmpty()) {
 				this.handlerMappings = new ArrayList<HandlerMapping>(matchingBeans.values());
 				// We keep HandlerMappings in sorted order.
 				OrderComparator.sort(this.handlerMappings);
 			}
 		}
 		else {
 			try {
 				HandlerMapping hm = context.getBean(HANDLER_MAPPING_BEAN_NAME, HandlerMapping.class);
 				this.handlerMappings = Collections.singletonList(hm);
 			}
 			catch (NoSuchBeanDefinitionException ex) {
 				// Ignore, we'll add a default HandlerMapping later.
 			}
 		}
 
 		// Ensure we have at least one HandlerMapping, by registering
 		// a default HandlerMapping if no other mappings are found.
 		if (this.handlerMappings == null) {
 			this.handlerMappings = getDefaultStrategies(context, HandlerMapping.class);
 			if (logger.isDebugEnabled()) {
 				logger.debug("No HandlerMappings found in portlet '" + getPortletName() + "': using default");
 			}
 		}
 	}
 
 	/**
 	 * Initialize the HandlerAdapters used by this class.
 	 * <p>If no HandlerAdapter beans are defined in the BeanFactory
 	 * for this namespace, we default to SimpleControllerHandlerAdapter.
 	 */
 	private void initHandlerAdapters(ApplicationContext context) {
 		this.handlerAdapters = null;
 
 		if (this.detectAllHandlerAdapters) {
 			// Find all HandlerAdapters in the ApplicationContext, including ancestor contexts.
 			Map<String, HandlerAdapter> matchingBeans = BeanFactoryUtils.beansOfTypeIncludingAncestors(
 					context, HandlerAdapter.class, true, false);
 			if (!matchingBeans.isEmpty()) {
 				this.handlerAdapters = new ArrayList<HandlerAdapter>(matchingBeans.values());
 				// We keep HandlerAdapters in sorted order.
 				OrderComparator.sort(this.handlerAdapters);
 			}
 		}
 		else {
 			try {
 				HandlerAdapter ha = context.getBean(HANDLER_ADAPTER_BEAN_NAME, HandlerAdapter.class);
 				this.handlerAdapters = Collections.singletonList(ha);
 			}
 			catch (NoSuchBeanDefinitionException ex) {
 				// Ignore, we'll add a default HandlerAdapter later.
 			}
 		}
 
 		// Ensure we have at least some HandlerAdapters, by registering
 		// default HandlerAdapters if no other adapters are found.
 		if (this.handlerAdapters == null) {
 			this.handlerAdapters = getDefaultStrategies(context, HandlerAdapter.class);
 			if (logger.isDebugEnabled()) {
 				logger.debug("No HandlerAdapters found in portlet '" + getPortletName() + "': using default");
 			}
 		}
 	}
 
 	/**
 	 * Initialize the HandlerExceptionResolver used by this class.
 	 * <p>If no bean is defined with the given name in the BeanFactory
 	 * for this namespace, we default to no exception resolver.
 	 */
 	private void initHandlerExceptionResolvers(ApplicationContext context) {
 		this.handlerExceptionResolvers = null;
 
 		if (this.detectAllHandlerExceptionResolvers) {
 			// Find all HandlerExceptionResolvers in the ApplicationContext, including ancestor contexts.
 			Map<String, HandlerExceptionResolver> matchingBeans = BeanFactoryUtils.beansOfTypeIncludingAncestors(
 					context, HandlerExceptionResolver.class, true, false);
 			if (!matchingBeans.isEmpty()) {
 				this.handlerExceptionResolvers = new ArrayList<HandlerExceptionResolver>(matchingBeans.values());
 				// We keep HandlerExceptionResolvers in sorted order.
 				OrderComparator.sort(this.handlerExceptionResolvers);
 			}
 		}
 		else {
 			try {
 				HandlerExceptionResolver her = context.getBean(
 						HANDLER_EXCEPTION_RESOLVER_BEAN_NAME, HandlerExceptionResolver.class);
 				this.handlerExceptionResolvers = Collections.singletonList(her);
 			}
 			catch (NoSuchBeanDefinitionException ex) {
 				// Ignore, no HandlerExceptionResolver is fine too.
 			}
 		}
 
 		// Just for consistency, check for default HandlerExceptionResolvers...
 		// There aren't any in usual scenarios.
 		if (this.handlerExceptionResolvers == null) {
 			this.handlerExceptionResolvers = getDefaultStrategies(context, HandlerExceptionResolver.class);
 			if (logger.isDebugEnabled()) {
 				logger.debug("No HandlerExceptionResolvers found in portlet '" + getPortletName() + "': using default");
 			}
 		}
 	}
 
 	/**
 	 * Initialize the ViewResolvers used by this class.
 	 * <p>If no ViewResolver beans are defined in the BeanFactory
 	 * for this namespace, we default to InternalResourceViewResolver.
 	 */
 	private void initViewResolvers(ApplicationContext context) {
 		this.viewResolvers = null;
 
 		if (this.detectAllViewResolvers) {
 			// Find all ViewResolvers in the ApplicationContext, including ancestor contexts.
 			Map<String, ViewResolver> matchingBeans = BeanFactoryUtils.beansOfTypeIncludingAncestors(
 					context, ViewResolver.class, true, false);
 			if (!matchingBeans.isEmpty()) {
 				this.viewResolvers = new ArrayList<ViewResolver>(matchingBeans.values());
 				// We keep ViewResolvers in sorted order.
 				OrderComparator.sort(this.viewResolvers);
 			}
 		}
 		else {
 			try {
 				ViewResolver vr = context.getBean(VIEW_RESOLVER_BEAN_NAME, ViewResolver.class);
 				this.viewResolvers = Collections.singletonList(vr);
 			}
 			catch (NoSuchBeanDefinitionException ex) {
 				// Ignore, we'll add a default ViewResolver later.
 			}
 		}
 
 		// Ensure we have at least one ViewResolver, by registering
 		// a default ViewResolver if no other resolvers are found.
 		if (this.viewResolvers == null) {
 			this.viewResolvers = getDefaultStrategies(context, ViewResolver.class);
 			if (logger.isDebugEnabled()) {
 				logger.debug("No ViewResolvers found in portlet '" + getPortletName() + "': using default");
 			}
 		}
 	}
 
 
 	/**
 	 * Return the default strategy object for the given strategy interface.
 	 * <p>The default implementation delegates to {@link #getDefaultStrategies},
 	 * expecting a single object in the list.
 	 * @param context the current Portlet ApplicationContext
 	 * @param strategyInterface the strategy interface
 	 * @return the corresponding strategy object
 	 * @see #getDefaultStrategies
 	 */
 	protected <T> T getDefaultStrategy(ApplicationContext context, Class<T> strategyInterface) {
 		List<T> strategies = getDefaultStrategies(context, strategyInterface);
 		if (strategies.size() != 1) {
 			throw new BeanInitializationException(
 					"DispatcherPortlet needs exactly 1 strategy for interface [" + strategyInterface.getName() + "]");
 		}
 		return strategies.get(0);
 	}
 
 	/**
 	 * Create a List of default strategy objects for the given strategy interface.
 	 * <p>The default implementation uses the "DispatcherPortlet.properties" file
 	 * (in the same package as the DispatcherPortlet class) to determine the class names.
 	 * It instantiates the strategy objects and satisifies ApplicationContextAware
 	 * if necessary.
 	 * @param context the current Portlet ApplicationContext
 	 * @param strategyInterface the strategy interface
 	 * @return the List of corresponding strategy objects
 	 */
 	@SuppressWarnings("unchecked")
 	protected <T> List<T> getDefaultStrategies(ApplicationContext context, Class<T> strategyInterface) {
 		String key = strategyInterface.getName();
 		String value = defaultStrategies.getProperty(key);
 		if (value != null) {
 			String[] classNames = StringUtils.commaDelimitedListToStringArray(value);
 			List<T> strategies = new ArrayList<T>(classNames.length);
 			for (String className : classNames) {
 				try {
 					Class<?> clazz = ClassUtils.forName(className, DispatcherPortlet.class.getClassLoader());
 					Object strategy = createDefaultStrategy(context, clazz);
 					strategies.add((T) strategy);
 				}
 				catch (ClassNotFoundException ex) {
 					throw new BeanInitializationException(
 							"Could not find DispatcherPortlet's default strategy class [" + className +
 									"] for interface [" + key + "]", ex);
 				}
 				catch (LinkageError err) {
 					throw new BeanInitializationException(
 							"Error loading DispatcherPortlet's default strategy class [" + className +
 									"] for interface [" + key + "]: problem with class file or dependent class", err);
 				}
 			}
 			return strategies;
 		}
 		else {
 			return new LinkedList<T>();
 		}
 	}
 
 	/**
 	 * Create a default strategy.
 	 * <p>The default implementation uses
 	 * {@link org.springframework.beans.factory.config.AutowireCapableBeanFactory#createBean}.
 	 * @param context the current Portlet ApplicationContext
 	 * @param clazz the strategy implementation class to instantiate
 	 * @return the fully configured strategy instance
 	 * @see org.springframework.context.ApplicationContext#getAutowireCapableBeanFactory()
 	 */
 	protected Object createDefaultStrategy(ApplicationContext context, Class<?> clazz) {
 		return context.getAutowireCapableBeanFactory().createBean(clazz);
 	}
 
 
 	/**
 	 * Obtain this portlet's PortletMultipartResolver, if any.
 	 * @return the PortletMultipartResolver used by this portlet, or {@code null}
 	 * if none (indicating that no multipart support is available)
 	 */
 	public PortletMultipartResolver getMultipartResolver() {
 		return this.multipartResolver;
 	}
 
 
 	/**
 	 * Processes the actual dispatching to the handler for action requests.
 	 * <p>The handler will be obtained by applying the portlet's HandlerMappings in order.
 	 * The HandlerAdapter will be obtained by querying the portlet's installed
 	 * HandlerAdapters to find the first that supports the handler class.
 	 * @param request current portlet action request
 	 * @param response current portlet Action response
 	 * @throws Exception in case of any kind of processing failure
 	 */
 	@Override
 	protected void doActionService(ActionRequest request, ActionResponse response) throws Exception {
 		if (logger.isDebugEnabled()) {
 			logger.debug("DispatcherPortlet with name '" + getPortletName() + "' received action request");
 		}
 
 		ActionRequest processedRequest = request;
 		HandlerExecutionChain mappedHandler = null;
 		int interceptorIndex = -1;
 
 		try {
 			processedRequest = checkMultipart(request);
 
 			// Determine handler for the current request.
 			mappedHandler = getHandler(processedRequest);
 			if (mappedHandler == null || mappedHandler.getHandler() == null) {
 				noHandlerFound(processedRequest, response);
 				return;
 			}
 
 			// Apply preHandle methods of registered interceptors.
 			HandlerInterceptor[] interceptors = mappedHandler.getInterceptors();
 			if (interceptors != null) {
 				for (int i = 0; i < interceptors.length; i++) {
 					HandlerInterceptor interceptor = interceptors[i];
 					if (!interceptor.preHandleAction(processedRequest, response, mappedHandler.getHandler())) {
 						triggerAfterActionCompletion(mappedHandler, interceptorIndex, processedRequest, response, null);
 						return;
 					}
 					interceptorIndex = i;
 				}
 			}
 
 			// Actually invoke the handler.
 			HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());
 			ha.handleAction(processedRequest, response, mappedHandler.getHandler());
 
 			// Trigger after-completion for successful outcome.
 			triggerAfterActionCompletion(mappedHandler, interceptorIndex, processedRequest, response, null);
 		}
 
 		catch (Exception ex) {
 			// Trigger after-completion for thrown exception.
 			triggerAfterActionCompletion(mappedHandler, interceptorIndex, processedRequest, response, ex);
 			// Forward the exception to the render phase to be displayed.
 			if (this.forwardActionException) {
 				try {
 					exposeActionException(request, response, ex);
 					logger.debug("Caught exception during action phase - forwarding to render phase", ex);
 				}
 				catch (IllegalStateException ex2) {
 					// Probably sendRedirect called... need to rethrow exception immediately.
 					throw ex;
 				}
 			}
 			else {
 				throw ex;
 			}
 		}
 		catch (Error err) {
 			PortletException ex =
 					new PortletException("Error occured during request processing: " + err.getMessage(), err);
 			// Trigger after-completion for thrown exception.
 			triggerAfterActionCompletion(mappedHandler, interceptorIndex, processedRequest, response, ex);
 			throw ex;
 		}
 
 		finally {
 			// Clean up any resources used by a multipart request.
 			if (processedRequest instanceof MultipartActionRequest && processedRequest != request) {
 				this.multipartResolver.cleanupMultipart((MultipartActionRequest) processedRequest);
 			}
 		}
 	}
 
 	/**
 	 * Processes the actual dispatching to the handler for render requests.
 	 * <p>The handler will be obtained by applying the portlet's HandlerMappings in order.
 	 * The HandlerAdapter will be obtained by querying the portlet's installed
 	 * HandlerAdapters to find the first that supports the handler class.
 	 * @param request current portlet render request
 	 * @param response current portlet render response
 	 * @throws Exception in case of any kind of processing failure
 	 */
 	@Override
 	protected void doRenderService(RenderRequest request, RenderResponse response) throws Exception {
 		if (logger.isDebugEnabled()) {
 			logger.debug("DispatcherPortlet with name '" + getPortletName() + "' received render request");
 		}
 
 		HandlerExecutionChain mappedHandler = null;
 		int interceptorIndex = -1;
 
 		try {
 			ModelAndView mv;
 			try {
 				// Determine handler for the current request.
 				mappedHandler = getHandler(request);
 				if (mappedHandler == null || mappedHandler.getHandler() == null) {
 					noHandlerFound(request, response);
 					return;
 				}
 
 				// Apply preHandle methods of registered interceptors.
 				HandlerInterceptor[] interceptors = mappedHandler.getInterceptors();
 				if (interceptors != null) {
 					for (int i = 0; i < interceptors.length; i++) {
 						HandlerInterceptor interceptor = interceptors[i];
 						if (!interceptor.preHandleRender(request, response, mappedHandler.getHandler())) {
 							triggerAfterRenderCompletion(mappedHandler, interceptorIndex, request, response, null);
 							return;
 						}
 						interceptorIndex = i;
 					}
 				}
 
 				// Check for forwarded exception from the action phase
 				PortletSession session = request.getPortletSession(false);
 				if (session != null) {
 					if (request.getParameter(ACTION_EXCEPTION_RENDER_PARAMETER) != null) {
 						Exception ex = (Exception) session.getAttribute(ACTION_EXCEPTION_SESSION_ATTRIBUTE);
 						if (ex != null) {
 							logger.debug("Render phase found exception caught during action phase - rethrowing it");
 							throw ex;
 						}
 					}
 					else {
 						session.removeAttribute(ACTION_EXCEPTION_SESSION_ATTRIBUTE);
 					}
 				}
 
 				// Actually invoke the handler.
 				HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());
 				mv = ha.handleRender(request, response, mappedHandler.getHandler());
 
 				// Apply postHandle methods of registered interceptors.
 				if (interceptors != null) {
 					for (int i = interceptors.length - 1; i >= 0; i--) {
 						HandlerInterceptor interceptor = interceptors[i];
 						interceptor.postHandleRender(request, response, mappedHandler.getHandler(), mv);
 					}
 				}
 			}
 			catch (ModelAndViewDefiningException ex) {
 				logger.debug("ModelAndViewDefiningException encountered", ex);
 				mv = ex.getModelAndView();
 			}
 			catch (Exception ex) {
 				Object handler = (mappedHandler != null ? mappedHandler.getHandler() : null);
 				mv = processHandlerException(request, response, handler, ex);
 			}
 
 			// Did the handler return a view to render?
 			if (mv != null && !mv.isEmpty()) {
 				render(mv, request, response);
 			}
 			else {
 				if (logger.isDebugEnabled()) {
 					logger.debug("Null ModelAndView returned to DispatcherPortlet with name '" +
 							getPortletName() + "': assuming HandlerAdapter completed request handling");
 				}
 			}
 
 			// Trigger after-completion for successful outcome.
 			triggerAfterRenderCompletion(mappedHandler, interceptorIndex, request, response, null);
 		}
 
 		catch (Exception ex) {
 			// Trigger after-completion for thrown exception.
 			triggerAfterRenderCompletion(mappedHandler, interceptorIndex, request, response, ex);
 			throw ex;
 		}
 		catch (Error err) {
 			PortletException ex =
 					new PortletException("Error occured during request processing: " + err.getMessage(), err);
 			// Trigger after-completion for thrown exception.
 			triggerAfterRenderCompletion(mappedHandler, interceptorIndex, request, response, ex);
 			throw ex;
 		}
 	}
 
 	/**
 	 * Processes the actual dispatching to the handler for resource requests.
 	 * <p>The handler will be obtained by applying the portlet's HandlerMappings in order.
 	 * The HandlerAdapter will be obtained by querying the portlet's installed
 	 * HandlerAdapters to find the first that supports the handler class.
 	 * @param request current portlet render request
 	 * @param response current portlet render response
 	 * @throws Exception in case of any kind of processing failure
 	 */
 	@Override
 	protected void doResourceService(ResourceRequest request, ResourceResponse response) throws Exception {
 		if (logger.isDebugEnabled()) {
 			logger.debug("DispatcherPortlet with name '" + getPortletName() + "' received resource request");
 		}
 
 		HandlerExecutionChain mappedHandler = null;
 		int interceptorIndex = -1;
 
 		try {
 			ModelAndView mv;
 			try {
 				// Determine handler for the current request.
 				mappedHandler = getHandler(request);
 				if (mappedHandler == null || mappedHandler.getHandler() == null) {
 					noHandlerFound(request, response);
 					return;
 				}
 
 				// Apply preHandle methods of registered interceptors.
 				HandlerInterceptor[] interceptors = mappedHandler.getInterceptors();
 				if (interceptors != null) {
 					for (int i = 0; i < interceptors.length; i++) {
 						HandlerInterceptor interceptor = interceptors[i];
 						if (!interceptor.preHandleResource(request, response, mappedHandler.getHandler())) {
 							triggerAfterResourceCompletion(mappedHandler, interceptorIndex, request, response, null);
 							return;
 						}
 						interceptorIndex = i;
 					}
 				}
 
 				// Actually invoke the handler.
 				HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());
 				mv = ha.handleResource(request, response, mappedHandler.getHandler());
 
 				// Apply postHandle methods of registered interceptors.
 				if (interceptors != null) {
 					for (int i = interceptors.length - 1; i >= 0; i--) {
 						HandlerInterceptor interceptor = interceptors[i];
 						interceptor.postHandleResource(request, response, mappedHandler.getHandler(), mv);
 					}
 				}
 			}
 			catch (ModelAndViewDefiningException ex) {
 				logger.debug("ModelAndViewDefiningException encountered", ex);
 				mv = ex.getModelAndView();
 			}
 			catch (Exception ex) {
 				Object handler = (mappedHandler != null ? mappedHandler.getHandler() : null);
 				mv = processHandlerException(request, response, handler, ex);
 			}
 
 			// Did the handler return a view to render?
 			if (mv != null && !mv.isEmpty()) {
 				render(mv, request, response);
 			}
 			else {
 				if (logger.isDebugEnabled()) {
 					logger.debug("Null ModelAndView returned to DispatcherPortlet with name '" +
 							getPortletName() + "': assuming HandlerAdapter completed request handling");
 				}
 			}
 
 			// Trigger after-completion for successful outcome.
 			triggerAfterResourceCompletion(mappedHandler, interceptorIndex, request, response, null);
 		}
 
 		catch (Exception ex) {
 			// Trigger after-completion for thrown exception.
 			triggerAfterResourceCompletion(mappedHandler, interceptorIndex, request, response, ex);
 			throw ex;
 		}
 		catch (Error err) {
 			PortletException ex =
 					new PortletException("Error occured during request processing: " + err.getMessage(), err);
 			// Trigger after-completion for thrown exception.
 			triggerAfterResourceCompletion(mappedHandler, interceptorIndex, request, response, ex);
 			throw ex;
 		}
 	}
 
 	/**
 	 * Processes the actual dispatching to the handler for event requests.
 	 * <p>The handler will be obtained by applying the portlet's HandlerMappings in order.
 	 * The HandlerAdapter will be obtained by querying the portlet's installed
 	 * HandlerAdapters to find the first that supports the handler class.
 	 * @param request current portlet action request
 	 * @param response current portlet Action response
 	 * @throws Exception in case of any kind of processing failure
 	 */
 	@Override
 	protected void doEventService(EventRequest request, EventResponse response) throws Exception {
 		if (logger.isDebugEnabled()) {
 			logger.debug("DispatcherPortlet with name '" + getPortletName() + "' received action request");
 		}
 
 		HandlerExecutionChain mappedHandler = null;
 		int interceptorIndex = -1;
 
 		try {
 			// Determine handler for the current request.
 			mappedHandler = getHandler(request);
 			if (mappedHandler == null || mappedHandler.getHandler() == null) {
 				noHandlerFound(request, response);
 				return;
 			}
 
 			// Apply preHandle methods of registered interceptors.
 			HandlerInterceptor[] interceptors = mappedHandler.getInterceptors();
 			if (interceptors != null) {
 				for (int i = 0; i < interceptors.length; i++) {
 					HandlerInterceptor interceptor = interceptors[i];
 					if (!interceptor.preHandleEvent(request, response, mappedHandler.getHandler())) {
 						triggerAfterEventCompletion(mappedHandler, interceptorIndex, request, response, null);
 						return;
 					}
 					interceptorIndex = i;
 				}
 			}
 
 			// Actually invoke the handler.
 			HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());
 			ha.handleEvent(request, response, mappedHandler.getHandler());
 
 			// Trigger after-completion for successful outcome.
 			triggerAfterEventCompletion(mappedHandler, interceptorIndex, request, response, null);
 		}
 
 		catch (Exception ex) {
 			// Trigger after-completion for thrown exception.
 			triggerAfterEventCompletion(mappedHandler, interceptorIndex, request, response, ex);
 			// Forward the exception to the render phase to be displayed.
 			if (this.forwardEventException) {
 				try {
 					exposeActionException(request, response, ex);
 					logger.debug("Caught exception during event phase - forwarding to render phase", ex);
 				}
 				catch (IllegalStateException ex2) {
 					// Probably sendRedirect called... need to rethrow exception immediately.
 					throw ex;
 				}
 			}
 			else {
 				throw ex;
 			}
 		}
 		catch (Error err) {
 			PortletException ex =
 					new PortletException("Error occured during request processing: " + err.getMessage(), err);
 			// Trigger after-completion for thrown exception.
 			triggerAfterEventCompletion(mappedHandler, interceptorIndex, request, response, ex);
 			throw ex;
 		}
 	}
 
 
 	/**
 	 * Convert the request into a multipart request, and make multipart resolver available.
 	 * If no multipart resolver is set, simply use the existing request.
 	 * @param request current HTTP request
 	 * @return the processed request (multipart wrapper if necessary)
 	 */
 	protected ActionRequest checkMultipart(ActionRequest request) throws MultipartException {
 		if (this.multipartResolver != null && this.multipartResolver.isMultipart(request)) {
 			if (request instanceof MultipartActionRequest) {
 				logger.debug("Request is already a MultipartActionRequest - probably in a forward");
 			}
 			else {
 				return this.multipartResolver.resolveMultipart(request);
 			}
 		}
 		// If not returned before: return original request.
 		return request;
 	}
 
 	/**
 	 * Return the HandlerExecutionChain for this request.
 	 * Try all handler mappings in order.
 	 * @param request current portlet request
 	 * @return the HandlerExecutionChain, or null if no handler could be found
 	 */
 	protected HandlerExecutionChain getHandler(PortletRequest request) throws Exception {
 		for (HandlerMapping hm : this.handlerMappings) {
 			if (logger.isDebugEnabled()) {
 				logger.debug(
 						"Testing handler map [" + hm + "] in DispatcherPortlet with name '" + getPortletName() + "'");
 			}
 			HandlerExecutionChain handler = hm.getHandler(request);
 			if (handler != null) {
 				return handler;
 			}
 		}
 		return null;
 	}
 
 	/**
 	 * No handler found -> throw appropriate exception.
 	 * @param request current portlet request
 	 * @param response current portlet response
 	 * @throws Exception if preparing the response failed
 	 */
 	protected void noHandlerFound(PortletRequest request, PortletResponse response) throws Exception {
 		if (pageNotFoundLogger.isWarnEnabled()) {
 			pageNotFoundLogger.warn("No handler found for current request " +
 					"in DispatcherPortlet with name '" + getPortletName() +
 					"', mode '" + request.getPortletMode() +
 					"', phase '" + request.getAttribute(PortletRequest.LIFECYCLE_PHASE) +
 					"', parameters " + StylerUtils.style(request.getParameterMap()));
 		}
 		throw new NoHandlerFoundException("No handler found for portlet request", request);
 	}
 
 	/**
 	 * Return the HandlerAdapter for this handler object.
 	 * @param handler the handler object to find an adapter for
 	 * @throws PortletException if no HandlerAdapter can be found for the handler.
 	 * This is a fatal error.
 	 */
 	protected HandlerAdapter getHandlerAdapter(Object handler) throws PortletException {
 		for (HandlerAdapter ha : this.handlerAdapters) {
 			if (logger.isDebugEnabled()) {
 				logger.debug("Testing handler adapter [" + ha + "]");
 			}
 			if (ha.supports(handler)) {
 				return ha;
 			}
 		}
 		throw new PortletException("No adapter for handler [" + handler +
 				"]: Does your handler implement a supported interface like Controller?");
 	}
 
 	/**
 	 * Expose the given action exception to the given response.
 	 * @param request current portlet request
 	 * @param response current portlet response
 	 * @param ex the action exception (may also come from an event phase)
 	 */
 	protected void exposeActionException(PortletRequest request, StateAwareResponse response, Exception ex) {
 		// Copy all parameters unless overridden in the action handler.
 		Enumeration<String> paramNames = request.getParameterNames();
 		while (paramNames.hasMoreElements()) {
 			String paramName = paramNames.nextElement();
 			String[] paramValues = request.getParameterValues(paramName);
 			if (paramValues != null && !response.getRenderParameterMap().containsKey(paramName)) {
 				response.setRenderParameter(paramName, paramValues);
 			}
 		}
 		response.setRenderParameter(ACTION_EXCEPTION_RENDER_PARAMETER, ex.toString());
 		request.getPortletSession().setAttribute(ACTION_EXCEPTION_SESSION_ATTRIBUTE, ex);
 	}
 
 
 	/**
 	 * Render the given ModelAndView. This is the last stage in handling a request.
 	 * It may involve resolving the view by name.
 	 * @param mv the ModelAndView to render
 	 * @param request current portlet render request
 	 * @param response current portlet render response
 	 * @throws Exception if there's a problem rendering the view
 	 */
 	protected void render(ModelAndView mv, PortletRequest request, MimeResponse response) throws Exception {
 		View view;
 		if (mv.isReference()) {
 			// We need to resolve the view name.
 			view = resolveViewName(mv.getViewName(), mv.getModelInternal(), request);
 			if (view == null) {
 				throw new PortletException("Could not resolve view with name '" + mv.getViewName() +
 						"' in portlet with name '" + getPortletName() + "'");
 			}
 		}
 		else {
 			// No need to lookup: the ModelAndView object contains the actual View object.
 			Object viewObject = mv.getView();
 			if (viewObject == null) {
 				throw new PortletException("ModelAndView [" + mv + "] neither contains a view name nor a " +
 						"View object in portlet with name '" + getPortletName() + "'");
 			}
 			if (!(viewObject instanceof View)) {
 				throw new PortletException(
 						"View object [" + viewObject + "] is not an instance of [org.springframework.web.servlet.View] - " +
 						"DispatcherPortlet does not support any other view types");
 			}
 			view = (View) viewObject;
 		}
 
 		// Set the content type on the response if needed and if possible.
 		// The Portlet spec requires the content type to be set on the RenderResponse;
 		// it's not sufficient to let the View set it on the ServletResponse.
 		if (response.getContentType() != null) {
 			if (logger.isDebugEnabled()) {
 				logger.debug("Portlet response content type already set to [" + response.getContentType() + "]");
 			}
 		}
 		else {
 			// No Portlet content type specified yet -> use the view-determined type.
 			String contentType = view.getContentType();
 			if (contentType != null) {
 				if (logger.isDebugEnabled()) {
 					logger.debug("Setting portlet response content type to view-determined type [" + contentType + "]");
 				}
 				response.setContentType(contentType);
 			}
 		}
 
 		doRender(view, mv.getModelInternal(), request, response);
 	}
 
 	/**
 	 * Resolve the given view name into a View object (to be rendered).
 	 * <p>Default implementations asks all ViewResolvers of this dispatcher.
 	 * Can be overridden for custom resolution strategies, potentially based
 	 * on specific model attributes or request parameters.
 	 * @param viewName the name of the view to resolve
 	 * @param model the model to be passed to the view
 	 * @param request current portlet render request
 	 * @return the View object, or null if none found
 	 * @throws Exception if the view cannot be resolved
 	 * (typically in case of problems creating an actual View object)
 	 * @see ViewResolver#resolveViewName
 	 */
 	protected View resolveViewName(String viewName, Map<String, ?> model, PortletRequest request) throws Exception {
 		for (ViewResolver viewResolver : this.viewResolvers) {
 			View view = viewResolver.resolveViewName(viewName, request.getLocale());
 			if (view != null) {
 				return view;
 			}
 		}
 		return null;
 	}
 
 	/**
 	 * Actually render the given view.
 	 * <p>The default implementation delegates to
 	 * {@link org.springframework.web.servlet.ViewRendererServlet}.
 	 * @param view the View to render
 	 * @param model the associated model
 	 * @param request current portlet render/resource request
 	 * @param response current portlet render/resource response
 	 * @throws Exception if there's a problem rendering the view
 	 */
 	protected void doRender(View view, Map<String, ?> model, PortletRequest request, MimeResponse response) throws Exception {
 		// Expose Portlet ApplicationContext to view objects.
 		request.setAttribute(ViewRendererServlet.WEB_APPLICATION_CONTEXT_ATTRIBUTE, getPortletApplicationContext());
 
 		// These attributes are required by the ViewRendererServlet.
 		request.setAttribute(ViewRendererServlet.VIEW_ATTRIBUTE, view);
 		request.setAttribute(ViewRendererServlet.MODEL_ATTRIBUTE, model);
 
 		// Include the content of the view in the render/resource response.
 		doDispatch(getPortletContext().getRequestDispatcher(this.viewRendererUrl), request, response);
 	}
 
 	/**
 	 * Perform a dispatch on the given PortletRequestDispatcher.
 	 * <p>The default implementation uses a forward for resource requests
 	 * and an include for render requests.
 	 * @param dispatcher the PortletRequestDispatcher to use
 	 * @param request current portlet render/resource request
 	 * @param response current portlet render/resource response
 	 * @throws Exception if there's a problem performing the dispatch
 	 */
 	protected void doDispatch(PortletRequestDispatcher dispatcher, PortletRequest request, MimeResponse response)
 			throws Exception {
 
 		// In general, we prefer a forward for resource responses, in order to have full Servlet API
 		// support in the target resource (e.g. on uPortal). However, on Liferay, a resource forward
 		// displays an empty page, so we have to resort to an include there...
 		if (PortletRequest.RESOURCE_PHASE.equals(request.getAttribute(PortletRequest.LIFECYCLE_PHASE)) &&
 				!dispatcher.getClass().getName().startsWith("com.liferay")) {
 			dispatcher.forward(request, response);
 		}
 		else {
 			dispatcher.include(request, response);
 		}
 	}
 
 
 	/**
 	 * Determine an error ModelAndView via the registered HandlerExceptionResolvers.
 	 * @param request current portlet request
 	 * @param response current portlet response
 	 * @param handler the executed handler, or null if none chosen at the time of
 	 * the exception (for example, if multipart resolution failed)
 	 * @param ex the exception that got thrown during handler execution
 	 * @return a corresponding ModelAndView to forward to
 	 * @throws Exception if no error ModelAndView found
 	 */
 	protected ModelAndView processHandlerException(
 			RenderRequest request, RenderResponse response, Object handler, Exception ex)
 			throws Exception {
 
 		ModelAndView exMv = null;
 		for (Iterator<HandlerExceptionResolver> it = this.handlerExceptionResolvers.iterator(); exMv == null && it.hasNext();) {
 			HandlerExceptionResolver resolver = it.next();
 			exMv = resolver.resolveException(request, response, handler, ex);
 		}
 		if (exMv != null) {
 			if (logger.isDebugEnabled()) {
 				logger.debug("HandlerExceptionResolver returned ModelAndView [" + exMv + "] for exception");
 			}
 			logger.warn("Handler execution resulted in exception - forwarding to resolved error view", ex);
 			return exMv;
 		}
 		else {
 			throw ex;
 		}
 	}
 
 	/**
 	 * Determine an error ModelAndView via the registered HandlerExceptionResolvers.
 	 * @param request current portlet request
 	 * @param response current portlet response
 	 * @param handler the executed handler, or null if none chosen at the time of
 	 * the exception (for example, if multipart resolution failed)
 	 * @param ex the exception that got thrown during handler execution
 	 * @return a corresponding ModelAndView to forward to
 	 * @throws Exception if no error ModelAndView found
 	 */
 	protected ModelAndView processHandlerException(
 			ResourceRequest request, ResourceResponse response, Object handler, Exception ex)
 			throws Exception {
 
 		ModelAndView exMv = null;
 		for (Iterator<HandlerExceptionResolver> it = this.handlerExceptionResolvers.iterator(); exMv == null && it.hasNext();) {
 			HandlerExceptionResolver resolver = it.next();
 			exMv = resolver.resolveException(request, response, handler, ex);
 		}
 		if (exMv != null) {
 			if (logger.isDebugEnabled()) {
 				logger.debug("HandlerExceptionResolver returned ModelAndView [" + exMv + "] for exception");
 			}
 			logger.warn("Handler execution resulted in exception - forwarding to resolved error view", ex);
 			return exMv;
 		}
 		else {
 			throw ex;
 		}
 	}
 
 	/**
 	 * Trigger afterCompletion callbacks on the mapped HandlerInterceptors.
 	 * Will just invoke afterCompletion for all interceptors whose preHandle
 	 * invocation has successfully completed and returned true.
 	 * @param mappedHandler the mapped HandlerExecutionChain
 	 * @param interceptorIndex index of last interceptor that successfully completed
 	 * @param ex Exception thrown on handler execution, or null if none
 	 * @see HandlerInterceptor#afterRenderCompletion
 	 */
 	private void triggerAfterActionCompletion(HandlerExecutionChain mappedHandler, int interceptorIndex,
 			ActionRequest request, ActionResponse response, Exception ex)
 			throws Exception {
 
 		// Apply afterCompletion methods of registered interceptors.
 		if (mappedHandler != null) {
 			HandlerInterceptor[] interceptors = mappedHandler.getInterceptors();
 			if (interceptors != null) {
 				for (int i = interceptorIndex; i >= 0; i--) {
 					HandlerInterceptor interceptor = interceptors[i];
 					try {
 						interceptor.afterActionCompletion(request, response, mappedHandler.getHandler(), ex);
 					}
 					catch (Throwable ex2) {
 						logger.error("HandlerInterceptor.afterCompletion threw exception", ex2);
 					}
 				}
 			}
 		}
 	}
 
 	/**
 	 * Trigger afterCompletion callbacks on the mapped HandlerInterceptors.
 	 * Will just invoke afterCompletion for all interceptors whose preHandle
 	 * invocation has successfully completed and returned true.
 	 * @param mappedHandler the mapped HandlerExecutionChain
 	 * @param interceptorIndex index of last interceptor that successfully completed
 	 * @param ex Exception thrown on handler execution, or null if none
 	 * @see HandlerInterceptor#afterRenderCompletion
 	 */
 	private void triggerAfterRenderCompletion(HandlerExecutionChain mappedHandler, int interceptorIndex,
 			RenderRequest request, RenderResponse response, Exception ex)
 			throws Exception {
 
 		// Apply afterCompletion methods of registered interceptors.
 		if (mappedHandler != null) {
 			HandlerInterceptor[] interceptors = mappedHandler.getInterceptors();
 			if (interceptors != null) {
 				for (int i = interceptorIndex; i >= 0; i--) {
 					HandlerInterceptor interceptor = interceptors[i];
 					try {
 						interceptor.afterRenderCompletion(request, response, mappedHandler.getHandler(), ex);
 					}
 					catch (Throwable ex2) {
 						logger.error("HandlerInterceptor.afterCompletion threw exception", ex2);
 					}
 				}
 			}
 		}
 	}
 
 	/**
 	 * Trigger afterCompletion callbacks on the mapped HandlerInterceptors.
 	 * Will just invoke afterCompletion for all interceptors whose preHandle
 	 * invocation has successfully completed and returned true.
 	 * @param mappedHandler the mapped HandlerExecutionChain
 	 * @param interceptorIndex index of last interceptor that successfully completed
 	 * @param ex Exception thrown on handler execution, or null if none
 	 * @see HandlerInterceptor#afterRenderCompletion
 	 */
 	private void triggerAfterResourceCompletion(HandlerExecutionChain mappedHandler, int interceptorIndex,
 			ResourceRequest request, ResourceResponse response, Exception ex)
 			throws Exception {
 
 		// Apply afterCompletion methods of registered interceptors.
 		if (mappedHandler != null) {
 			HandlerInterceptor[] interceptors = mappedHandler.getInterceptors();
 			if (interceptors != null) {
 				for (int i = interceptorIndex; i >= 0; i--) {
 					HandlerInterceptor interceptor = interceptors[i];
 					try {
 						interceptor.afterResourceCompletion(request, response, mappedHandler.getHandler(), ex);
 					}
 					catch (Throwable ex2) {
 						logger.error("HandlerInterceptor.afterCompletion threw exception", ex2);
 					}
 				}
 			}
 		}
 	}
 
 	/**
 	 * Trigger afterCompletion callbacks on the mapped HandlerInterceptors.
 	 * Will just invoke afterCompletion for all interceptors whose preHandle
 	 * invocation has successfully completed and returned true.
 	 * @param mappedHandler the mapped HandlerExecutionChain
 	 * @param interceptorIndex index of last interceptor that successfully completed
 	 * @param ex Exception thrown on handler execution, or null if none
 	 * @see HandlerInterceptor#afterRenderCompletion
 	 */
 	private void triggerAfterEventCompletion(HandlerExecutionChain mappedHandler, int interceptorIndex,
 			EventRequest request, EventResponse response, Exception ex)
 			throws Exception {
 
 		// Apply afterCompletion methods of registered interceptors.
 		if (mappedHandler != null) {
 			HandlerInterceptor[] interceptors = mappedHandler.getInterceptors();
 			if (interceptors != null) {
 				for (int i = interceptorIndex; i >= 0; i--) {
 					HandlerInterceptor interceptor = interceptors[i];
 					try {
 						interceptor.afterEventCompletion(request, response, mappedHandler.getHandler(), ex);
 					}
 					catch (Throwable ex2) {
 						logger.error("HandlerInterceptor.afterCompletion threw exception", ex2);
 					}
 				}
 			}
 		}
 	}
 
 }