Overview | Package | Class | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## org.springframework.web.servlet.mvc.annotation
Class DefaultAnnotationHandlerMapping

    java.lang.Object
      org.springframework.context.support.ApplicationObjectSupport
          org.springframework.web.context.support.WebApplicationObjectSupport
              org.springframework.web.servlet.handler.AbstractHandlerMapping
                  org.springframework.web.servlet.handler.AbstractUrlHandlerMapping
                      org.springframework.web.servlet.handler.AbstractDetectingUrlHandlerMapping
                          org.springframework.web.servlet.mvc.annotation.DefaultAnnotationHandlerMapping

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

    public class DefaultAnnotationHandlerMapping

extends AbstractDetectingUrlHandlerMapping

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

Registered by default in `DispatcherServlet` on Java 5+. NOTE: If you define custom HandlerMapping beans in your DispatcherServlet 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.servlet.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 if `RequestMapping` is not present at the type level.

NOTE: Method-level mappings are only allowed to narrow the mapping expressed at the class level (if any). HTTP paths need to uniquely map onto specific handler beans, with any given HTTP path only allowed to be mapped 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, Arjen Poutsma
See Also:
  `RequestMapping`, `AnnotationMethodHandlerAdapter`

Field Summary

Fields inherited from class org.springframework.context.support.ApplicationObjectSupport
`logger`

Fields inherited from interface org.springframework.web.servlet.HandlerMapping
`BEST_MATCHING_PATTERN_ATTRIBUTE, INTROSPECT_TYPE_LEVEL_MAPPING, PATH_WITHIN_HANDLER_MAPPING_ATTRIBUTE, PRODUCIBLE_MEDIA_TYPES_ATTRIBUTE, URI_TEMPLATE_VARIABLES_ATTRIBUTE`

Fields inherited from interface org.springframework.core.Ordered
`HIGHEST_PRECEDENCE, LOWEST_PRECEDENCE`

Constructor Summary
`DefaultAnnotationHandlerMapping()`

Method Summary
`protected void` | `addUrlsForPath(Set<String> urls, String path)` Add URLs and/or URL patterns for the given path.
`protected String[]` | `determineUrlsForHandler(String beanName)` Checks for presence of the `RequestMapping` annotation on the handler class and on any of its methods.
`protected String[]` | `determineUrlsForHandlerMethods(Class<?> handlerType)` Derive URL mappings from the handler's method-level mappings.
`protected String[]` | `determineUrlsForHandlerMethods(Class<?> handlerType, boolean hasTypeLevelMapping)` Derive URL mappings from the handler's method-level mappings.
`void` | `setUseDefaultSuffixPattern(boolean useDefaultSuffixPattern)` Set whether to register paths using the default suffix pattern as well: i.e.
`protected boolean` | `supportsTypeLevelMappings()` Indicates whether this handler mapping support type-level mappings.
`protected void` | `validateHandler(Object handler, HttpServletRequest request)` Validate the given annotated handler against the current request.
`protected void` | `validateMapping(RequestMapping mapping, HttpServletRequest request)` Validate the given type-level mapping metadata against the current request, checking HTTP request method and parameter conditions.

Methods inherited from class org.springframework.web.servlet.handler.AbstractDetectingUrlHandlerMapping
`detectHandlers, initApplicationContext, setDetectHandlersInAncestorContexts`

Methods inherited from class org.springframework.web.servlet.handler.AbstractUrlHandlerMapping
`buildPathExposingHandler, exposePathWithinMapping, exposeUriTemplateVariables, getHandlerInternal, getHandlerMap, getRootHandler, lookupHandler, registerHandler, registerHandler, setLazyInitHandlers, setRootHandler`

Methods inherited from class org.springframework.web.servlet.handler.AbstractHandlerMapping
`adaptInterceptor, detectMappedInterceptors, extendInterceptors, getAdaptedInterceptors, getDefaultHandler, getHandler, getHandlerExecutionChain, getMappedInterceptors, getOrder, getPathMatcher, getUrlPathHelper, initInterceptors, setAlwaysUseFullPath, setDefaultHandler, setInterceptors, setOrder, setPathMatcher, setUrlDecode, setUrlPathHelper`

Methods inherited from class org.springframework.web.context.support.WebApplicationObjectSupport
`getServletContext, getTempDir, getWebApplicationContext, initApplicationContext, initServletContext, isContextRequired, setServletContext`

Methods inherited from class org.springframework.context.support.ApplicationObjectSupport
`getApplicationContext, getMessageSourceAccessor, 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

### setUseDefaultSuffixPattern

    public void setUseDefaultSuffixPattern(boolean useDefaultSuffixPattern)

  Set whether to register paths using the default suffix pattern as well: i.e. whether "/users" should be registered as "/users.*" and "/users/" too.

  Default is "true". Turn this convention off if you intend to interpret your `@RequestMapping` paths strictly.

  Note that paths which include a ".xxx" suffix or end with "/" already will not be transformed using the default suffix pattern in any case.

### determineUrlsForHandler

    protected String[] determineUrlsForHandler(String beanName)

  Checks for presence of the `RequestMapping` annotation on the handler class and on any of its methods.

  Specified by:
    `determineUrlsForHandler` in class `AbstractDetectingUrlHandlerMapping`
  Parameters:
    `beanName` - the name of the candidate bean
  Returns:
    the URLs determined for the bean, or `null` or an empty array if none

### determineUrlsForHandlerMethods

    protected String[] determineUrlsForHandlerMethods(Class<?> handlerType,
                                                      boolean hasTypeLevelMapping)

  Derive URL mappings from the handler's method-level mappings.

  Parameters:
    `handlerType` - the handler type to introspect
    `hasTypeLevelMapping` - whether the method-level mappings are nested within a type-level mapping
  Returns:
    the array of mapped URLs

### determineUrlsForHandlerMethods

    protected String[] determineUrlsForHandlerMethods(Class<?> handlerType)

  Derive URL mappings from the handler's method-level mappings.

  Parameters:
    `handlerType` - the handler type to introspect
  Returns:
    the array of mapped URLs

### addUrlsForPath

    protected void addUrlsForPath(Set<String> urls,
                                  String path)

  Add URLs and/or URL patterns for the given path.

  Parameters:
    `urls` - the Set of URLs for the current bean
    `path` - the currently introspected path

### validateHandler

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

  Validate the given annotated handler against the current request.

  Overrides:
    `validateHandler` in class `AbstractUrlHandlerMapping`
  Parameters:
    `handler` - the handler object to validate
    `request` - current HTTP request
  Throws:
    `Exception` - if validation failed
  See Also:
    `validateMapping(org.springframework.web.bind.annotation.RequestMapping, javax.servlet.http.HttpServletRequest)`

### validateMapping

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

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

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

### supportsTypeLevelMappings

    protected boolean supportsTypeLevelMappings()

  Description copied from class: `AbstractUrlHandlerMapping`
  Indicates whether this handler mapping support type-level mappings. Default to `false`.

  Overrides:
    `supportsTypeLevelMappings` in class `AbstractUrlHandlerMapping`

Overview | Package | Class | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD