Package org.springframework.web.servlet.mvc.method.annotation

Class RequestMappingHandlerMapping

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.AbstractHandlerMethodMapping<RequestMappingInfo>
org.springframework.web.servlet.mvc.method.RequestMappingInfoHandlerMapping
org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping
All Implemented Interfaces:
org.springframework.beans.factory.Aware, org.springframework.beans.factory.BeanNameAware, org.springframework.beans.factory.InitializingBean, org.springframework.context.ApplicationContextAware, org.springframework.context.EmbeddedValueResolverAware, org.springframework.core.Ordered, org.springframework.web.context.ServletContextAware, MatchableHandlerMapping, HandlerMapping
public class RequestMappingHandlerMapping extends RequestMappingInfoHandlerMapping implements MatchableHandlerMapping, org.springframework.context.EmbeddedValueResolverAware
Creates RequestMappingInfo instances from type-level and method-level @RequestMapping and @HttpExchange annotations in @Controller classes.

Deprecation Note:

In 5.2.4, useSuffixPatternMatch and useRegisteredSuffixPatternMatch were deprecated in order to discourage use of path extensions for request mapping and for content negotiation (with similar deprecations in ContentNegotiationManagerFactoryBean). For further context, please read issue #24179.
Since:
3.1
Author:
Arjen Poutsma, Rossen Stoyanchev, Sam Brannen, Olga Maciaszek-Sharma

  • Constructor Details

    • RequestMappingHandlerMapping

      public RequestMappingHandlerMapping()

  • Method Details

    • setPatternParser

      public void setPatternParser(@Nullable org.springframework.web.util.pattern.PathPatternParser patternParser)
      Description copied from class: AbstractHandlerMapping
      Set the PathPatternParser to parse patterns with for URL path matching. Parsed patterns provide a more modern and efficient alternative to String path matching via AntPathMatcher.

      Note: This property is mutually exclusive with the below properties, all of which are not necessary for parsed patterns and are ignored when a PathPatternParser is available:

      By default, as of 6.0, this is set to a PathPatternParser instance with default settings and therefore use of parsed patterns is enabled. Set this to null to switch to String path matching via AntPathMatcher instead.

      Overrides:
      setPatternParser in class AbstractHandlerMethodMapping<RequestMappingInfo>
      Parameters:
      patternParser - the parser to use

    • setUseSuffixPatternMatch

      @Deprecated public void setUseSuffixPatternMatch(boolean useSuffixPatternMatch)
      Deprecated.
      as of 5.2.4. See class level note on the deprecation of path extension config options. As there is no replacement for this method, in 5.2.x it is necessary to set it to false. In 5.3 the default changes to false and use of this property becomes unnecessary.
      Whether to use suffix pattern match (".*") when matching patterns to requests. If enabled a method mapped to "/users" also matches to "/users.*".

      By default value this is set to false.

      Also see setUseRegisteredSuffixPatternMatch(boolean) for more fine-grained control over specific suffixes to allow.

      Note: This property is ignored when setPatternParser(PathPatternParser) is configured.

    • setUseRegisteredSuffixPatternMatch

      @Deprecated public void setUseRegisteredSuffixPatternMatch(boolean useRegisteredSuffixPatternMatch)
      Deprecated.
      as of 5.2.4. See class level note on the deprecation of path extension config options.
      Whether suffix pattern matching should work only against path extensions explicitly registered with the ContentNegotiationManager. This is generally recommended to reduce ambiguity and to avoid issues such as when a "." appears in the path for other reasons.

      By default this is set to "false".

      Note: This property is ignored when setPatternParser(PathPatternParser) is configured.

    • setUseTrailingSlashMatch

      @Deprecated(since="6.0") public void setUseTrailingSlashMatch(boolean useTrailingSlashMatch)
      Deprecated.
      as of 6.0, see PathPatternParser.setMatchOptionalTrailingSeparator(boolean)
      Whether to match to URLs irrespective of the presence of a trailing slash. If enabled a method mapped to "/users" also matches to "/users/".

      The default was changed in 6.0 from true to false in order to support the deprecation of the property.

    • setPathPrefixes

      public void setPathPrefixes(Map<String,Predicate<Class<?>>> prefixes)
      Configure path prefixes to apply to controller methods.

      Prefixes are used to enrich the mappings of every @RequestMapping method and @HttpExchange method whose controller type is matched by a corresponding Predicate in the map. The prefix for the first matching predicate is used, assuming the input map has predictable order.

      Consider using HandlerTypePredicate to group controllers.

      Parameters:
      prefixes - a map with path prefixes as key
      Since:
      5.1

    • getPathPrefixes

      public Map<String,Predicate<Class<?>>> getPathPrefixes()
      The configured path prefixes as a read-only, possibly empty map.
      Since:
      5.1

    • setContentNegotiationManager

      public void setContentNegotiationManager(org.springframework.web.accept.ContentNegotiationManager contentNegotiationManager)
      Set the ContentNegotiationManager to use to determine requested media types. If not set, the default constructor is used.

    • getContentNegotiationManager

      public org.springframework.web.accept.ContentNegotiationManager getContentNegotiationManager()
      Return the configured ContentNegotiationManager.

    • setEmbeddedValueResolver

      public void setEmbeddedValueResolver(org.springframework.util.StringValueResolver resolver)
      Specified by:
      setEmbeddedValueResolver in interface org.springframework.context.EmbeddedValueResolverAware

    • afterPropertiesSet

      public void afterPropertiesSet()
      Description copied from class: AbstractHandlerMethodMapping
      Detects handler methods at initialization.
      Specified by:
      afterPropertiesSet in interface org.springframework.beans.factory.InitializingBean
      Overrides:
      afterPropertiesSet in class AbstractHandlerMethodMapping<RequestMappingInfo>
      See Also:

    • useSuffixPatternMatch

      @Deprecated public boolean useSuffixPatternMatch()
      Deprecated.
      as of 5.2.4. See deprecation notice on setUseSuffixPatternMatch(boolean).
      Whether to use registered suffixes for pattern matching.

    • useRegisteredSuffixPatternMatch

      @Deprecated public boolean useRegisteredSuffixPatternMatch()
      Deprecated.
      as of 5.2.4. See deprecation notice on setUseRegisteredSuffixPatternMatch(boolean).
      Whether to use registered suffixes for pattern matching.

    • useTrailingSlashMatch

      public boolean useTrailingSlashMatch()
      Whether to match to URLs irrespective of the presence of a trailing slash.

    • getFileExtensions

      @Nullable @Deprecated public List<String> getFileExtensions()
      Deprecated.
      as of 5.2.4. See class-level note on the deprecation of path extension config options.
      Return the file extensions to use for suffix pattern matching.

    • getBuilderConfiguration

      public RequestMappingInfo.BuilderConfiguration getBuilderConfiguration()
      Obtain a RequestMappingInfo.BuilderConfiguration that reflects the internal configuration of this HandlerMapping and can be used to set RequestMappingInfo.Builder.options(RequestMappingInfo.BuilderConfiguration).

      This is useful for programmatic registration of request mappings via registerHandlerMethod(Object, Method, RequestMappingInfo).

      Returns:
      the builder configuration that reflects the internal state
      Since:
      5.3.14

    • isHandler

      protected boolean isHandler(Class<?> beanType)
      Whether the given type is a handler with handler methods.

      Expects a handler to have a type-level @Controller annotation.

      Specified by:
      isHandler in class AbstractHandlerMethodMapping<RequestMappingInfo>
      Parameters:
      beanType - the type of the bean being checked
      Returns:
      "true" if this a handler type, "false" otherwise.

    • getMappingForMethod

      @Nullable protected RequestMappingInfo getMappingForMethod(Method method, Class<?> handlerType)
      Uses type-level and method-level @RequestMapping and @HttpExchange annotations to create the RequestMappingInfo.
      Specified by:
      getMappingForMethod in class AbstractHandlerMethodMapping<RequestMappingInfo>
      Parameters:
      method - the method to provide a mapping for
      handlerType - the handler type, possibly a subtype of the method's declaring class
      Returns:
      the created RequestMappingInfo, or null if the method does not have a @RequestMapping or @HttpExchange annotation
      See Also:

    • getCustomTypeCondition

      @Nullable protected RequestCondition<?> getCustomTypeCondition(Class<?> handlerType)
      Provide a custom type-level request condition. The custom RequestCondition can be of any type so long as the same condition type is returned from all calls to this method in order to ensure custom request conditions can be combined and compared.

      Consider extending AbstractRequestCondition for custom condition types and using CompositeRequestCondition to provide multiple custom conditions.

      Parameters:
      handlerType - the handler type for which to create the condition
      Returns:
      the condition, or null

    • getCustomMethodCondition

      @Nullable protected RequestCondition<?> getCustomMethodCondition(Method method)
      Provide a custom method-level request condition. The custom RequestCondition can be of any type so long as the same condition type is returned from all calls to this method in order to ensure custom request conditions can be combined and compared.

      Consider extending AbstractRequestCondition for custom condition types and using CompositeRequestCondition to provide multiple custom conditions.

      Parameters:
      method - the handler method for which to create the condition
      Returns:
      the condition, or null

    • createRequestMappingInfo

      protected RequestMappingInfo createRequestMappingInfo(org.springframework.web.bind.annotation.RequestMapping requestMapping, @Nullable RequestCondition<?> customCondition)
      Create a RequestMappingInfo from the supplied @RequestMapping annotation, meta-annotation, or synthesized result of merging annotation attributes within an annotation hierarchy.

    • createRequestMappingInfo

      protected RequestMappingInfo createRequestMappingInfo(org.springframework.web.service.annotation.HttpExchange httpExchange, @Nullable RequestCondition<?> customCondition)
      Create a RequestMappingInfo from the supplied @HttpExchange annotation, meta-annotation, or synthesized result of merging annotation attributes within an annotation hierarchy.
      Since:
      6.1

    • resolveEmbeddedValuesInPatterns

      protected String[] resolveEmbeddedValuesInPatterns(String[] patterns)
      Resolve placeholder values in the given array of patterns.
      Returns:
      a new array with updated patterns

    • registerMapping

      public void registerMapping(RequestMappingInfo mapping, Object handler, Method method)
      Description copied from class: AbstractHandlerMethodMapping
      Register the given mapping.

      This method may be invoked at runtime after initialization has completed.

      Overrides:
      registerMapping in class AbstractHandlerMethodMapping<RequestMappingInfo>
      Parameters:
      mapping - the mapping for the handler method
      handler - the handler
      method - the method

    • registerHandlerMethod

      protected void registerHandlerMethod(Object handler, Method method, RequestMappingInfo mapping)
      Register a handler method and its unique mapping. Invoked at startup for each detected handler method.

      Note: To create the RequestMappingInfo, please use getBuilderConfiguration() and set the options on RequestMappingInfo.Builder.options(RequestMappingInfo.BuilderConfiguration) to match how this HandlerMapping is configured. This is important for example to ensure use of PathPattern or PathMatcher based matching.

      Overrides:
      registerHandlerMethod in class AbstractHandlerMethodMapping<RequestMappingInfo>
      Parameters:
      handler - the bean name of the handler or the handler instance
      method - the method to register
      mapping - the mapping conditions associated with the handler method

    • match

      public RequestMatchResult match(HttpServletRequest request, String pattern)
      Description copied from interface: MatchableHandlerMapping
      Determine whether the request matches the given pattern. Use this method when MatchableHandlerMapping.getPatternParser() returns null which means that the HandlerMapping is using String pattern matching.
      Specified by:
      match in interface MatchableHandlerMapping
      Parameters:
      request - the current request
      pattern - the pattern to match
      Returns:
      the result from request matching, or null if none

    • initCorsConfiguration

      protected org.springframework.web.cors.CorsConfiguration initCorsConfiguration(Object handler, Method method, RequestMappingInfo mappingInfo)
      Description copied from class: AbstractHandlerMethodMapping
      Extract and return the CORS configuration for the mapping.
      Overrides:
      initCorsConfiguration in class AbstractHandlerMethodMapping<RequestMappingInfo>