# All Classes and Interfaces

Class
Description
AbstractAnnotationConfigDispatcherServletInitializer
`WebApplicationInitializer` to register a `DispatcherServlet` and use Java-based Spring configuration.
AbstractAtomFeedView
Abstract superclass for Atom Feed views, using the ROME package.
AbstractCachingViewResolver
Convenient base class for `ViewResolver` implementations.
AbstractCachingViewResolver.CacheFilter
Filter that determines if view should be cached.
AbstractCheckedElementTag
Abstract base class to provide common methods for implementing databinding-aware JSP tags for rendering an HTML '`input`' element with a '`type`' of '`checkbox`' or '`radio`'.
AbstractController
Convenient superclass for controller implementations, using the Template Method design pattern.
AbstractDataBoundFormElementTag
Base tag for all data-binding aware JSP form tags.
AbstractDetectingUrlHandlerMapping
Abstract implementation of the `HandlerMapping` interface, detecting URL mappings for handler beans through introspection of all defined beans in the application context.
AbstractDispatcherServletInitializer
Base class for `WebApplicationInitializer` implementations that register a `DispatcherServlet` in the servlet context.
AbstractFeedView<T extends com.rometools.rome.feed.WireFeed>
Abstract base class for Atom and RSS Feed views, using the ROME package.
AbstractFlashMapManager
A base class for `FlashMapManager` implementations.
AbstractFormTag
Base class for all JSP form tags.
AbstractHandlerExceptionResolver
Abstract base class for `HandlerExceptionResolver` implementations.
AbstractHandlerMapping
Abstract base class for `HandlerMapping` implementations.
AbstractHandlerMethodAdapter
Abstract base class for `HandlerAdapter` implementations that support handlers of type `HandlerMethod`.
AbstractHandlerMethodExceptionResolver
Abstract base class for `HandlerExceptionResolver` implementations that support handling exceptions from handlers of type `HandlerMethod`.
AbstractHandlerMethodMapping<T>
Abstract base class for `HandlerMapping` implementations that define a mapping between a request and a `HandlerMethod`.
AbstractHtmlElementBodyTag
Convenient superclass for many html tags that render content using the databinding features of the `AbstractHtmlElementTag`.
AbstractHtmlElementTag
Base class for databinding-aware JSP tags that render HTML element.
AbstractHtmlInputElementTag
Base class for databinding-aware JSP tags that render HTML form input element.
AbstractJackson2View
Abstract base class for Jackson based and content type independent `AbstractView` implementations.
AbstractLocaleContextResolver
Abstract base class for `LocaleContextResolver` implementations.
AbstractLocaleResolver
Abstract base class for `LocaleResolver` implementations.
AbstractMappingJacksonResponseBodyAdvice
A convenient base class for `ResponseBodyAdvice` implementations that customize the response before JSON serialization with `AbstractJackson2HttpMessageConverter`'s concrete subclasses.
AbstractMessageConverterMethodArgumentResolver
A base class for resolving method argument values by reading from the body of a request with `HttpMessageConverters`.
AbstractMessageConverterMethodArgumentResolver.ConverterType
AbstractMessageConverterMethodProcessor
Extends `AbstractMessageConverterMethodArgumentResolver` with the ability to handle method return values by writing to the response with `HttpMessageConverters`.
AbstractMultiCheckedElementTag
Abstract base class to provide common methods for implementing databinding-aware JSP tags for rendering multiple HTML '`input`' elements with a '`type`' of '`checkbox`' or '`radio`'.
AbstractPdfStamperView
Abstract superclass for PDF views that operate on an existing document with an AcroForm.
AbstractPdfView
Abstract superclass for PDF views.
AbstractRequestCondition<T extends AbstractRequestCondition<T>>
A base class for `RequestCondition` types providing implementations of `AbstractRequestCondition.equals(Object)`, `AbstractRequestCondition.hashCode()`, and `AbstractRequestCondition.toString()`.
AbstractResourceResolver
Base class for `ResourceResolver` implementations.
AbstractRssFeedView
Abstract superclass for RSS Feed views, using the ROME package.
AbstractSingleCheckedElementTag
Abstract base class to provide common methods for implementing databinding-aware JSP tags for rendering a single HTML '`input`' element with a '`type`' of '`checkbox`' or '`radio`'.
AbstractTemplateView
Adapter base class for template-based view technologies such as FreeMarker, with the ability to use request and session attributes in their model and the option to expose helper objects for Spring's FreeMarker macro library.
AbstractTemplateViewResolver
Abstract base class for template view resolvers, in particular for FreeMarker views.
AbstractThemeResolver
Deprecated.
as of 6.0 in favor of using CSS, without direct replacement
AbstractUrlBasedView
Abstract base class for URL-based views.
AbstractUrlHandlerMapping
Abstract base class for URL-mapped `HandlerMapping` implementations.
AbstractUrlViewController
Abstract base class for `Controllers` that return a view name based on the request URL.
AbstractVersionStrategy
Abstract base class for `VersionStrategy` implementations.
AbstractVersionStrategy.FileNameVersionPathStrategy
File name-based `VersionPathStrategy`, for example, `"path/foo-{version}.css"`.
AbstractVersionStrategy.PrefixVersionPathStrategy
A prefix-based `VersionPathStrategy`, for example, `"{version}/path/foo.js"`.
AbstractView
Abstract base class for `View` implementations.
AbstractXlsView
Convenient superclass for Excel document views in traditional XLS format.
AbstractXlsxStreamingView
Convenient superclass for Excel document views in the Office 2007 XLSX format, using POI's streaming variant.
AbstractXlsxView
Convenient superclass for Excel document views in the Office 2007 XLSX format (as supported by POI-OOXML).
AcceptHeaderLocaleResolver
`LocaleResolver` implementation that looks for a match between locales in the `Accept-Language` header and a list of configured supported locales.
ArgumentAware
Allows implementing tag to utilize nested `spring:argument` tags.
ArgumentTag
The `<argument>` tag is based on the JSTL `fmt:param` tag.
AsyncHandlerInterceptor
Extends `HandlerInterceptor` with a callback method invoked after the start of asynchronous request handling.
AsyncServerResponse
Asynchronous subtype of `ServerResponse` that exposes the future response.
AsyncSupportConfigurer
Helps with configuring options for asynchronous request processing.
AsyncTaskMethodReturnValueHandler
Handles return values of type `WebAsyncTask`.
BeanNameUrlHandlerMapping
Implementation of the `HandlerMapping` interface that maps from URLs to beans with names that start with a slash ("/"), similar to how Struts maps URLs to action names.
BeanNameViewResolver
A simple implementation of `ViewResolver` that interprets a view name as a bean name in the current application context, i.e.
BindErrorsTag
This `<hasBindErrors>` tag provides an `Errors` instance in case of bind errors.
BindStatus
Simple adapter to expose the bind status of a field or object.
BindTag
The `<bind>` tag supports evaluation of binding errors for a certain bean or bean property.
ButtonTag
The `<button>` tag renders a form field label in an HTML 'button' tag.
CachingResourceResolver
A `ResourceResolver` that resolves resources from a `Cache` or otherwise delegates to the resolver chain and saves the result in the cache.
CachingResourceTransformer
A `ResourceTransformer` that checks a `Cache` to see if a previously transformed resource exists in the cache and returns it if found, and otherwise delegates to the resolver chain and saves the result in the cache.
CallableMethodReturnValueHandler
Handles return values of type `Callable`.
CheckboxesTag
The `<checkboxes>` tag renders multiple HTML 'input' tags with type 'checkbox'.
CheckboxTag
The `<checkbox>` tag renders an HTML 'input' tag with type 'checkbox'.
CompositeRequestCondition
Implements the `RequestCondition` contract by delegating to multiple `RequestCondition` types and using a logical conjunction (`' && '`) to ensure all conditions match a given request.
ConsumesRequestCondition
A logical disjunction (' || ') request condition to match a request's 'Content-Type' header to a list of media type expressions.
ContentNegotiatingViewResolver
Implementation of `ViewResolver` that resolves a view based on the request file name or `Accept` header.
ContentNegotiationConfigurer
Creates a `ContentNegotiationManager` and configures it with one or more `ContentNegotiationStrategy` instances.
ContentVersionStrategy
A `VersionStrategy` that calculates a Hex MD5 hash from the content of the resource and appends it to the file name, for example, `"styles/main-e36d2e05253c6c7085a91522ce43a0b4.css"`.
ContinuationHandlerMethodArgumentResolver
No-op resolver for method arguments of type `Continuation`.
Controller
Base Controller interface, representing a component that receives `HttpServletRequest` and `HttpServletResponse` instances just like a `HttpServlet` but is able to participate in an MVC workflow.
ConversionServiceExposingInterceptor
Interceptor that places the configured `ConversionService` in request scope so it's available during request processing.
CookieLocaleResolver
`LocaleResolver` implementation that uses a cookie sent back to the user in case of a custom setting, with a fallback to the configured default locale, the request's `Accept-Language` header, or the default locale for the server.
CookieThemeResolver
Deprecated.
as of 6.0 in favor of using CSS, without direct replacement
CorsBeanDefinitionParser
`BeanDefinitionParser` that parses a `cors` element in order to set the CORS configuration in the various {AbstractHandlerMapping} beans created by `AnnotationDrivenBeanDefinitionParser`, `ResourcesBeanDefinitionParser` and `ViewControllerBeanDefinitionParser`.
CorsRegistration
Assists with the creation of a `CorsConfiguration` instance for a given URL path pattern.
CorsRegistry
Assists with the registration of global, URL pattern based `CorsConfiguration` mappings.
CssLinkResourceTransformer
A `ResourceTransformer` implementation that modifies links in a CSS file to match the public URL paths that should be exposed to clients (for example, with an MD5 content-based hash inserted in the URL).
CssLinkResourceTransformer.AbstractLinkParser
Abstract base class for `CssLinkResourceTransformer.LinkParser` implementations.
CssLinkResourceTransformer.LinkParser
Extract content chunks that represent links.
DefaultHandlerExceptionResolver
The default implementation of the `HandlerExceptionResolver` interface, resolving standard Spring MVC exceptions and translating them to corresponding HTTP status codes.
DefaultRequestToViewNameTranslator
`RequestToViewNameTranslator` that simply transforms the URI of the incoming request into a view name.
DefaultServletHandlerConfigurer
Configures a request handler for serving static resources by forwarding the request to the Servlet container's "default" Servlet.
DefaultServletHttpRequestHandler
An `HttpRequestHandler` for serving static files using the Servlet container's "default" Servlet.
DeferredResultMethodReturnValueHandler
Handler for return values of type `DeferredResult`, `ListenableFuture`, and `CompletionStage`.
DelegatingWebMvcConfiguration
A subclass of `WebMvcConfigurationSupport` that detects and delegates to all beans of type `WebMvcConfigurer` allowing them to customize the configuration provided by `WebMvcConfigurationSupport`.
DispatcherServlet
Central dispatcher for HTTP request handlers/controllers, for example, for web UI controllers or HTTP-based remote service exporters.
DispatcherServletWebRequest
`ServletWebRequest` subclass that is aware of `DispatcherServlet`'s request context, such as the Locale determined by the configured `LocaleResolver`.
EditorAwareTag
Interface to be implemented by JSP tags that expose a PropertyEditor for a property that they are currently bound to.
EnableWebMvc
Adding this annotation to an `@Configuration` class imports the Spring MVC configuration from `WebMvcConfigurationSupport`, for example:
EncodedResourceResolver
Resolver that delegates to the chain, and if a resource is found, it then attempts to find an encoded (for example, gzip, brotli) variant that is acceptable based on the "Accept-Encoding" request header.
EntityResponse<T>
Entity-specific subtype of `ServerResponse` that exposes entity data.
EntityResponse.Builder<T>
Defines a builder for `EntityResponse`.
ErrorsTag
The `<errors>` tag renders field errors in an HTML 'span' tag.
EscapeBodyTag
The `<escapeBody>` tag is used to escape its enclosed body content, applying HTML escaping and/or JavaScript escaping.
EvalTag
The `<eval>` tag evaluates a Spring expression (SpEL) and either prints the result or assigns it to a variable.
ExceptionHandlerExceptionResolver
An `AbstractHandlerMethodExceptionResolver` that resolves exceptions through `@ExceptionHandler` methods.
ExtendedServletRequestDataBinder
Subclass of `ServletRequestDataBinder` that adds URI template variables to the values used for data binding.
FixedLocaleResolver
`LocaleResolver` implementation that always returns a fixed default locale and optionally time zone.
FixedThemeResolver
Deprecated.
as of 6.0 in favor of using CSS, without direct replacement
FixedVersionStrategy
A `VersionStrategy` that relies on a fixed version applied as a request path prefix, for example, reduced SHA, version name, release date, etc.
FlashMap
A FlashMap provides a way for one request to store attributes intended for use in another.
FlashMapManager
A strategy interface for retrieving and saving FlashMap instances.
FormTag
The `<form>` tag renders an HTML 'form' tag and exposes a binding path to inner tags for binding.
FragmentsRendering
Public API for HTML rendering of a collection of fragments each with a view and independent model.
FragmentsRendering.Builder
Defines a builder for `FragmentsRendering`.
FrameworkServlet
Base servlet for Spring's web framework.
FreeMarkerConfig
Interface to be implemented by objects that configure and manage a FreeMarker `Configuration` object in a web environment.
FreeMarkerConfigurer
Bean to configure FreeMarker for web usage, via the "configLocation", "freemarkerSettings", or "templateLoaderPath" properties.
FreeMarkerConfigurerBeanDefinitionParser
Parse the `<mvc:freemarker-configurer>` MVC namespace element and register `FreeMarkerConfigurer` bean.
FreeMarkerView
View using the FreeMarker template engine.
FreeMarkerViewResolver
Convenience subclass of `UrlBasedViewResolver` that supports `FreeMarkerView` (i.e.
GroovyMarkupConfig
Interface to be implemented by objects that configure and manage a Groovy `MarkupTemplateEngine` for automatic lookup in a web environment.
GroovyMarkupConfigurer
An extension of Groovy's `TemplateConfiguration` and an implementation of Spring MVC's `GroovyMarkupConfig` for creating a `MarkupTemplateEngine` for use in a web application.
GroovyMarkupConfigurerBeanDefinitionParser
Parse the `<mvc:groovy-configurer>` MVC namespace element and register a `GroovyConfigurer` bean.
GroovyMarkupView
An `AbstractTemplateView` subclass based on Groovy XML/XHTML markup templates.
GroovyMarkupViewResolver
Convenience subclass of `AbstractTemplateViewResolver` that supports `GroovyMarkupView` (i.e.
HandlerAdapter
MVC framework SPI, allowing parameterization of the core MVC workflow.
HandlerExceptionResolver
Interface to be implemented by objects that can resolve exceptions thrown during handler mapping or execution, in the typical case to error views.
HandlerExceptionResolverComposite
A `HandlerExceptionResolver` that delegates to a list of other `HandlerExceptionResolvers`.
HandlerExecutionChain
Handler execution chain, consisting of handler object and any handler interceptors.
HandlerFilterFunction<T extends ServerResponse,R extends ServerResponse>
Represents a function that filters a handler function.
HandlerFunction<T extends ServerResponse>
Represents a function that handles a request.
HandlerFunctionAdapter
`HandlerAdapter` implementation that supports `HandlerFunction`s.
HandlerInterceptor
Workflow interface that allows for customized handler execution chains.
HandlerMapping
Interface to be implemented by objects that define a mapping between requests and handler objects.
HandlerMappingIntrospector
Helper class to get information from the `HandlerMapping` that would serve a specific request.
HandlerMappingIntrospector.CachedResult
Container for a `MatchableHandlerMapping` and `CorsConfiguration` for a given request matched by dispatcher type and requestURI.
HandlerMethodMappingNamingStrategy<T>
A strategy for assigning a name to a handler method's mapping.
HeadersRequestCondition
A logical conjunction (`' && '`) request condition that matches a request against a set of header expressions with syntax defined in `RequestMapping.headers()`.
HiddenInputTag
The `<hidden>` tag renders an HTML 'input' tag with type 'hidden' using the bound value.
HtmlEscapeTag
The `<htmlEscape>` tag sets default HTML escape value for the current page.
HtmlEscapingAwareTag
Superclass for tags that output content that might get HTML-escaped.
HttpEntityMethodProcessor
Resolves `HttpEntity` and `RequestEntity` method argument values, as well as return values of type `HttpEntity`, `ResponseEntity`, `ErrorResponse` and `ProblemDetail`.
HttpHeadersReturnValueHandler
Handles `HttpHeaders` return values.
HttpRequestHandlerAdapter
Adapter to use the plain `HttpRequestHandler` interface with the generic `DispatcherServlet`.
HttpResource
Extended interface for a `Resource` to be written to an HTTP response.
HttpServletBean
Simple extension of `HttpServlet` which treats its config parameters (`init-param` entries within the `servlet` tag in `web.xml`) as bean properties.
InputTag
The `<input>` tag renders an HTML 'input' tag with type 'text' using the bound value.
InterceptorRegistration
Assists with the creation of a `MappedInterceptor`.
InterceptorRegistry
Helps with configuring a list of mapped interceptors.
InternalResourceView
Wrapper for a JSP or other resource within the same web application.
InternalResourceViewResolver
Convenient subclass of `UrlBasedViewResolver` that supports `InternalResourceView` (i.e.
JsonViewRequestBodyAdvice
A `RequestBodyAdvice` implementation that adds support for Jackson's `@JsonView` annotation declared on a Spring MVC `@HttpEntity` or `@RequestBody` method parameter.
JsonViewResponseBodyAdvice
A `ResponseBodyAdvice` implementation that adds support for Jackson's `@JsonView` annotation declared on a Spring MVC `@RequestMapping` or `@ExceptionHandler` method.
JspAwareRequestContext
JSP-aware (and JSTL-aware) subclass of RequestContext, allowing for population of the context from a `jakarta.servlet.jsp.PageContext`.
JstlUtils
Helper class for preparing JSTL views, in particular for exposing a JSTL localization context.
JstlView
Specialization of `InternalResourceView` for JSTL pages, i.e.
LabelTag
The `<label>` tag renders a form field label in an HTML 'label' tag.
LastModified
Deprecated.
as of 5.3.9 in favor of using the `checkNotModified` methods in `WebRequest`, or from an annotated controller method, returning a `ResponseEntity` with an "ETag" and/or "Last-Modified" headers set.
LiteWebJarsResourceResolver
A `ResourceResolver` that delegates to the chain to locate a resource and then attempts to find a matching versioned resource contained in a WebJar JAR file.
LocaleChangeInterceptor
Interceptor that allows for changing the current locale on every request, via a configurable request parameter (default parameter name: "locale").
LocaleContextResolver
Extension of `LocaleResolver` that adds support for a rich locale context (potentially including locale and time zone information).
LocaleResolver
Interface for web-based locale resolution strategies that allows for both locale resolution via the request and locale modification via request and response.
MappedInterceptor
Wraps a `HandlerInterceptor` and uses URL patterns to determine whether it applies to a given request.
MappingJackson2JsonView
Spring MVC `View` that renders JSON content by serializing the model for the current request using Jackson 2's `ObjectMapper`.
MappingJackson2XmlView
Spring MVC `View` that renders XML content by serializing the model for the current request using Jackson 2's `XmlMapper`.
MarshallingView
Spring-MVC `View` that allows for response context to be rendered as the result of marshalling by a `Marshaller`.
MatchableHandlerMapping
Additional interface that a `HandlerMapping` can implement to expose a request matching API aligned with its internal request matching configuration and implementation.
MatrixVariableMapMethodArgumentResolver
Resolves arguments of type `Map` annotated with `@MatrixVariable` where the annotation does not specify a name.
MatrixVariableMethodArgumentResolver
Resolves arguments annotated with `@MatrixVariable`.
MediaTypeExpression
A contract for media type expressions (for example, "text/plain", "!text/plain") as defined in the `@RequestMapping` annotation for "consumes" and "produces" conditions.
MessageTag
The `<message>` tag looks up a message in the scope of this page.
ModelAndView
Holder for both Model and View in the web MVC framework.
ModelAndViewDefiningException
Exception to be thrown on error conditions that should forward to a specific view with a specific model.
ModelAndViewMethodReturnValueHandler
Handles return values of type `ModelAndView` copying view and model information to the `ModelAndViewContainer`.
ModelAndViewResolver
SPI for resolving custom return values from a specific handler method.
ModelAndViewResolverMethodReturnValueHandler
This return value handler is intended to be ordered after all others as it attempts to handle _any_ return value type (i.e.
MvcNamespaceHandler
`NamespaceHandler` for Spring MVC configuration namespace.
MvcNamespaceUtils
Convenience methods for use in MVC namespace BeanDefinitionParsers.
MvcUriComponentsBuilder
Creates instances of `UriComponentsBuilder` by pointing to `@RequestMapping` methods on Spring MVC controllers.
MvcUriComponentsBuilder.MethodArgumentBuilder
Builder class to create URLs for method arguments.
MvcUriComponentsBuilder.MethodInvocationInfo
Method invocation information.
NameValueExpression<T>
A contract for `"name!=value"` style expression used to specify request parameters and request header conditions in `@RequestMapping`.
NestedPathTag
The `<nestedPath>` tag supports and assists with nested beans or bean properties in the model.
NoHandlerFoundException
Thrown when the `DispatcherServlet` can't find a handler for a request, which may be handled with a configured `HandlerExceptionResolver`.
NoResourceFoundException
Raised when `ResourceHttpRequestHandler` can not find a resource.
OptionsTag
The `<options>` tag renders a list of HTML 'option' tags.
OptionTag
The `<option>` tag renders a single HTML 'option'.
Param
Bean used to pass name-value pair parameters from a `ParamTag` to a `ParamAware` tag.
ParamAware
Allows implementing tag to utilize nested `spring:param` tags.
ParameterizableViewController
Trivial controller that always returns a pre-configured view and optionally sets the response status code.
ParamsRequestCondition
A logical conjunction (`' && '`) request condition that matches a request against a set parameter expressions with syntax defined in `RequestMapping.params()`.
ParamTag
The `<param>` tag collects name-value parameters and passes them to a `ParamAware` ancestor in the tag hierarchy.
PasswordInputTag
The `<password>` tag renders an HTML 'input' tag with type 'password' using the bound value.
PathMatchConfigurer
Configure path matching options.
PathPatternsRequestCondition
A logical disjunction (' || ') request condition that matches a request against a set of URL path patterns.
PathResourceResolver
A simple `ResourceResolver` that tries to find a resource under the given locations matching to the request path.
PathVariableMapMethodArgumentResolver
Resolves `Map` method arguments annotated with `@PathVariable` where the annotation does not specify a path variable name.
PathVariableMethodArgumentResolver
Resolves method arguments annotated with an @`PathVariable`.
PatternsRequestCondition
A logical disjunction (' || ') request condition that matches a request against a set of URL path patterns.
PrincipalMethodArgumentResolver
Resolves an argument of type `Principal`, similar to `ServletRequestMethodArgumentResolver` but irrespective of whether the argument is annotated or not.
ProducesRequestCondition
A logical disjunction (' || ') request condition to match a request's 'Accept' header to a list of media type expressions.
RadioButtonsTag
The `<radiobuttons>` tag renders multiple HTML 'input' tags with type 'radio'.
RadioButtonTag
The `<radiobutton>` tag renders an HTML 'input' tag with type 'radio'.
RedirectAttributes
A specialization of the `Model` interface that controllers can use to select attributes for a redirect scenario.
RedirectAttributesMethodArgumentResolver
Resolves method arguments of type `RedirectAttributes`.
RedirectAttributesModelMap
A `ModelMap` implementation of `RedirectAttributes` that formats values as Strings using a `DataBinder`.
RedirectView
View that redirects to an absolute, context relative, or current request relative URL.
RedirectViewControllerRegistration
Assist with the registration of a single redirect view controller.
RenderingContext
Context passed to `ScriptTemplateView` render function in order to make the application context, the locale, the template loader and the url available on scripting side.
RenderingResponse
Rendering-specific subtype of `ServerResponse` that exposes model and template data.
RenderingResponse.Builder
Defines a builder for `RenderingResponse`.
RequestAttributeMethodArgumentResolver
Resolves method arguments annotated with an @`RequestAttribute`.
RequestBodyAdvice
Allows customizing the request before its body is read and converted into an Object and also allows for processing of the resulting Object before it is passed into a controller method as an `@RequestBody` or an `HttpEntity` method argument.
RequestBodyAdviceAdapter
A convenient starting point for implementing `RequestBodyAdvice` with default method implementations.
RequestCondition<T>
Contract for request mapping conditions.
RequestConditionHolder
A holder for a `RequestCondition` useful when the type of the request condition is not known ahead of time, for example, custom condition.
RequestContext
Context holder for request-specific state, like current web application context, current locale, current theme, and potential binding errors.
RequestContextAwareTag
Superclass for all tags that require a `RequestContext`.
RequestContextUtils
Utility class for easy access to request-specific state which has been set by the `DispatcherServlet`.
RequestDataValueProcessor
A contract for inspecting and potentially modifying request data values such as URL query parameters or form field values before they are rendered by a view or before a redirect.
RequestMappingHandlerAdapter
Extension of `AbstractHandlerMethodAdapter` that supports `@RequestMapping` annotated `HandlerMethods`.
RequestMappingHandlerMapping
Creates `RequestMappingInfo` instances from type-level and method-level `@RequestMapping` and `@HttpExchange` annotations in `@Controller` classes.
RequestMappingInfo
Request mapping information.
RequestMappingInfo.Builder
Defines a builder for creating a RequestMappingInfo.
RequestMappingInfo.BuilderConfiguration
Container for configuration options used for request mapping purposes.
RequestMappingInfoHandlerMapping
Abstract base class for classes for which `RequestMappingInfo` defines the mapping between a request and a handler method.
RequestMappingInfoHandlerMethodMappingNamingStrategy
A `HandlerMethodMappingNamingStrategy` for `RequestMappingInfo`-based handler method mappings.
RequestMatchResult
Container for the result from request pattern matching via `MatchableHandlerMapping` with a method to further extract URI template variables from the pattern.
RequestMethodsRequestCondition
A logical disjunction (' || ') request condition that matches a request against a set of `RequestMethods`.
RequestPartMethodArgumentResolver
Resolves the following method arguments: Annotated with @`RequestPart` Of type `MultipartFile` in conjunction with Spring's `MultipartResolver` abstraction Of type `jakarta.servlet.http.Part` in conjunction with Servlet multipart requests
RequestPredicate
Represents a function that evaluates on a given `ServerRequest`.
RequestPredicates
Implementations of `RequestPredicate` that implement various useful request matching operations, such as matching based on path, HTTP method, etc.
RequestPredicates.Visitor
Receives notifications from the logical structure of request predicates.
RequestResponseBodyMethodProcessor
Resolves method arguments annotated with `@RequestBody` and handles return values from methods annotated with `@ResponseBody` by reading and writing to the body of the request or response with an `HttpMessageConverter`.
RequestToViewNameTranslator
Strategy interface for translating an incoming `HttpServletRequest` into a logical view name when no view name is explicitly supplied.
ResourceBundleViewResolver
Deprecated.
as of 5.3, in favor of Spring's common view resolver variants and/or custom resolver implementations
ResourceChainRegistration
Assists with the registration of resource resolvers and transformers.
ResourceHandlerRegistration
Encapsulates information required to create a resource handler.
ResourceHandlerRegistry
Stores registrations of resource handlers for serving static resources such as images, css files and others through Spring MVC including setting cache headers optimized for efficient loading in a web browser.
ResourceHandlerUtils
Resource handling utility methods to share common logic between `ResourceHttpRequestHandler` and `org.springframework.web.servlet.function`.
ResourceHttpRequestHandler
`HttpRequestHandler` that serves static resources in an optimized way according to the guidelines of Page Speed, YSlow, etc.
ResourceResolver
A strategy for resolving a request to a server-side resource.
ResourceResolverChain
A contract for invoking a chain of `ResourceResolvers` where each resolver is given a reference to the chain allowing it to delegate when necessary.
ResourceTransformer
An abstraction for transforming the content of a resource.
ResourceTransformerChain
A contract for invoking a chain of `ResourceTransformers` where each resolver is given a reference to the chain allowing it to delegate when necessary.
ResourceTransformerSupport
A base class for a `ResourceTransformer` with an optional helper method for resolving public links within a transformed resource.
ResourceUrlEncodingFilter
A filter that wraps the `HttpServletResponse` and overrides its `encodeURL` method in order to translate internal resource request URLs into public URL paths for external use.
ResourceUrlProvider
A central component to use to obtain the public URL path that clients should use to access a static resource.
ResourceUrlProviderExposingInterceptor
An interceptor that exposes the `ResourceUrlProvider` instance it is configured with as a request attribute.
ResponseBodyAdvice<T>
Allows customizing the response after the execution of an `@ResponseBody` or a `ResponseEntity` controller method but before the body is written with an `HttpMessageConverter`.
ResponseBodyEmitter
A controller method return value type for asynchronous request processing where one or more objects are written to the response.
ResponseBodyEmitter.DataWithMediaType
A simple holder of data to be written along with a MediaType hint for selecting a message converter to write with.
ResponseBodyEmitterReturnValueHandler
Handler for return values of type: `ResponseBodyEmitter` including sub-class `SseEmitter` and others.
ResponseEntityExceptionHandler
A class with an `@ExceptionHandler` method that handles all Spring MVC raised exceptions by returning a `ResponseEntity` with RFC 9457 formatted error details in the body.
ResponseStatusExceptionResolver
A `HandlerExceptionResolver` that uses the `@ResponseStatus` annotation to map exceptions to HTTP status codes.
RouterFunction<T extends ServerResponse>
Represents a function that routes to a handler function.
RouterFunctionMapping
`HandlerMapping` implementation that supports `RouterFunctions`.
RouterFunctions
Central entry point to Spring's functional web framework. Exposes routing functionality, such as to create a `RouterFunction` using a discoverable builder-style API, to create a `RouterFunction` given a `RequestPredicate` and `HandlerFunction`, and to do further subrouting on an existing routing function.
RouterFunctions.Builder
Represents a discoverable builder for router functions.
RouterFunctions.Visitor
Receives notifications from the logical structure of router functions.
ScriptTemplateConfig
Interface to be implemented by objects that configure and manage a JSR-223 `ScriptEngine` for automatic lookup in a web environment.
ScriptTemplateConfigurer
An implementation of Spring MVC's `ScriptTemplateConfig` for creating a `ScriptEngine` for use in a web application.
ScriptTemplateConfigurerBeanDefinitionParser
Parse the `<mvc:script-template-configurer>` MVC namespace element and register a `ScriptTemplateConfigurer` bean.
ScriptTemplateView
An `AbstractUrlBasedView` subclass designed to run any template library based on a JSR-223 script engine.
ScriptTemplateViewResolver
Convenience subclass of `UrlBasedViewResolver` that supports `ScriptTemplateView` and custom subclasses of it.
SelectTag
The `<select>` tag renders an HTML 'select' element.
ServerRequest
Represents a server-side HTTP request, as handled by a `HandlerFunction`.
ServerRequest.Builder
Defines a builder for a request.
ServerRequest.Headers
Represents the headers of the HTTP request.
ServerResponse
Represents a typed server-side HTTP response, as returned by a handler function or filter function.
ServerResponse.BodyBuilder
Defines a builder that adds a body to the response.
ServerResponse.Context
Defines the context used during the `ServerResponse.writeTo(HttpServletRequest, HttpServletResponse, Context)`.
ServerResponse.HeadersBuilder<B extends ServerResponse.HeadersBuilder<B>>
Defines a builder that adds headers to the response.
ServerResponse.HeadersBuilder.WriteFunction
Defines the contract for `ServerResponse.HeadersBuilder.build(WriteFunction)`.
ServerResponse.SseBuilder
Defines a builder for a body that sends server-sent events.
ServerResponse.StreamBuilder
Defines a builder for a streaming response body.
ServletCookieValueMethodArgumentResolver
An `AbstractCookieValueMethodArgumentResolver` that resolves cookie values from an `HttpServletRequest`.
ServletForwardingController
Spring Controller implementation that forwards to a named servlet, i.e.
ServletInvocableHandlerMethod
Extends `InvocableHandlerMethod` with the ability to handle return values through a registered `HandlerMethodReturnValueHandler` and also supports setting the response status based on a method-level `@ResponseStatus` annotation.
ServletModelAttributeMethodProcessor
A Servlet-specific `ModelAttributeMethodProcessor` that applies data binding through a WebDataBinder of type `ServletRequestDataBinder`.
ServletRequestDataBinderFactory
Creates a `ServletRequestDataBinder`.
ServletRequestMethodArgumentResolver
Resolves servlet backed request-related method arguments.
ServletResponseMethodArgumentResolver
Resolves servlet backed response-related method arguments.
ServletUriComponentsBuilder
UriComponentsBuilder with additional static factory methods to create links based on the current HttpServletRequest.
ServletWebArgumentResolverAdapter
A Servlet-specific `AbstractWebArgumentResolverAdapter` that creates a `NativeWebRequest` from `ServletRequestAttributes`.
ServletWrappingController
Spring Controller implementation that wraps a servlet instance which it manages internally.
SessionAttributeMethodArgumentResolver
Resolves method arguments annotated with an @`SessionAttribute`.
SessionFlashMapManager
Store and retrieve `FlashMap` instances to and from the HTTP session.
SessionLocaleResolver
`LocaleResolver` implementation that uses a locale attribute in the user's session in case of a custom setting, with a fallback to the configured default locale, the request's `Accept-Language` header, or the default locale for the server.
SessionThemeResolver
Deprecated.
as of 6.0 in favor of using CSS, without direct replacement
SimpleControllerHandlerAdapter
Adapter to use the plain `Controller` workflow interface with the generic `DispatcherServlet`.
SimpleMappingExceptionResolver
`HandlerExceptionResolver` implementation that allows for mapping exception class names to view names, either for a set of given handlers or for all handlers in the DispatcherServlet.
SimpleServletHandlerAdapter
Adapter to use the Servlet interface with the generic DispatcherServlet.
SimpleServletPostProcessor
`BeanPostProcessor` that applies initialization and destruction callbacks to beans that implement the `Servlet` interface.
SimpleUrlHandlerMapping
Implementation of the `HandlerMapping` interface that maps from URLs to request handler beans.
SmartView
Provides additional information about a View such as whether it performs redirects.
SseEmitter
A specialization of `ResponseBodyEmitter` for sending Server-Sent Events.
SseEmitter.SseEventBuilder
A builder for an SSE event.
StreamingResponseBody
A controller method return value type for asynchronous request processing where the application can write directly to the response `OutputStream` without holding up the Servlet container thread.
StreamingResponseBodyReturnValueHandler
Supports return values of type `StreamingResponseBody` and also `ResponseEntity<StreamingResponseBody>`.
TagWriter
Utility class for writing HTML content to a `Writer` instance.
TextareaTag
The `<textarea>` tag renders an HTML 'textarea'.
ThemeChangeInterceptor
Deprecated.
as of 6.0 in favor of using CSS, without direct replacement
ThemeResolver
Deprecated.
as of 6.0 in favor of using CSS, without direct replacement
ThemeTag
Deprecated.
as of 6.0, with no direct replacement
TransformedResource
An extension of `ByteArrayResource` that a `ResourceTransformer` can use to represent an original resource preserving all other information except the content.
TransformTag
The `<transform>` tag provides transformation for reference data values from controllers and other objects inside a `spring:bind` tag (or a data-bound form element tag from Spring's form tag library).
UriComponentsBuilderMethodArgumentResolver
Resolvers argument values of type `UriComponentsBuilder`.
UrlBasedViewResolver
Simple implementation of the `ViewResolver` interface, allowing for direct resolution of symbolic view names to URLs, without explicit mapping definitions.
UrlBasedViewResolverRegistration
Assist with configuring a `UrlBasedViewResolver`.
UrlFilenameViewController
Simple `Controller` implementation that transforms the virtual path of a URL into a view name and returns that view.
UrlTag
The `<url>` tag creates URLs.
UserRoleAuthorizationInterceptor
Interceptor that checks the authorization of the current user via the user's roles, as evaluated by HttpServletRequest's isUserInRole method.
VersionPathStrategy
A strategy for extracting and embedding a resource version in its URL path.
VersionResourceResolver
Resolves request paths containing a version string that can be used as part of an HTTP caching strategy in which a resource is cached with a date in the distant future (for example, 1 year) and cached until the version, and therefore the URL, is changed.
VersionStrategy
An extension of `VersionPathStrategy` that adds a method to determine the actual version of a `Resource`.
View
MVC View for a web interaction.
ViewControllerRegistration
Assist with the registration of a single view controller.
ViewControllerRegistry
Assists with the registration of simple automated controllers pre-configured with status code and/or a view.
ViewMethodReturnValueHandler
Handles return values that are of type `View`.
ViewNameMethodReturnValueHandler
Handles return values of types `void` and `String` interpreting them as view name reference.
ViewResolver
Interface to be implemented by objects that can resolve views by name.
ViewResolverComposite
A `ViewResolver` that delegates to others.
ViewResolverRegistry
Assist with the configuration of a chain of `ViewResolver` instances.
ViewResolversBeanDefinitionParser
Parses the `view-resolvers` MVC namespace element and registers `ViewResolver` bean definitions.
WebContentGenerator
Convenient superclass for any kind of web content generator, like `AbstractController` and `WebContentInterceptor`.
WebContentInterceptor
Handler interceptor that checks the request for supported methods and a required session and prepares the response by applying the configured cache settings.
WebJarsResourceResolver
Deprecated, for removal: This API element is subject to removal in a future version.
as of 6.2, in favor of `LiteWebJarsResourceResolver`
WebMvcConfigurationSupport
This is the main class providing the configuration behind the MVC Java config.
WebMvcConfigurer
Defines callback methods to customize the Java-based configuration for Spring MVC enabled via `@EnableWebMvc`.
WebRequestHandlerInterceptorAdapter
Adapter that implements the Servlet HandlerInterceptor interface and wraps an underlying WebRequestInterceptor.
XmlViewResolver
Deprecated.
as of 5.3, in favor of Spring's common view resolver variants and/or custom resolver implementations
XsltView
XSLT-driven View that allows for response context to be rendered as the result of an XSLT transformation.
XsltViewResolver
`ViewResolver` implementation that resolves instances of `XsltView` by translating the supplied view name into the URL of the XSLT stylesheet.