AnnotationMethodHandlerExceptionResolver (Spring Framework 3.2.1.RELEASE API)
Date: 2013-01-24

org.springframework.web.portlet.mvc.annotation

## Class AnnotationMethodHandlerExceptionResolver

- java.lang.Object
- - org.springframework.web.portlet.handler.AbstractHandlerExceptionResolver
  - - org.springframework.web.portlet.mvc.annotation.AnnotationMethodHandlerExceptionResolver

- All Implemented Interfaces:
    Ordered, HandlerExceptionResolver

      public class AnnotationMethodHandlerExceptionResolver
      extends AbstractHandlerExceptionResolver

  Implementation of the `HandlerExceptionResolver` interface that handles exceptions through the `ExceptionHandler` annotation.

  This exception resolver is enabled by default in the `DispatcherPortlet`.

  Since:
    3.0
  Author:
    Arjen Poutsma, Juergen Hoeller

- - ### Field Summary

    - ### Fields inherited from class org.springframework.web.portlet.handler.AbstractHandlerExceptionResolver

      `logger`

    - ### Fields inherited from interface org.springframework.core.Ordered

      `HIGHEST_PRECEDENCE, LOWEST_PRECEDENCE`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `AnnotationMethodHandlerExceptionResolver()`

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `protected ModelAndView` | `doResolveException(PortletRequest request, MimeResponse response, Object handler, Exception ex)` Actually resolve the given exception that got thrown during on handler execution, returning a ModelAndView that represents a specific error page if appropriate.
    `protected List<Class<? extends Throwable>>` | `getHandledExceptions(Method method)` Returns all the exception classes handled by the given method.
    `protected Object` | `resolveCommonArgument(MethodParameter methodParameter, NativeWebRequest webRequest, Exception thrownException)` Resolves common method arguments.
    `protected Object` | `resolveStandardArgument(Class<?> parameterType, NativeWebRequest webRequest, Exception thrownException)` Resolves standard method arguments.
    `void` | `setCustomArgumentResolver(WebArgumentResolver argumentResolver)` Set a custom ArgumentResolvers to use for special method parameter types.
    `void` | `setCustomArgumentResolvers(WebArgumentResolver[] argumentResolvers)` Set one or more custom ArgumentResolvers to use for special method parameter types.

    - ### Methods inherited from class org.springframework.web.portlet.handler.AbstractHandlerExceptionResolver

      `buildLogMessage, getOrder, logException, resolveException, resolveException, setMappedHandlerClasses, setMappedHandlers, setOrder, setRenderWhenMinimized, setWarnLogCategory, shouldApplyTo`

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Constructor Detail

    - #### AnnotationMethodHandlerExceptionResolver

          public AnnotationMethodHandlerExceptionResolver()

  - ### Method Detail

    - #### setCustomArgumentResolver

          public void setCustomArgumentResolver(WebArgumentResolver argumentResolver)

      Set a custom ArgumentResolvers to use for special method parameter types.

      Such a custom ArgumentResolver will kick in first, having a chance to resolve an argument value before the standard argument handling kicks in.

    - #### setCustomArgumentResolvers

          public void setCustomArgumentResolvers(WebArgumentResolver[] argumentResolvers)

      Set one or more custom ArgumentResolvers to use for special method parameter types.

      Any such custom ArgumentResolver will kick in first, having a chance to resolve an argument value before the standard argument handling kicks in.

    - #### doResolveException

          protected ModelAndView doResolveException(PortletRequest request,
                                        MimeResponse response,
                                        Object handler,
                                        Exception ex)

      Description copied from class: `AbstractHandlerExceptionResolver`
      Actually resolve the given exception that got thrown during on handler execution, returning a ModelAndView that represents a specific error page if appropriate.

      Must be overridden in subclasses, in order to apply specific exception checks. Note that this template method will be invoked after checking whether this resolved applies ("mappedHandlers" etc), so an implementation may simply proceed with its actual exception handling.

      Specified by:
        `doResolveException` in class `AbstractHandlerExceptionResolver`
      Parameters:
        `request` - current portlet request
        `response` - current portlet response
        `handler` - the executed handler, or null if none chosen at the time of the exception (for example, if multipart resolution failed)
        `ex` - the exception that got thrown during handler execution
      Returns:
        a corresponding ModelAndView to forward to, or null for default processing

    - #### getHandledExceptions

          protected List<Class<? extends Throwable>> getHandledExceptions(Method method)

      Returns all the exception classes handled by the given method.

      Default implementation looks for exceptions in the annotation, or - if that annotation element is empty - any exceptions listed in the method parameters if the method is annotated with `@ExceptionHandler`.

      Parameters:
        `method` - the method
      Returns:
        the handled exceptions

    - #### resolveCommonArgument

          protected Object resolveCommonArgument(MethodParameter methodParameter,
                                     NativeWebRequest webRequest,
                                     Exception thrownException)
                                          throws Exception

      Resolves common method arguments. Delegates to registered `argumentResolvers` first, then checking `resolveStandardArgument(java.lang.Class<?>, org.springframework.web.context.request.NativeWebRequest, java.lang.Exception)`.
      Parameters:
        `methodParameter` - the method parameter
        `webRequest` - the request
        `thrownException` - the exception thrown
      Returns:
        the argument value, or `WebArgumentResolver.UNRESOLVED`
      Throws:
        `Exception`

    - #### resolveStandardArgument

          protected Object resolveStandardArgument(Class<?> parameterType,
                                       NativeWebRequest webRequest,
                                       Exception thrownException)
                                            throws Exception

      Resolves standard method arguments. The default implementation handles `NativeWebRequest`, `ServletRequest`, `ServletResponse`, `HttpSession`, `Principal`, `Locale`, request `InputStream`, request `Reader`, response `OutputStream`, response `Writer`, and the given `thrownException`.
      Parameters:
        `parameterType` - the method parameter type
        `webRequest` - the request
        `thrownException` - the exception thrown
      Returns:
        the argument value, or `WebArgumentResolver.UNRESOLVED`
      Throws:
        `Exception`