name (String)

Assign a name to the mapping.

value (String[])

The path mapping URIs (for example, /myPath.do). Ant-style path patterns are also supported (for example, /myPath/*.do).

Path mapping URIs may contain placeholders (for example, /${connect}) against local properties and/or system properties and environment variables.

A path implements URI templates that give access to selected parts of a URL through patterns, variables, placeholders, and matrix variables (see section URI Templates).

At the method level, relative paths (for example, edit.do) are supported within the primary mapping expressed at the type level.

method

(RequestMethod[])

GET, POST, HEAD, OPTIONS, PUT, PATCH, DELETE, TRACE.

params (String[])

A sequence of myParam=myValue style expressions.

Expressions can be negated using the != operator,as in myParam!=myValue.

headers (String[])

A sequence of My-Header=myValue style expressions.

Specifying only the header name (for example, My-Header) is supported (allowed to have any value).

Negating a header name (for example, "!My-Header") is also supported (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.

consumes (String[])

The consumable media types of the mapped request.

Only mapped if the {@code Content-Type} matches one of these media types.

Negating an expression (for example, !text/xml) is also supported.

produces (String[])

The producible media types of the mapped request.

Only mapped if the {@code Accept} matches one of these media types.

Negating an expression (for example, !text/plain) is also supported. It matches all requests with a {@code Accept} other than "text/plain".

ServletRequest /

HttpServletRequest

Injects the servlet request/response.

javax.servlet.http.*

ServletResponse /

HttpServletResponse

HttpSession

Injects the HTTP session bound to the servlet request. If null, Spring creates a new one.

synchronizeOnSession must be set on an AbstractController or in RequestMappingHandlerAdapter if sessions should be shared

concurrently across multiple requests.

WebRequest / NativeWebRequest

Injects a wrapper for access to request parameters and request/session attributes only.

org.springframework.web.context.request.*

Locale

Injects the local e of the request using the configured LocaleResolver.

java.util.*

InputStream / Reader

Provides a direct access to the request/response payload.

java.io.*

OutputStream / Writer

HttpMethod

Injects the current method of the request.

org.springframework.http.*

Principal

Using the Spring security context, it injects the authenticated account.

java.security.*

HttpEntity<?>

Spring converts and injects the inbound request to a custom type using HttpMessageConverter. It also provides access to the request headers.

org.springframework.http.*

Map

Instantiates for us a BindingAwareModelMap to be used in the view.

java.util.*

Model

org.springframework.ui.*

ModelMap

RedirectAttributes

Injects and repopulates a map of attributes and flash attributes maintained over request redirection

org.springframework.web.servlet.mvc.support.*

Errors

Injects the validation results of the argument located just before in the argument list.

org.springframework.validation.*

BindingResult

SessionStatus

Allows tagging with setComplete(Boolean), the completion of a session. This method clears the session attributes defined at the type level with @SessionAttributes.

org.springframework.web.bind.support.*

UriComponentsBuilder

Injects a Spring URL builder UriComponentsBuilder.

org.springframework.web.util.*

@PathVariable

Injects an URI Template variable into an argument.

org.springframework.web.bind.annotation.*

@MatrixVariable

Injects name-value pairs located in URI path segments into an argument.

@RequestParam

Injects a specific request parameter into an argument.

@RequestHeader

Injects a specific request HTTP Header into an argument.

@RequestBody

Allows direct access to the request payload injecting it into an argument.

@RequestPart

Injects the content of a specific part (meta-data, file-data…) of a multipart/form-data encoded request into an argument of the matching type (MetaData, MultipartFile…)

@ModelAttribute

Populates automatically an attribute of the Model using the URI template.

This binding is operated before the method handler processing.

Model

Spring MVC creates an implementation of the Model Interface for the handler method.

The Model objects are populated manually within the handler- method or with @ModelAttribute.

The view to render needs to be mapped to the request with RequestToViewNameTranslator.

org.springframework.ui.*

ModelAndView

A wrapper object for the Model with a View and a view name. If a view name is provided, Spring MVC will attempt to resolve the associated View. Otherwise, the embedded View is rendered.

The Model objects are populated manually within the method or with @ModelAttribute.

Map

Allows a custom Model implementation.

The view to render needs to be mapped to the request with RequestToViewNameTranslator.

java.util.*

View

Allows the rendering of a custom View object.

Spring MVC creates an implementation of the Model interface for the handler method.

The objects of the model are populated manually within the method or with the help of @ModelAttribute.

org.springframework.web.servlet.*

String

If a @ResponseBody annotation is not specified on the handler method, the returned String is processed as a View name (View identifier).

java.lang.*

HttpEntity<?> / ResponseEntity<?>

Two wrapper objects to easily manage the response headers and converted-by-Spring body (with HttpMessageConverters).

org.springframework.http.*

HttpHeaders

Provides a wrapper object for HEAD responses.

org.springframework.http .*

Callable<?>

Can produce asynchronously a typed object when the Thread is controlled by Spring MVC.

java.util.concurrent.*

DeferredResult<?>

Can produce asynchronously a Typed object when the Thread is not controlled by Spring MVC.

org.springframework.web.context.request.async.*

ListenableFuture<?>

org.springframework.util.concurrent.*

void

When the view is externally resolved with RequestToViewNameTranslator or when the method prints directly in the response.