## 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
`DefaultAnnotationHandlerMapping()`

Method Summary
`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.
`protected void` `validateHandler(Object handler, PortletRequest request)` Validate the given annotated handler against the current request.
`protected void` `validateMapping(RequestMapping mapping, PortletRequest request)` Validate the given type-level mapping metadata against the current request, checking request method and parameter conditions.

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

### validateHandler

    protected void validateHandler(Object handler,
                                   PortletRequest request)
                            throws Exception

  Validate the given annotated handler against the current request.

  Throws:
    `Exception`
  See Also:
    `validateMapping(org.springframework.web.bind.annotation.RequestMapping, javax.portlet.PortletRequest)`

### validateMapping

    protected void validateMapping(RequestMapping mapping,
                                   PortletRequest request)
                            throws Exception

  Validate the given type-level mapping metadata against the current request, checking request method and parameter conditions.

  Parameters:
    `mapping` - the mapping metadata to validate
    `request` - current portlet request
  Throws:
    `Exception` - if validation failed