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

  Deprecated.
  in Spring 3.2 in favor of `RequestMappingHandlerMapping`

      @Deprecated
      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, MATRIX_VARIABLES_ATTRIBUTE, 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

    Constructors
    Constructor and Description
    `DefaultAnnotationHandlerMapping()` Deprecated.

  - ### Method Summary

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

      Deprecated.

  - ### Method Detail

    - #### setUseDefaultSuffixPattern

          public void setUseDefaultSuffixPattern(boolean useDefaultSuffixPattern)

      Deprecated.
      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)

      Deprecated.
      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)

      Deprecated.
      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)

      Deprecated.
      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)

      Deprecated.
      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

      Deprecated.
      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

      Deprecated.
      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()

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