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

org.springframework.web.portlet.mvc.annotation

## Class DefaultAnnotationHandlerMapping

- java.lang.Object
- - org.springframework.context.support.ApplicationObjectSupport
  - - org.springframework.web.portlet.handler.AbstractHandlerMapping
    - - org.springframework.web.portlet.handler.AbstractMapBasedHandlerMapping<PortletMode>
      - - org.springframework.web.portlet.mvc.annotation.DefaultAnnotationHandlerMapping

- All Implemented Interfaces:
    Aware, ApplicationContextAware, Ordered, HandlerMapping

      public class DefaultAnnotationHandlerMapping
      extends AbstractMapBasedHandlerMapping<PortletMode>

  Implementation of the `HandlerMapping` interface that maps handlers based on portlet modes expressed through the `RequestMapping` annotation at the type or method level.

  Registered by default in `DispatcherPortlet`. NOTE: If you define custom HandlerMapping beans in your DispatcherPortlet context, you need to add a DefaultAnnotationHandlerMapping bean explicitly, since custom HandlerMapping beans replace the default mapping strategies. Defining a DefaultAnnotationHandlerMapping also allows for registering custom interceptors:

       <bean class="org.springframework.web.portlet.mvc.annotation.DefaultAnnotationHandlerMapping">
         <property name="interceptors">
           ...
         </property>
       </bean>

  Annotated controllers are usually marked with the `Controller` stereotype at the type level. This is not strictly necessary when `RequestMapping` is applied at the type level (since such a handler usually implements the `Controller` interface). However, `Controller` is required for detecting `RequestMapping` annotations at the method level.

  NOTE: Method-level mappings are only allowed to narrow the mapping expressed at the class level (if any). A portlet mode in combination with specific parameter conditions needs to uniquely map onto one specific handler bean, not spread across multiple handler beans. It is strongly recommended to co-locate related handler methods into the same bean.

  The `AnnotationMethodHandlerAdapter` is responsible for processing annotated handler methods, as mapped by this HandlerMapping. For `RequestMapping` at the type level, specific HandlerAdapters such as `SimpleControllerHandlerAdapter` apply.

  Since:
    2.5
  Author:
    Juergen Hoeller
  See Also:
    `RequestMapping`, `AnnotationMethodHandlerAdapter`

- - ### Nested Class Summary

    - ### Nested classes/interfaces inherited from class org.springframework.web.portlet.handler.AbstractMapBasedHandlerMapping

      `AbstractMapBasedHandlerMapping.PortletRequestMappingPredicate`

  - ### Field Summary

    - ### Fields inherited from class org.springframework.context.support.ApplicationObjectSupport

      `logger`

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

      `HIGHEST_PRECEDENCE, LOWEST_PRECEDENCE`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `DefaultAnnotationHandlerMapping()`

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `protected boolean` | `detectHandlerMethods(Class<?> handlerType, String beanName, RequestMapping typeMapping)` Derive portlet mode mappings from the handler's method-level mappings.
    `protected void` | `detectHandlers()` Register all handlers specified in the Portlet mode map for the corresponding modes.
    `protected PortletMode` | `getLookupKey(PortletRequest request)` Uses the current PortletMode as lookup key.
    `void` | `initApplicationContext()` Calls the `registerHandlers` method in addition to the superclass's initialization.

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

      `getHandlerInternal, registerHandler, registerHandler, registerHandlers, setLazyInitHandlers`

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

      `adaptInterceptor, extendInterceptors, getAdaptedInterceptors, getDefaultHandler, getHandler, getHandlerExecutionChain, getOrder, initInterceptors, setApplyWebRequestInterceptorsToRenderPhaseOnly, setDefaultHandler, setInterceptors, setOrder`

    - ### Methods inherited from class org.springframework.context.support.ApplicationObjectSupport

      `getApplicationContext, getMessageSourceAccessor, initApplicationContext, isContextRequired, requiredContextClass, setApplicationContext`

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

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

- - ### Constructor Detail

    - #### DefaultAnnotationHandlerMapping

          public DefaultAnnotationHandlerMapping()

  - ### Method Detail

    - #### initApplicationContext

          public void initApplicationContext()
                                      throws BeansException

      Calls the `registerHandlers` method in addition to the superclass's initialization.
      Overrides:
        `initApplicationContext` in class `AbstractHandlerMapping`
      Throws:
        `ApplicationContextException` - in case of initialization errors
        `BeansException` - if thrown by ApplicationContext methods
      See Also:
        `detectHandlers()`

    - #### detectHandlers

          protected void detectHandlers()
                                 throws BeansException

      Register all handlers specified in the Portlet mode map for the corresponding modes.
      Throws:
        `BeansException` - if the handler couldn't be registered

    - #### detectHandlerMethods

          protected boolean detectHandlerMethods(Class<?> handlerType,
                                     String beanName,
                                     RequestMapping typeMapping)

      Derive portlet mode mappings from the handler's method-level mappings.
      Parameters:
        `handlerType` - the handler type to introspect
        `beanName` - the name of the bean introspected
        `typeMapping` - the type level mapping (if any)
      Returns:
        `true` if at least 1 handler method has been registered; `false` otherwise

    - #### getLookupKey

          protected PortletMode getLookupKey(PortletRequest request)
                                      throws Exception

      Uses the current PortletMode as lookup key.
      Specified by:
        `getLookupKey` in class `AbstractMapBasedHandlerMapping<PortletMode>`
      Parameters:
        `request` - current portlet request
      Returns:
        the lookup key (never `null`)
      Throws:
        `Exception` - if key computation failed