org.springframework.web.bind.annotation

Annotation Type RequestMapping



  • @Target(value={METHOD,TYPE})
     @Retention(value=RUNTIME)
     @Documented
    public @interface RequestMapping
    Annotation for mapping web requests onto methods in request-handling classes with flexible method signatures.

    Both Spring MVC and Spring WebFlux support this annotation through a RequestMappingHandlerMapping and RequestMappingHandlerAdapter in their respective modules and package structure. For the exact list of supported handler method arguments and return types in each, please use the reference documentation links below:

    Note: This annotation can be used both at the class and at the method level. In most cases, at the method level applications will prefer to use one of the HTTP method specific variants @GetMapping, @PostMapping, @PutMapping, @DeleteMapping, or @PatchMapping.

    NOTE: When using controller interfaces (e.g. for AOP proxying), make sure to consistently put all your mapping annotations - such as @RequestMapping and @SessionAttributes - on the controller interface rather than on the implementation class.

    Since:
    2.5
    Author:
    Juergen Hoeller, Arjen Poutsma, Sam Brannen
    See Also:
    GetMapping, PostMapping, PutMapping, DeleteMapping, PatchMapping, RequestMappingHandlerAdapter, RequestMappingHandlerAdapter
    • Optional Element Summary

      Optional Elements 
      Modifier and Type Optional Element and Description
      java.lang.String[] consumes
      The consumable media types of the mapped request, narrowing the primary mapping.
      java.lang.String[] headers
      The headers of the mapped request, narrowing the primary mapping.
      RequestMethod[] method
      The HTTP request methods to map to, narrowing the primary mapping: GET, POST, HEAD, OPTIONS, PUT, PATCH, DELETE, TRACE.
      java.lang.String name
      Assign a name to this mapping.
      java.lang.String[] params
      The parameters of the mapped request, narrowing the primary mapping.
      java.lang.String[] path
      The path mapping URIs (e.g.
      java.lang.String[] produces
      The producible media types of the mapped request, narrowing the primary mapping.
      java.lang.String[] value
      The primary mapping expressed by this annotation.
    • Element Detail

      • name

        public abstract java.lang.String name
        Assign a name to this mapping.

        Supported at the type level as well as at the method level! When used on both levels, a combined name is derived by concatenation with "#" as separator.

        See Also:
        MvcUriComponentsBuilder, HandlerMethodMappingNamingStrategy
        Default:
        ""
      • value

        @AliasFor(value="path")
        public abstract java.lang.String[] value
        The primary mapping expressed by this annotation.

        This is an alias for path(). For example @RequestMapping("/foo") is equivalent to @RequestMapping(path="/foo").

        Supported at the type level as well as at the method level! When used at the type level, all method-level mappings inherit this primary mapping, narrowing it for a specific handler method.

        Default:
        {}
      • path

        @AliasFor(value="value")
        public abstract java.lang.String[] path
        The path mapping URIs (e.g. "/myPath.do"). Ant-style path patterns are also supported (e.g. "/myPath/*.do"). At the method level, relative paths (e.g. "edit.do") are supported within the primary mapping expressed at the type level. Path mapping URIs may contain placeholders (e.g. "/${connect}").

        Supported at the type level as well as at the method level! When used at the type level, all method-level mappings inherit this primary mapping, narrowing it for a specific handler method.

        Since:
        4.2
        See Also:
        ValueConstants.DEFAULT_NONE
        Default:
        {}
      • method

        public abstract RequestMethod[] method
        The HTTP request methods to map to, narrowing the primary mapping: GET, POST, HEAD, OPTIONS, PUT, PATCH, DELETE, TRACE.

        Supported at the type level as well as at the method level! When used at the type level, all method-level mappings inherit this HTTP method restriction (i.e. the type-level restriction gets checked before the handler method is even resolved).

        Default:
        {}
      • params

        public abstract java.lang.String[] params
        The parameters of the mapped request, narrowing the primary mapping.

        Same format for any environment: a sequence of "myParam=myValue" style expressions, with a request only mapped if each such parameter is found to have the given value. Expressions can be negated by using the "!=" operator, as in "myParam!=myValue". "myParam" style expressions are also supported, with such parameters having to be present in the request (allowed to have any value). Finally, "!myParam" style expressions indicate that the specified parameter is not supposed to be present in the request.

        Supported at the type level as well as at the method level! When used at the type level, all method-level mappings inherit this parameter restriction (i.e. the type-level restriction gets checked before the handler method is even resolved).

        Parameter mappings are considered as restrictions that are enforced at the type level. The primary path mapping (i.e. the specified URI value) still has to uniquely identify the target handler, with parameter mappings simply expressing preconditions for invoking the handler.

        Default:
        {}
      • headers

        public abstract java.lang.String[] headers
        The headers of the mapped request, narrowing the primary mapping.

        Same format for any environment: a sequence of "My-Header=myValue" style expressions, with a request only mapped if each such header is found to have the given value. Expressions can be negated by using the "!=" operator, as in "My-Header!=myValue". "My-Header" style expressions are also supported, with such headers having to be present in the request (allowed to have any value). Finally, "!My-Header" style expressions indicate that the specified header is not supposed to be present in the request.

        Also supports media type wildcards (*), for headers such as Accept and Content-Type. For instance,

         @RequestMapping(value = "/something", headers = "content-type=text/*")
         
        will match requests with a Content-Type of "text/html", "text/plain", etc.

        Supported at the type level as well as at the method level! When used at the type level, all method-level mappings inherit this header restriction (i.e. the type-level restriction gets checked before the handler method is even resolved).

        See Also:
        MediaType
        Default:
        {}
      • consumes

        public abstract java.lang.String[] consumes
        The consumable media types of the mapped request, narrowing the primary mapping.

        The format is a single media type or a sequence of media types, with a request only mapped if the Content-Type matches one of these media types. Examples:

         consumes = "text/plain"
         consumes = {"text/plain", "application/*"}
         
        Expressions can be negated by using the "!" operator, as in "!text/plain", which matches all requests with a Content-Type other than "text/plain".

        Supported at the type level as well as at the method level! When used at the type level, all method-level mappings override this consumes restriction.

        See Also:
        MediaType, ServletRequest.getContentType()
        Default:
        {}
      • produces

        public abstract java.lang.String[] produces
        The producible media types of the mapped request, narrowing the primary mapping.

        The format is a single media type or a sequence of media types, with a request only mapped if the Accept matches one of these media types. Examples:

         produces = "text/plain"
         produces = {"text/plain", "application/*"}
         produces = MediaType.APPLICATION_JSON_UTF8_VALUE
         

        It affects the actual content type written, for example to produce a JSON response with UTF-8 encoding, MediaType.APPLICATION_JSON_UTF8_VALUE should be used.

        Expressions can be negated by using the "!" operator, as in "!text/plain", which matches all requests with a Accept other than "text/plain".

        Supported at the type level as well as at the method level! When used at the type level, all method-level mappings override this produces restriction.

        See Also:
        MediaType
        Default:
        {}