@Target(value={TYPE,METHOD}) @Retention(value=RUNTIME) @Documented public @interface RequestMapping
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.
GetMapping
,
PostMapping
,
PutMapping
,
DeleteMapping
,
PatchMapping
Modifier and Type | Optional Element and Description |
---|---|
String[] |
consumes
Narrows the primary mapping by media types that can be consumed by the
mapped handler.
|
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.
|
String |
name
Assign a name to this mapping.
|
String[] |
params
The parameters of the mapped request, narrowing the primary mapping.
|
String[] |
path
The path mapping URIs (e.g.
|
String[] |
produces
Narrows the primary mapping by media types that can be produced by the
mapped handler.
|
String[] |
value
The primary mapping expressed by this annotation.
|
public abstract String name
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.
@AliasFor(value="path") public abstract String[] value
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.
NOTE: A handler method that is not mapped to any path explicitly is effectively mapped to an empty path.
@AliasFor(value="value") public abstract String[] path
"/profile"
).
Ant-style path patterns are also supported (e.g. "/profile/**"
).
At the method level, relative paths (e.g. "edit"
) are supported
within the primary mapping expressed at the type level.
Path mapping URIs may contain placeholders (e.g. "/${profile_path}"
).
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.
NOTE: A handler method that is not mapped to any path explicitly is effectively mapped to an empty path.
public abstract RequestMethod[] method
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.
public abstract String[] params
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.
public abstract String[] headers
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.
MediaType
public abstract String[] consumes
Content-Type
header. Examples:
consumes = "text/plain" consumes = {"text/plain", "application/*"} consumes = MediaType.TEXT_PLAIN_VALUEExpressions 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! If specified at both levels, the method level consumes condition overrides the type level condition.
MediaType
,
ServletRequest.getContentType()
public abstract String[] produces
"Accept"
header but may be derived from query parameters, or other. Examples:
produces = "text/plain" produces = {"text/plain", "application/*"} produces = MediaType.TEXT_PLAIN_VALUE produces = "text/plain;charset=UTF-8"
If a declared media type contains a parameter (e.g. "charset=UTF-8", "type=feed", "type=entry") and if a compatible media type from the request has that parameter too, then the parameter values must match. Otherwise if the media type from the request does not contain the parameter, it is assumed the client accepts any value.
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! If specified at both levels, the method level produces condition overrides the type level condition.
MediaType