# All Classes and Interfaces

Class
Description
AbstractClientHttpRequest
Abstract base for `ClientHttpRequest` that makes sure that headers and body are not written multiple times.
AbstractClientHttpRequest
Base class for `ClientHttpRequest` implementations.
AbstractClientHttpRequestFactoryWrapper
Abstract base class for `ClientHttpRequestFactory` implementations that decorate another delegate request factory.
AbstractClientHttpResponse
Base class for `ClientHttpResponse` implementations.
AbstractContextLoaderInitializer
Convenient base class for `WebApplicationInitializer` implementations that register a `ContextLoaderListener` in the servlet context.
AbstractCookieValueMethodArgumentResolver
A base abstract class to resolve method arguments annotated with `@CookieValue`.
AbstractGenericHttpMessageConverter<T>
Abstract base class for most `GenericHttpMessageConverter` implementations.
AbstractHttpMessageConverter<T>
Abstract base class for most `HttpMessageConverter` implementations.
AbstractJackson2Decoder
Abstract base class for Jackson 2.x decoding, leveraging non-blocking parsing.
AbstractJackson2Encoder
Base class providing support methods for Jackson 2.x encoding.
AbstractJackson2HttpMessageConverter
Abstract base class for Jackson based and content type independent `HttpMessageConverter` implementations.
AbstractJaxb2HttpMessageConverter<T>
Abstract base class for `HttpMessageConverters` that use JAXB2.
AbstractJsonHttpMessageConverter
Common base class for plain JSON converters, for example, Gson and JSON-B.
AbstractKotlinSerializationHttpMessageConverter<T extends kotlinx.serialization.SerialFormat>
Abstract base class for `HttpMessageConverter` implementations that use Kotlin serialization.
AbstractListenerReadPublisher<T>
Abstract base class for `Publisher` implementations that bridge between event-listener read APIs and Reactive Streams.
AbstractListenerServerHttpResponse
Abstract base class for listener-based server responses.
AbstractListenerWriteFlushProcessor<T>
An alternative to `AbstractListenerWriteProcessor` but instead writing a `Publisher<Publisher<T>>` with flush boundaries enforces after the completion of each nested Publisher.
AbstractListenerWriteProcessor<T>
Abstract base class for `Processor` implementations that bridge between event-listener write APIs and Reactive Streams.
AbstractMappingContentNegotiationStrategy
Base class for `ContentNegotiationStrategy` implementations with the steps to resolve a request to media types.
AbstractMultipartHttpServletRequest
Abstract base implementation of the `MultipartHttpServletRequest` interface.
AbstractNamedValueArgumentResolver
Base class for arguments that resolve to a named request value such as a request header, path variable, cookie, and others.
AbstractNamedValueArgumentResolver.NamedValueInfo
Info about a request value, typically extracted from a method parameter annotation.
AbstractNamedValueMethodArgumentResolver
Abstract base class for resolving method arguments from a named value.
AbstractNamedValueMethodArgumentResolver.NamedValueInfo
Represents the information about a named value, including name, whether it's required and a default value.
AbstractReactiveWebInitializer
Base class for a `WebApplicationInitializer` that installs a Spring Reactive Web Application on a Servlet container.
AbstractReactorHttpExchangeAdapter
Convenient base class for a `ReactorHttpExchangeAdapter` implementation adapting to the synchronous `HttpExchangeAdapter` contract.
AbstractRefreshableWebApplicationContext
`AbstractRefreshableApplicationContext` subclass which implements the `ConfigurableWebApplicationContext` interface for web environments.
AbstractRequestAttributes
Abstract support class for RequestAttributes implementations, offering a request completion mechanism for request-specific destruction callbacks and for updating accessed session attributes.
AbstractRequestAttributesScope
Abstract `Scope` implementation that reads from a particular scope in the current thread-bound `RequestAttributes` object.
AbstractRequestLoggingFilter
Base class for `Filter`s that perform logging operations before and after a request is processed.
AbstractServerHttpRequest
Common base class for `ServerHttpRequest` implementations.
AbstractServerHttpResponse
Base class for `ServerHttpResponse` implementations.
AbstractSmartHttpMessageConverter<T>
Abstract base class for most `SmartHttpMessageConverter` implementations.
AbstractWebArgumentResolverAdapter
An abstract base class adapting a `WebArgumentResolver` to the `HandlerMethodArgumentResolver` contract.
AbstractWireFeedHttpMessageConverter<T extends com.rometools.rome.feed.WireFeed>
Abstract base class for Atom and RSS Feed message converters, using the ROME tools project.
AbstractXmlHttpMessageConverter<T>
Abstract base class for `HttpMessageConverters` that convert from/to XML.
AcceptHeaderLocaleContextResolver
`LocaleContextResolver` implementation that looks for a match between locales in the `Accept-Language` header and a list of configured supported locales.
AllEncompassingFormHttpMessageConverter
Extension of `FormHttpMessageConverter`, adding support for XML, JSON, Smile, CBOR, Protobuf and Yaml based parts when related libraries are present in the classpath.
AnnotationConfigWebApplicationContext
`WebApplicationContext` implementation which accepts component classes as input — in particular `@Configuration` classes, but also plain `@Component` classes as well as JSR-330 compliant classes using `jakarta.inject` annotations.
ApplicationScope
`@ApplicationScope` is a specialization of `@Scope` for a component whose lifecycle is bound to the current web application.
AsyncHandlerMethodReturnValueHandler
A return value handler that supports async types.
AsyncRequestNotUsableException
Raised when the response for an asynchronous request becomes unusable as indicated by a write failure, or a Servlet container error notification, or after the async request has completed.
AsyncRequestTimeoutException
Exception to be thrown when an async request times out.
AsyncWebRequest
Extends `NativeWebRequest` with methods for asynchronous request processing.
AsyncWebRequestInterceptor
Extends `WebRequestInterceptor` with a callback method invoked during asynchronous request handling.
AtomFeedHttpMessageConverter
Implementation of `HttpMessageConverter` that can read and write Atom feeds.
BasicAuthenticationInterceptor
`ClientHttpRequestInterceptor` to apply a given HTTP Basic Authentication username/password pair, unless a custom `Authorization` header has already been set.
BindErrorUtils
Utility methods to resolve a list of `MessageSourceResolvable`s, and optionally join them.
BindParam
Annotation to bind values from a web request such as request parameters or path variables to fields of a Java object.
BindParamNameResolver
`DataBinder.NameResolver` that determines the bind value name from a `@BindParam` method parameter annotation.
BufferedImageHttpMessageConverter
Implementation of `HttpMessageConverter` that can read and write `BufferedImages`.
BufferingClientHttpRequestFactory
Wrapper for a `ClientHttpRequestFactory` that buffers all outgoing and incoming streams in memory.
ByteArrayHttpMessageConverter
Implementation of `HttpMessageConverter` that can read and write byte arrays.
ByteArrayMultipartFileEditor
Custom `PropertyEditor` for converting `MultipartFiles` to byte arrays.
CacheControl
A builder for creating "Cache-Control" HTTP response headers.
CallableProcessingInterceptor
Intercepts concurrent request handling, where the concurrent result is obtained by executing a `Callable` on behalf of the application with an `AsyncTaskExecutor`.
ChannelSendOperator<T>
Given a write function that accepts a source `Publisher<T>` to write with and returns `Publisher<Void>` for the result, this operator helps to defer the invocation of the write function, until we know if the source publisher will begin publishing without an error.
CharacterEncodingFilter
Servlet Filter that allows one to specify a character encoding for requests.
ClientCodecConfigurer
Extension of `CodecConfigurer` for HTTP message reader and writer options relevant on the client side.
ClientCodecConfigurer.ClientDefaultCodecs
`CodecConfigurer.DefaultCodecs` extension with extra client-side options.
ClientHttpConnector
Abstraction over HTTP clients driving the underlying HTTP client to connect to the origin server and provide all necessary infrastructure to send a `ClientHttpRequest` and receive a `ClientHttpResponse`.
ClientHttpObservationDocumentation
Documented `KeyValues` for `HTTP client` observations.
ClientHttpObservationDocumentation.HighCardinalityKeyNames
ClientHttpObservationDocumentation.LowCardinalityKeyNames
ClientHttpRequest
Represents a client-side HTTP request.
ClientHttpRequest
Represents a client-side reactive HTTP request.
ClientHttpRequestDecorator
Wraps another `ClientHttpRequest` and delegates all methods to it.
ClientHttpRequestExecution
Represents the context of a client-side HTTP request execution.
ClientHttpRequestFactory
Factory for `ClientHttpRequest` objects.
ClientHttpRequestInitializer
Callback interface for initializing a `ClientHttpRequest` prior to it being used.
ClientHttpRequestInterceptor
Contract to intercept client-side HTTP requests.
ClientHttpResponse
Represents a client-side HTTP response.
ClientHttpResponse
Represents a client-side reactive HTTP response.
ClientHttpResponseDecorator
Wraps another `ClientHttpResponse` and delegates all methods to it.
ClientRequestObservationContext
Context that holds information for metadata collection during the `client HTTP exchanges` observations.
ClientRequestObservationConvention
Interface for an `ObservationConvention` for `client HTTP exchanges`.
CodecConfigurer
Defines a common interface for configuring either client or server HTTP message readers and writers.
CodecConfigurer.CustomCodecs
Registry for custom HTTP message readers and writers.
CodecConfigurer.DefaultCodecConfig
Exposes the values of properties configured through `CodecConfigurer.defaultCodecs()` that are applied to default codecs.
CodecConfigurer.DefaultCodecs
Customize or replace the HTTP message readers and writers registered by default.
CodecConfigurer.MultipartCodecs
Registry and container for multipart HTTP message writers.
CommonsRequestLoggingFilter
Simple request logging filter that writes the request URI (and optionally the query string) to the Commons Log.
CompositeFilter
A generic composite servlet `Filter` that just delegates its behavior to a chain (list) of user-supplied filters, achieving the functionality of a `FilterChain`, but conveniently using only `Filter` instances.
CompositeUriComponentsContributor
A `UriComponentsContributor` containing a list of other contributors to delegate to and also encapsulating a specific `ConversionService` to use for formatting method argument values as Strings.
ConfigurableWebApplicationContext
Interface to be implemented by configurable web application contexts.
ConfigurableWebBindingInitializer
Convenient `WebBindingInitializer` for declarative configuration in a Spring application context.
ConfigurableWebEnvironment
Specialization of `ConfigurableEnvironment` allowing initialization of servlet-related `PropertySource` objects at the earliest moment that the `ServletContext` and (optionally) `ServletConfig` become available.
ContentCachingRequestWrapper
`HttpServletRequest` wrapper that caches all content read from the input stream and reader, and allows this content to be retrieved via a `byte array`.
ContentCachingResponseWrapper
`HttpServletResponse` wrapper that caches all content written to the output stream and writer, and allows this content to be retrieved via a byte array.
ContentDisposition
Representation of the Content-Disposition type and parameters as defined in RFC 6266.
ContentDisposition.Builder
A mutable builder for `ContentDisposition`.
ContentNegotiationManager
Central class to determine requested media types for a request.
ContentNegotiationManagerFactoryBean
Factory to create a `ContentNegotiationManager` and configure it with `ContentNegotiationStrategy` instances.
ContentNegotiationStrategy
A strategy for resolving the requested media types for a request.
ContextCleanupListener
Web application listener that cleans up remaining disposable attributes in the ServletContext, i.e.
ContextExposingHttpServletRequest
HttpServletRequest decorator that makes all Spring beans in a given WebApplicationContext accessible as request attributes, through lazy checking once an attribute gets accessed.
ContextLoader
Performs the actual initialization work for the root application context.
ContextLoaderListener
Bootstrap listener to start up and shut down Spring's root `WebApplicationContext`.
ContextPathCompositeHandler
`HttpHandler` delegating requests to one of several `HttpHandler`'s based on simple, prefix-based mappings.
ControllerAdvice
Specialization of `@Component` for classes that declare `@ExceptionHandler`, `@InitBinder`, or `@ModelAttribute` methods to be shared across multiple `@Controller` classes.
ControllerAdviceBean
Encapsulates information about an `@ControllerAdvice` Spring-managed bean without necessarily requiring it to be instantiated.
CookieGenerator
Deprecated.
as of 6.0 in favor of `ResponseCookie`
CookieValue
Annotation to indicate that a method parameter is bound to an HTTP cookie.
CookieValueArgumentResolver
`HttpServiceArgumentResolver` for `@CookieValue` annotated arguments.
CookieWebSessionIdResolver
Cookie-based `WebSessionIdResolver`.
CorsConfiguration
A container for CORS configuration along with methods to check against the actual origin, HTTP methods, and headers of a given request.
CorsConfigurationSource
Interface to be implemented by classes (usually HTTP request handlers) that provides a `CorsConfiguration` instance based on the provided request.
CorsConfigurationSource
Interface to be implemented by classes (usually HTTP request handlers) that provides a `CorsConfiguration` instance based on the provided reactive request.
CorsFilter
`Filter` to handle CORS pre-flight requests and intercept CORS simple and actual requests with a `CorsProcessor`, and to update the response, for example, with CORS response headers, based on the policy matched through the provided `CorsConfigurationSource`.
CorsProcessor
A strategy that takes a request and a `CorsConfiguration` and updates the response.
CorsProcessor
A strategy to apply CORS validation checks and updates to a `ServerWebExchange`, either rejecting through the response or adding CORS related headers, based on a pre-selected `CorsConfiguration`.
CorsUtils
Utility class for CORS request handling based on the CORS W3C recommendation.
CorsUtils
Utility class for CORS reactive request handling based on the CORS W3C recommendation.
CorsWebFilter
`WebFilter` that handles CORS preflight requests and intercepts CORS simple and actual requests thanks to a `CorsProcessor` implementation (`DefaultCorsProcessor` by default) in order to add the relevant CORS response headers (like `Access-Control-Allow-Origin`) using the provided `CorsConfigurationSource` (for example an `UrlBasedCorsConfigurationSource` instance.
CrossOrigin
Annotation for permitting cross-origin requests on specific handler classes and/or handler methods.
DecoderHttpMessageReader<T>
`HttpMessageReader` that wraps and delegates to a `Decoder`.
DecoratingNavigationHandler
Base class for JSF NavigationHandler implementations that want to be capable of decorating an original NavigationHandler.
DefaultClientCodecConfigurer
Default implementation of `ClientCodecConfigurer`.
DefaultClientRequestObservationConvention
Default implementation for a `ClientRequestObservationConvention`, extracting information from the `ClientRequestObservationContext`.
DefaultCorsProcessor
The default implementation of `CorsProcessor`, as defined by the CORS W3C recommendation.
DefaultCorsProcessor
The default implementation of `CorsProcessor`, as defined by the CORS W3C recommendation.
DefaultDataBinderFactory
Create a `WebRequestDataBinder` instance and initialize it with a `WebBindingInitializer`.
DefaultMultipartHttpServletRequest
Default implementation of the `MultipartHttpServletRequest` interface.
DefaultPartHttpMessageReader
Default `HttpMessageReader` for parsing `"multipart/form-data"` requests to a stream of `Part`s.
DefaultResponseErrorHandler
Spring's default implementation of the `ResponseErrorHandler` interface.
DefaultServerCodecConfigurer
Default implementation of `ServerCodecConfigurer`.
DefaultServerRequestObservationConvention
Default `ServerRequestObservationConvention`.
DefaultServerRequestObservationConvention
Default `ServerRequestObservationConvention`.
DefaultServerWebExchange
Default implementation of `ServerWebExchange`.
DefaultSessionAttributeStore
Default implementation of the `SessionAttributeStore` interface, storing the attributes in the WebRequest session (i.e.
DefaultUriBuilderFactory
`UriBuilderFactory` that relies on `UriComponentsBuilder` for the actual building of the URI.
DefaultUriBuilderFactory.EncodingMode
Enum to represent multiple URI encoding strategies.
DefaultWebFilterChain
Default implementation of `WebFilterChain`.
DefaultWebSessionManager
Default implementation of `WebSessionManager` delegating to a `WebSessionIdResolver` for session id resolution and to a `WebSessionStore`.
DeferredResult<T>
`DeferredResult` provides an alternative to using a `Callable` for asynchronous request processing.
DeferredResult.DeferredResultHandler
Handles a DeferredResult value when set.
DeferredResultProcessingInterceptor
Intercepts concurrent request handling, where the concurrent result is obtained by waiting for a `DeferredResult` to be set from a thread chosen by the application (for example, in response to some external event).
DelegatingFilterProxy
Proxy for a standard Servlet Filter, delegating to a Spring-managed bean that implements the Filter interface.
DelegatingNavigationHandlerProxy
JSF NavigationHandler implementation that delegates to a NavigationHandler bean obtained from the Spring root WebApplicationContext.
DelegatingPhaseListenerMulticaster
JSF PhaseListener implementation that delegates to one or more Spring-managed PhaseListener beans coming from the Spring root WebApplicationContext.
DelegatingServerHttpResponse
Implementation of `ServerHttpResponse` that delegates all calls to a given target `ServerHttpResponse`.
DeleteExchange
Shortcut for `@HttpExchange` for HTTP DELETE requests.
DeleteMapping
Annotation for mapping HTTP `DELETE` requests onto specific handler methods.
DestructionCallbackBindingListener
Adapter that implements the Servlet HttpSessionBindingListener interface, wrapping a session destruction callback.
DisconnectedClientHelper
Utility methods to assist with identifying and logging exceptions that indicate the server response connection is lost, for example because the client has gone away.
EncoderHttpMessageWriter<T>
`HttpMessageWriter` that wraps and delegates to an `Encoder`.
ErrorResponse
Representation of a complete RFC 9457 error response including status, headers, and an RFC 9457 formatted `ProblemDetail` body.
ErrorResponse.Builder
Builder for an `ErrorResponse`.
ErrorResponse.Interceptor
Callback to perform an action before an RFC-9457 `ProblemDetail` response is rendered.
ErrorResponseException
`RuntimeException` that implements `ErrorResponse` to expose an HTTP status, response headers, and a body formatted as an RFC 9457 `ProblemDetail`.
ErrorsMethodArgumentResolver
Resolves `Errors` method arguments.
EscapedErrors
Errors wrapper that adds automatic HTML escaping to the wrapped instance, for convenient usage in HTML views.
ETag
Represents an ETag for HTTP conditional requests.
ExceptionHandler
Annotation for handling exceptions in specific handler classes and/or handler methods.
ExceptionHandlerMappingInfo
`@ExceptionHandler` mapping information.
ExceptionHandlerMethodResolver
Discovers @ExceptionHandler methods in a given class, including all of its superclasses, and helps to resolve a given `Exception` and `MediaType` requested by clients to combinations supported by a given `Method`.
ExceptionHandlingWebHandler
WebHandler decorator that invokes one or more `WebExceptionHandlers` after the delegate `WebHandler`.
ExpressionValueMethodArgumentResolver
Resolves method arguments annotated with `@Value`.
ExtractingResponseErrorHandler
Implementation of `ResponseErrorHandler` that uses `HttpMessageConverters` to convert HTTP error responses to `RestClientExceptions`.
FacesContextUtils
Convenience methods to retrieve Spring's root `WebApplicationContext` for a given JSF `FacesContext`.
FacesRequestAttributes
`RequestAttributes` adapter for a JSF `FacesContext`.
FacesWebRequest
`WebRequest` adapter for a JSF `FacesContext`.
FilePart
Specialization of `Part` that represents an uploaded file received in a multipart request.
FilePartEvent
Represents an event triggered for a file upload.
FilteringWebHandler
`WebHandlerDecorator` that invokes a chain of `WebFilters` before invoking the delegate `WebHandler`.
FixedContentNegotiationStrategy
A `ContentNegotiationStrategy` that returns a fixed content type.
FixedLocaleContextResolver
`LocaleContextResolver` implementation that always returns a fixed locale and optionally time zone.
FormContentFilter
`Filter` that parses form data for HTTP PUT, PATCH, and DELETE requests and exposes it as Servlet request parameters.
FormFieldPart
Specialization of `Part` for a form field.
FormHttpMessageConverter
Implementation of `HttpMessageConverter` to read and write 'normal' HTML forms and also to write (but not read) multipart data (for example, file uploads).
FormHttpMessageReader
Implementation of an `HttpMessageReader` to read HTML form data, i.e.
FormHttpMessageWriter
`HttpMessageWriter` for writing a `MultiValueMap<String, String>` as HTML form data, i.e.
FormPartEvent
Represents an event triggered for a form field.
ForwardedHeaderFilter
Extract values from "Forwarded" and "X-Forwarded-*" headers, wrap the request and response, and make they reflect the client-originated protocol and address in the following methods: `getServerName()` `getServerPort()` `getScheme()` `isSecure()` `sendRedirect(String)`.
ForwardedHeaderTransformer
Extract values from "Forwarded" and "X-Forwarded-*" headers to override the request URI (i.e.
ForwardedHeaderUtils
Utility class to assist with processing "Forwarded" and "X-Forwarded-*" headers.
GenericFilterBean
Simple base implementation of `Filter` which treats its config parameters (`init-param` entries within the `filter` tag in `web.xml`) as bean properties.
GenericHttpMessageConverter<T>
A specialization of `HttpMessageConverter` that can convert an HTTP request into a target object of a specified generic type and a source object of a specified generic type into an HTTP response.
GenericWebApplicationContext
Subclass of `GenericApplicationContext`, suitable for web environments.
GetExchange
Shortcut for `@HttpExchange` for HTTP GET requests.
GetMapping
Annotation for mapping HTTP `GET` requests onto specific handler methods.
GroovyWebApplicationContext
`WebApplicationContext` implementation which takes its configuration from Groovy bean definition scripts and/or XML files, as understood by a `GroovyBeanDefinitionReader`.
GsonBuilderUtils
A simple utility class for obtaining a Google Gson 2.x `GsonBuilder` which Base64-encodes `byte[]` properties when reading and writing JSON.
GsonFactoryBean
A `FactoryBean` for creating a Google Gson 2.x `Gson` instance.
GsonHttpMessageConverter
Implementation of `HttpMessageConverter` that can read and write JSON using the Google Gson library.
HandlerMethod
Encapsulates information about a handler method consisting of a method and a bean.
HandlerMethodArgumentResolver
Strategy interface for resolving method parameters into argument values in the context of a given request.
HandlerMethodArgumentResolverComposite
Resolves method parameters by delegating to a list of registered `HandlerMethodArgumentResolvers`.
HandlerMethodReturnValueHandler
Strategy interface to handle the value returned from the invocation of a handler method.
HandlerMethodReturnValueHandlerComposite
Handles method return values by delegating to a list of registered `HandlerMethodReturnValueHandlers`.
HandlerMethodValidationException
`ResponseStatusException` that is also `MethodValidationResult`.
HandlerMethodValidationException.Visitor
Contract to handle validation results with callbacks by controller method parameter type, with `HandlerMethodValidationException.Visitor.other(org.springframework.validation.method.ParameterValidationResult)` serving as the fallthrough.
HandlerMethodValidator
`MethodValidator` that uses Bean Validation to validate `@RequestMapping` method arguments.
HandlerTypePredicate
A `Predicate` to match request handling component types if any of the following selectors match: Base packages -- for selecting handlers by their package.
HandlerTypePredicate.Builder
A `HandlerTypePredicate` builder.
HeaderContentNegotiationStrategy
A `ContentNegotiationStrategy` that checks the 'Accept' request header.
HeaderWebSessionIdResolver
Request and response header-based `WebSessionIdResolver`.
HiddenHttpMethodFilter
`Filter` that converts posted method parameters into HTTP methods, retrievable via `HttpServletRequest.getMethod()`.
HiddenHttpMethodFilter
Reactive `WebFilter` that converts posted method parameters into HTTP methods, retrievable via `HttpRequest.getMethod()`.
HtmlUtils
Utility class for HTML escaping.
HttpAccessor
Base class for `RestTemplate` and other HTTP accessing gateway helpers, defining common properties such as the `ClientHttpRequestFactory` to operate on.
HttpClientAdapter
Deprecated, for removal: This API element is subject to removal in a future version.
in favor of `ReactorHttpExchangeAdapter`
HttpClientErrorException
Exception thrown when an HTTP 4xx is received.
HttpClientErrorException.BadRequest
`HttpClientErrorException` for status HTTP 400 Bad Request.
HttpClientErrorException.Conflict
`HttpClientErrorException` for status HTTP 409 Conflict.
HttpClientErrorException.Forbidden
`HttpClientErrorException` for status HTTP 403 Forbidden.
HttpClientErrorException.Gone
`HttpClientErrorException` for status HTTP 410 Gone.
HttpClientErrorException.MethodNotAllowed
`HttpClientErrorException` for status HTTP 405 Method Not Allowed.
HttpClientErrorException.NotAcceptable
`HttpClientErrorException` for status HTTP 406 Not Acceptable.
HttpClientErrorException.NotFound
`HttpClientErrorException` for status HTTP 404 Not Found.
HttpClientErrorException.TooManyRequests
`HttpClientErrorException` for status HTTP 429 Too Many Requests.
HttpClientErrorException.Unauthorized
`HttpClientErrorException` for status HTTP 401 Unauthorized.
HttpClientErrorException.UnprocessableEntity
`HttpClientErrorException` for status HTTP 422 Unprocessable Entity.
HttpClientErrorException.UnsupportedMediaType
`HttpClientErrorException` for status HTTP 415 Unsupported Media Type.
HttpComponentsClientHttpConnector
`ClientHttpConnector` implementation for the Apache HttpComponents HttpClient 5.x.
HttpComponentsClientHttpRequestFactory
`ClientHttpRequestFactory` implementation that uses Apache HttpComponents HttpClient to create requests.
HttpComponentsHeadersAdapter
`MultiValueMap` implementation for wrapping Apache HttpComponents HttpClient headers.
HttpCookie
Represents an HTTP cookie as a name-value pair consistent with the content of the "Cookie" request header.
HttpEntity<T>
Represents an HTTP request or response entity, consisting of headers and body.
HttpExchange
Annotation to declare a method on an HTTP service interface as an HTTP endpoint.
HttpExchangeAdapter
Contract to abstract an HTTP client from HttpServiceProxyFactory and make it pluggable.
HttpHandler
Lowest level contract for reactive HTTP request handling that serves as a common denominator across different runtimes.
HttpHandlerDecoratorFactory
Contract for applying a decorator to an `HttpHandler`.
HttpHeaders
A data structure representing HTTP request or response headers, mapping String header names to a list of String values, also offering accessors for common application-level data types.
HttpHeadResponseDecorator
`ServerHttpResponse` decorator for HTTP HEAD requests.
HttpInputMessage
Represents an HTTP input message, consisting of headers and a readable body.
HttpLogging
Holds the shared logger named "org.springframework.web.HttpLogging" for HTTP related logging when "org.springframework.http" is not enabled but "org.springframework.web" is.
HttpMediaTypeException
Abstract base for exceptions related to media types.
HttpMediaTypeNotAcceptableException
Exception thrown when the request handler cannot generate a response that is acceptable by the client.
HttpMediaTypeNotSupportedException
Exception thrown when a client POSTs, PUTs, or PATCHes content of a type not supported by request handler.
HttpMessage
Represents the base interface for HTTP request and response messages.
HttpMessageConversionException
Thrown by `HttpMessageConverter` implementations when a conversion attempt fails.
HttpMessageConverter<T>
Strategy interface for converting from and to HTTP requests and responses.
HttpMessageConverterExtractor<T>
Response extractor that uses the given entity converters to convert the response into a type `T`.
HttpMessageDecoder<T>
Extension of `Decoder` exposing extra methods relevant in the context of HTTP request or response body decoding.
HttpMessageEncoder<T>
Extension of `Encoder` exposing extra methods relevant in the context of HTTP request or response body encoding.
HttpMessageNotReadableException
Thrown by `HttpMessageConverter` implementations when the `HttpMessageConverter.read(java.lang.Class<? extends T>, org.springframework.http.HttpInputMessage)` method fails.
HttpMessageNotWritableException
Thrown by `HttpMessageConverter` implementations when the `HttpMessageConverter.write(T, org.springframework.http.MediaType, org.springframework.http.HttpOutputMessage)` method fails.
HttpMessageReader<T>
Strategy for reading from a `ReactiveHttpInputMessage` and decoding the stream of bytes to Objects of type `<T>`.
HttpMessageWriter<T>
Strategy for encoding a stream of objects of type `<T>` and writing the encoded stream of bytes to an `ReactiveHttpOutputMessage`.
HttpMethod
Represents an HTTP request method.
HttpMethodArgumentResolver
`HttpServiceArgumentResolver` that resolves the target request's HTTP method from an `HttpMethod` argument.
HttpOutputMessage
Represents an HTTP output message, consisting of headers and a writable body.
HttpRange
Represents an HTTP (byte) range for use with the HTTP `"Range"` header.
HttpRequest
Represents an HTTP request message, consisting of a method and a URI.
HttpRequestHandler
Plain handler interface for components that process HTTP requests, analogous to a Servlet.
HttpRequestHandlerServlet
Simple HttpServlet that delegates to an `HttpRequestHandler` bean defined in Spring's root web application context.
HttpRequestMethodNotSupportedException
Exception thrown when a request handler does not support a specific request method.
HttpRequestValues
Container for HTTP request values extracted from an `@HttpExchange`-annotated method and argument values passed to it.
HttpRequestValues.Builder
Builder for `HttpRequestValues`.
HttpRequestValues.Metadata
Expose static metadata from `@HttpExchange` annotation attributes.
HttpRequestWrapper
Provides a convenient implementation of the `HttpRequest` interface that can be overridden to adapt the request.
HttpServerErrorException
Exception thrown when an HTTP 5xx is received.
HttpServerErrorException.BadGateway
`HttpServerErrorException` for HTTP status 502 Bad Gateway.
HttpServerErrorException.GatewayTimeout
`HttpServerErrorException` for status HTTP 504 Gateway Timeout.
HttpServerErrorException.InternalServerError
`HttpServerErrorException` for status HTTP 500 Internal Server Error.
HttpServerErrorException.NotImplemented
`HttpServerErrorException` for status HTTP 501 Not Implemented.
HttpServerErrorException.ServiceUnavailable
`HttpServerErrorException` for status HTTP 503 Service Unavailable.
HttpServiceArgumentResolver
Resolve an argument from an `@HttpExchange`-annotated method to one or more HTTP request values.
HttpServiceProxyFactory
Factory to create a client proxy from an HTTP service interface with `@HttpExchange` methods.
HttpServiceProxyFactory.Builder
Builder to create an `HttpServiceProxyFactory`.
HttpSessionMutexListener
Servlet HttpSessionListener that automatically exposes the session mutex when an HttpSession gets created.
HttpSessionRequiredException
Exception thrown when an HTTP request handler requires a pre-existing session.
HttpStatus
Enumeration of HTTP status codes.
HttpStatus.Series
Enumeration of HTTP status series.
HttpStatusCode
Represents an HTTP response status code.
HttpStatusCodeException
Abstract base class for exceptions based on an `HttpStatusCode`.
HttpWebHandlerAdapter
Default adapter of `WebHandler` to the `HttpHandler` contract.
InitBinder
Annotation that identifies methods that initialize the `WebDataBinder` which will be used for populating command and form object arguments of annotated handler methods.
InitBinderDataBinderFactory
Adds initialization to a WebDataBinder via `@InitBinder` methods.
InMemoryWebSessionStore
Simple Map-based storage for `WebSession` instances.
InterceptingClientHttpRequestFactory
`ClientHttpRequestFactory` wrapper with support for `ClientHttpRequestInterceptors`.
InterceptingHttpAccessor
Base class for `RestTemplate` and other HTTP accessing gateway helpers, adding interceptor-related properties to `HttpAccessor`'s common properties.
IntrospectorCleanupListener
Listener that flushes the JDK's `JavaBeans Introspector` cache on web app shutdown.
InvalidMediaTypeException
Exception thrown from `MediaType.parseMediaType(String)` in case of encountering an invalid media type specification String.
InvalidUrlException
Thrown when a URL string cannot be parsed.
InvocableHandlerMethod
Extension of `HandlerMethod` that invokes the underlying method with argument values resolved from the current HTTP request through a list of `HandlerMethodArgumentResolver`.
Jackson2CborDecoder
Decode bytes into CBOR and convert to Object's with Jackson.
Jackson2CborEncoder
Encode from an `Object` to bytes of CBOR objects using Jackson.
Jackson2CodecSupport
Base class providing support methods for Jackson 2.x encoding and decoding.
Jackson2JsonDecoder
Decode a byte stream into JSON and convert to Object's with Jackson 2.x, leveraging non-blocking parsing.
Jackson2JsonEncoder
Encode from an `Object` stream to a byte stream of JSON objects using Jackson 2.x.
Jackson2ObjectMapperBuilder
A builder used to create `ObjectMapper` instances with a fluent API.
Jackson2ObjectMapperFactoryBean
A `FactoryBean` for creating a Jackson 2.x `ObjectMapper` (default) or `XmlMapper` (`createXmlMapper` property set to true) with setters to enable or disable Jackson features from within XML configuration.
Jackson2SmileDecoder
Decode a byte stream into Smile and convert to Object's with Jackson 2.x, leveraging non-blocking parsing.
Jackson2SmileEncoder
Encode from an `Object` stream to a byte stream of Smile objects using Jackson 2.x.
JavaScriptUtils
Utility class for JavaScript escaping.
Jaxb2CollectionHttpMessageConverter<T extends Collection>
An `HttpMessageConverter` that can read XML collections using JAXB2.
Jaxb2RootElementHttpMessageConverter
Implementation of `HttpMessageConverter` that can read and write XML using JAXB2.
Jaxb2XmlDecoder
Decode from a bytes stream containing XML elements to a stream of `Object`s (POJOs).
Jaxb2XmlEncoder
Encode from single value to a byte stream containing XML elements.
JdkClientHttpConnector
`ClientHttpConnector` for the Java `HttpClient`.
JdkClientHttpRequestFactory
`ClientHttpRequestFactory` implementation based on the Java `HttpClient`.
JdkHttpClientResourceFactory
Factory to manage JDK HttpClient resources such as a shared `Executor` within the lifecycle of a Spring `ApplicationContext`.
JettyClientHttpConnector
`ClientHttpConnector` for the Jetty Reactive Streams HttpClient.
JettyClientHttpRequestFactory
`ClientHttpRequestFactory` implementation based on Jetty's `HttpClient`.
JettyCoreHttpHandlerAdapter
Adapt `HttpHandler` to the Jetty `Handler` abstraction.
JettyHeadersAdapter
`MultiValueMap` implementation for wrapping Jetty HTTP headers.
JettyHttpHandlerAdapter
`ServletHttpHandlerAdapter` extension that uses Jetty APIs for writing to the response with `ByteBuffer`.
JettyResourceFactory
Factory to manage Jetty resources, i.e.
JsonbHttpMessageConverter
Implementation of `HttpMessageConverter` that can read and write JSON using the JSON Binding API.
KotlinSerializationBinaryDecoder<T extends kotlinx.serialization.BinaryFormat>
Abstract base class for `Decoder` implementations that defer to Kotlin binary serializers.
KotlinSerializationBinaryEncoder<T extends kotlinx.serialization.BinaryFormat>
Abstract base class for `Encoder` implementations that defer to Kotlin binary serializers.
KotlinSerializationBinaryHttpMessageConverter<T extends kotlinx.serialization.BinaryFormat>
Abstract base class for `HttpMessageConverter` implementations that defer to Kotlin binary serializers.
KotlinSerializationCborDecoder
Decode a byte stream into CBOR and convert to Objects with kotlinx.serialization.
KotlinSerializationCborEncoder
Encode from an `Object` stream to a byte stream of CBOR objects using kotlinx.serialization.
KotlinSerializationCborHttpMessageConverter
Implementation of `HttpMessageConverter` that can read and write CBOR using kotlinx.serialization.
KotlinSerializationJsonDecoder
Decode a byte stream into JSON and convert to Object's with kotlinx.serialization.
KotlinSerializationJsonEncoder
Encode from an `Object` stream to a byte stream of JSON objects using kotlinx.serialization.
KotlinSerializationJsonHttpMessageConverter
Implementation of `HttpMessageConverter` that can read and write JSON using kotlinx.serialization.
KotlinSerializationProtobufDecoder
Decode a byte stream into a protocol Buffer and convert to Objects with kotlinx.serialization.
KotlinSerializationProtobufEncoder
Decode a byte stream into a Protocol Buffer and convert to Objects with kotlinx.serialization.
KotlinSerializationProtobufHttpMessageConverter
Implementation of `HttpMessageConverter` that can read and write Protocol Buffers using kotlinx.serialization.
KotlinSerializationStringDecoder<T extends kotlinx.serialization.StringFormat>
Abstract base class for `Decoder` implementations that defer to Kotlin string serializers.
KotlinSerializationStringEncoder<T extends kotlinx.serialization.StringFormat>
Abstract base class for `Encoder` implementations that defer to Kotlin string serializers.
KotlinSerializationStringHttpMessageConverter<T extends kotlinx.serialization.StringFormat>
Abstract base class for `HttpMessageConverter` implementations that defer to Kotlin string serializers.
KotlinSerializationSupport<T extends kotlinx.serialization.SerialFormat>
Base class providing support methods for encoding and decoding with Kotlin serialization.
LocaleContextResolver
Interface for web-based locale context resolution strategies that allows for both locale context resolution via the request and locale context modification via the HTTP exchange.
LoggingCodecSupport
Base class for `Encoder`, `Decoder`, `HttpMessageReader`, or `HttpMessageWriter` that uses a logger and shows potentially sensitive request data.
MapMethodProcessor
Resolves `Map` method arguments and handles `Map` return values.
Mapping
Meta annotation that indicates a web mapping annotation.
MappingJackson2CborHttpMessageConverter
Implementation of `HttpMessageConverter` that can read and write the CBOR data format using the dedicated Jackson 2.x extension.
MappingJackson2HttpMessageConverter
Implementation of `HttpMessageConverter` that can read and write JSON using Jackson 2.x's `ObjectMapper`.
MappingJackson2SmileHttpMessageConverter
Implementation of `HttpMessageConverter` that can read and write Smile data format ("binary JSON") using the dedicated Jackson 2.x extension.
MappingJackson2XmlHttpMessageConverter
Implementation of `HttpMessageConverter` that can read and write XML using Jackson 2.x extension component for reading and writing XML encoded data.
MappingJackson2YamlHttpMessageConverter
Implementation of `HttpMessageConverter` that can read and write the YAML data format using the dedicated Jackson 2.x extension.
MappingJacksonInputMessage
`HttpInputMessage` that can eventually stores a Jackson view that will be used to deserialize the message.
MappingJacksonValue
A simple holder for the POJO to serialize via `MappingJackson2HttpMessageConverter` along with further serialization instructions to be passed in to the converter.
MappingMediaTypeFileExtensionResolver
An implementation of `MediaTypeFileExtensionResolver` that maintains lookups between file extensions and MediaTypes in both directions.
MarshallingHttpMessageConverter
Implementation of `HttpMessageConverter` that can read and write XML using Spring's `Marshaller` and `Unmarshaller` abstractions.
MatrixVariable
Annotation which indicates that a method parameter should be bound to a name-value pair within a path segment.
MaxUploadSizeExceededException
MultipartException subclass thrown when an upload exceeds the maximum upload size allowed.
MediaType
A subclass of `MimeType` that adds support for quality parameters as defined in the HTTP specification.
MediaTypeEditor
`Editor` for `MediaType` descriptors, to automatically convert `String` specifications (for example, `"text/html"`) to `MediaType` properties.
MediaTypeFactory
A factory delegate for resolving `MediaType` objects from `Resource` handles or filenames.
MediaTypeFileExtensionResolver
Strategy to resolve a `MediaType` to a list of file extensions — for example, to resolve "application/json" to "json".
MethodArgumentConversionNotSupportedException
A ConversionNotSupportedException raised while resolving a method argument.
MethodArgumentNotValidException
`BindException` to be thrown when validation on an argument annotated with `@Valid` fails.
MethodArgumentTypeMismatchException
A TypeMismatchException raised while resolving a controller method argument.
MethodNotAllowedException
Exception for errors that fit response status 405 (method not allowed).
MissingMatrixVariableException
`ServletRequestBindingException` subclass that indicates that a matrix variable expected in the method parameters of an `@RequestMapping` method is not present among the matrix variables extracted from the URL.
MissingPathVariableException
`ServletRequestBindingException` subclass that indicates that a path variable expected in the method parameters of an `@RequestMapping` method is not present among the URI variables extracted from the URL.
MissingRequestCookieException
`ServletRequestBindingException` subclass that indicates that a request cookie expected in the method parameters of an `@RequestMapping` method is not present.
MissingRequestHeaderException
`ServletRequestBindingException` subclass that indicates that a request header expected in the method parameters of an `@RequestMapping` method is not present.
MissingRequestValueException
Base class for `ServletRequestBindingException` exceptions that could not bind because the request value is required but is either missing or otherwise resolves to `null` after conversion.
MissingRequestValueException
`ServerWebInputException` subclass that indicates a missing request value such as a request header, cookie value, query parameter, etc.
MissingServletRequestParameterException
`ServletRequestBindingException` subclass that indicates a missing parameter.
MissingServletRequestPartException
Signals the part of a "multipart/form-data" request, identified by name could not be found.
ModelAndViewContainer
Records model and view related decisions made by `HandlerMethodArgumentResolvers` and `HandlerMethodReturnValueHandlers` during the course of invocation of a controller method.
ModelAttribute
Annotation that binds a method parameter or method return value to a named model attribute, exposed to a web view.
ModelAttributeMethodProcessor
Resolve `@ModelAttribute` annotated method arguments and handle return values from `@ModelAttribute` annotated methods.
ModelFactory
Assist with initialization of the `Model` before controller method invocation and with updates to it after the invocation.
ModelMethodProcessor
Resolves `Model` arguments and handles `Model` return values.
MultipartBodyBuilder
Prepare the body of a multipart request, resulting in a `MultiValueMap<String, HttpEntity>`.
MultipartBodyBuilder.PartBuilder
Builder that allows for further customization of part headers.
MultipartException
Exception thrown when multipart resolution fails.
MultipartFile
A representation of an uploaded file received in a multipart request.
MultipartFilter
Servlet Filter that resolves multipart requests via a `MultipartResolver`.
MultipartHttpMessageReader
`HttpMessageReader` for reading `"multipart/form-data"` requests into a `MultiValueMap<String, Part>`.
MultipartHttpMessageWriter
`HttpMessageWriter` for writing a `MultiValueMap<String, ?>` as multipart form data, i.e.
MultipartHttpServletRequest
Provides additional methods for dealing with multipart content within a servlet request, allowing to access uploaded files.
MultipartRequest
This interface defines the multipart request access operations that are exposed for actual multipart requests.
MultipartResolutionDelegate
A common delegate for `HandlerMethodArgumentResolver` implementations which need to resolve `MultipartFile` and `Part` arguments.
MultipartResolver
A strategy interface for multipart file upload resolution in accordance with RFC 1867.
MultipartWriterSupport
Support class for multipart HTTP message writers.
NativeWebRequest
Extension of the `WebRequest` interface, exposing the native request and response objects in a generic fashion.
NestedServletException
Deprecated.
as of 6.0, in favor of standard `ServletException` nesting
Netty4HeadersAdapter
`MultiValueMap` implementation for wrapping Netty 4 HTTP headers.
Netty5HeadersAdapter
Deprecated, for removal: This API element is subject to removal in a future version.
NoOpResponseErrorHandler
A basic, no operation `ResponseErrorHandler` implementation suitable for ignoring any error using the `RestTemplate` or `RestClient`.
NotAcceptableStatusException
Exception for errors that fit response status 406 (not acceptable).
ObjectToStringHttpMessageConverter
An `HttpMessageConverter` that uses `StringHttpMessageConverter` for reading and writing content and a `ConversionService` for converting the String content to and from the target object type.
OkHttp3ClientHttpRequestFactory
Deprecated, for removal: This API element is subject to removal in a future version.
since 6.1, in favor of other `ClientHttpRequestFactory` implementations; scheduled for removal in 7.0
OncePerRequestFilter
Filter base class that aims to guarantee a single execution per request dispatch, on any servlet container.
ParameterContentNegotiationStrategy
Strategy that resolves the requested content type from a query parameter.
Part
Representation for a part in a "multipart/form-data" request.
PartEvent
Represents an event for a "multipart/form-data" request.
PartEventHttpMessageReader
`HttpMessageReader` for parsing `"multipart/form-data"` requests to a stream of `PartEvent` elements.
PartEventHttpMessageWriter
`HttpMessageWriter` for writing `PartEvent` objects.
PartHttpMessageWriter
`HttpMessageWriter` for writing with `Part`.
PatchExchange
Shortcut for `@HttpExchange` for HTTP PATCH requests.
PatchMapping
Annotation for mapping HTTP `PATCH` requests onto specific handler methods.
PathContainer
Structured representation of a URI path parsed via `PathContainer.parsePath(String)` into a sequence of `PathContainer.Separator` and `PathContainer.PathSegment` elements.
PathContainer.Element
A path element, either separator or path segment.
PathContainer.Options
Options to customize parsing based on the type of input path.
PathContainer.PathSegment
Path segment element.
PathContainer.Separator
Path separator element.
PathExtensionContentNegotiationStrategy
Deprecated.
as of 5.2.4.
PathPattern
Representation of a parsed path pattern.
PathPattern.PathMatchInfo
Holder for URI variables and path parameters (matrix variables) extracted based on the pattern for a given matched path.
PathPattern.PathRemainingMatchInfo
Holder for the result of a match on the start of a pattern.
PathPatternParser
Parser for URI path patterns producing `PathPattern` instances that can then be matched to requests.
PathPatternRouteMatcher
`RouteMatcher` built on `PathPatternParser` that uses `PathContainer` and `PathPattern` as parsed representations of routes and patterns.
PathVariable
Annotation which indicates that a method parameter should be bound to a URI template variable.
PathVariableArgumentResolver
`HttpServiceArgumentResolver` for `@PathVariable` annotated arguments.
PatternParseException
Exception that is thrown when there is a problem with the pattern being parsed.
PatternParseException.PatternMessage
The messages that can be included in a `PatternParseException` when there is a parse failure.
PayloadTooLargeException
Exception for errors that fit response status 413 (payload too large) for use in Spring Web applications.
PostExchange
Shortcut for `@HttpExchange` for HTTP POST requests.
PostMapping
Annotation for mapping HTTP `POST` requests onto specific handler methods.
PreFlightRequestHandler
Handler for CORS pre-flight requests.
PreFlightRequestHandler
Handler for CORS pre-flight requests.
PreFlightRequestWebFilter
WebFilter that handles pre-flight requests through a `PreFlightRequestHandler` and bypasses the rest of the chain.
ProblemDetail
Representation for an RFC 9457 problem detail.
ProblemDetailJacksonMixin
An interface to associate Jackson annotations with `ProblemDetail` to avoid a hard dependency on the Jackson library.
ProblemDetailJacksonXmlMixin
Provides the same declarations as `ProblemDetailJacksonMixin` and some additional ones to support XML serialization when `jackson-dataformat-xml` is on the classpath.
ProtobufCodecSupport
Base class providing support methods for Protobuf encoding and decoding.
ProtobufDecoder
A `Decoder` that reads `Message`s using Google Protocol Buffers.
ProtobufEncoder
An `Encoder` that writes `Message`s using Google Protocol Buffers.
ProtobufHttpMessageConverter
An `HttpMessageConverter` that reads and writes `com.google.protobuf.Messages` using Google Protocol Buffers.
ProtobufHttpMessageWriter
`HttpMessageWriter` that can write a protobuf `Message` and adds `X-Protobuf-Schema`, `X-Protobuf-Message` headers and a `delimited=true` parameter is added to the content type if a flux is serialized.
ProtobufJsonDecoder
A `Decoder` that reads a JSON byte stream and converts it to Google Protocol Buffers `Message`s.
ProtobufJsonEncoder
A `Encoder` that writes `Message`s as JSON.
ProtobufJsonFormatHttpMessageConverter
Subclass of `ProtobufHttpMessageConverter` which enforces the use of Protobuf 3 and its official library `"com.google.protobuf:protobuf-java-util"` for JSON processing.
ProxyFactoryBean
`FactoryBean` that creates a `java.net.Proxy`.
PutExchange
Shortcut for `@HttpExchange` for HTTP PUT requests.
PutMapping
Annotation for mapping HTTP `PUT` requests onto specific handler methods.
ReactiveHttpInputMessage
A "reactive" HTTP input message that exposes the input as `Publisher`.
ReactiveHttpOutputMessage
A "reactive" HTTP output message that accepts output as a `Publisher`.
ReactiveHttpRequestValues
`HttpRequestValues` extension for use with `ReactorHttpExchangeAdapter`.
ReactiveHttpRequestValues.Builder
Builder for `ReactiveHttpRequestValues`.
ReactorClientHttpConnector
Reactor-Netty implementation of `ClientHttpConnector`.
ReactorClientHttpRequestFactory
Reactor-Netty implementation of `ClientHttpRequestFactory`.
ReactorHttpExchangeAdapter
Contract to abstract a reactive, HTTP client from HttpServiceProxyFactory and make it pluggable.
ReactorHttpHandlerAdapter
Adapt `HttpHandler` to the Reactor Netty channel handling function.
ReactorNetty2ClientHttpConnector
Deprecated, for removal: This API element is subject to removal in a future version.
as of 6.2.18 with no replacement
ReactorNetty2HttpHandlerAdapter
Deprecated, for removal: This API element is subject to removal in a future version.
as of 6.2.18 with no replacement
ReactorNetty2ResourceFactory
Deprecated, for removal: This API element is subject to removal in a future version.
as of 6.2.18 with no replacement
ReactorNettyClientRequestFactory
Deprecated, for removal: This API element is subject to removal in a future version.
in favor of the renamed `ReactorClientHttpRequestFactory`
ReactorResourceFactory
Deprecated.
since 6.1 due to a package change; use `ReactorResourceFactory` instead.
ReactorResourceFactory
Factory to manage Reactor Netty resources, i.e.
RelativeRedirectFilter
Overrides `HttpServletResponse.sendRedirect(String)` and handles it by setting the HTTP status and "Location" headers, which keeps the Servlet container from re-writing relative redirect URLs into absolute ones.
RequestAttribute
Annotation to bind a method parameter to a request attribute.
RequestAttributeArgumentResolver
`HttpServiceArgumentResolver` for `@RequestAttribute` annotated arguments.
RequestAttributes
Abstraction for accessing attribute objects associated with a request.
RequestAttributesThreadLocalAccessor
Adapt `RequestContextHolder` to the `ThreadLocalAccessor` contract to assist the Micrometer Context Propagation library with `RequestAttributes` propagation.
RequestBody
Annotation indicating a method parameter should be bound to the body of the web request.
RequestBodyArgumentResolver
`HttpServiceArgumentResolver` for `@RequestBody` annotated arguments.
RequestCallback
Callback interface for code that operates on a `ClientHttpRequest`.
RequestContextFilter
Servlet Filter that exposes the request to the current thread, through both `LocaleContextHolder` and `RequestContextHolder`.
RequestContextHolder
Holder class to expose the web request in the form of a thread-bound `RequestAttributes` object.
RequestContextListener
Servlet listener that exposes the request to the current thread, through both `LocaleContextHolder` and `RequestContextHolder`.
RequestEntity<T>
Extension of `HttpEntity` that also exposes the HTTP method and the target URL.
RequestEntity.BodyBuilder
Defines a builder that adds a body to the response entity.
RequestEntity.HeadersBuilder<B extends RequestEntity.HeadersBuilder<B>>
Defines a builder that adds headers to the request entity.
RequestEntity.UriTemplateRequestEntity<T>
RequestEntity initialized with a URI template and variables instead of a `URI`.
RequestHandledEvent
Event raised when a request is handled within an ApplicationContext.
RequestHeader
Annotation which indicates that a method parameter should be bound to a web request header.
RequestHeaderArgumentResolver
`HttpServiceArgumentResolver` for `@RequestHeader` annotated arguments.
RequestHeaderMapMethodArgumentResolver
Resolves `Map` method arguments annotated with `@RequestHeader`.
RequestHeaderMethodArgumentResolver
Resolves method arguments annotated with `@RequestHeader` except for `Map` arguments.
RequestMapping
Annotation for mapping web requests onto methods in request-handling classes with flexible method signatures.
RequestMethod
Enumeration of HTTP request methods.
RequestParam
Annotation which indicates that a method parameter should be bound to a web request parameter.
RequestParamArgumentResolver
`HttpServiceArgumentResolver` for `@RequestParam` annotated arguments.
RequestParamMapMethodArgumentResolver
Resolves `Map` method arguments annotated with an @`RequestParam` where the annotation does not specify a request parameter name.
RequestParamMethodArgumentResolver
Resolves method arguments annotated with @`RequestParam`, arguments of type `MultipartFile` in conjunction with Spring's `MultipartResolver` abstraction, and arguments of type `jakarta.servlet.http.Part` in conjunction with Servlet multipart requests.
RequestPart
Annotation that can be used to associate the part of a "multipart/form-data" request with a method argument.
RequestPartArgumentResolver
`HttpServiceArgumentResolver` for `@RequestPart` annotated arguments.
RequestPartServletServerHttpRequest
`ServerHttpRequest` implementation that accesses one part of a multipart request.
RequestPath
Specialization of `PathContainer` that subdivides the path into a `RequestPath.contextPath()` and the remaining `RequestPath.pathWithinApplication()`.
RequestScope
`@RequestScope` is a specialization of `@Scope` for a component whose lifecycle is bound to the current web request.
RequestScope
Request-backed `Scope` implementation.
ResourceAccessException
Exception thrown when an I/O error occurs.
ResourceHttpMessageConverter
Implementation of `HttpMessageConverter` that can read/write `Resources` and supports byte range requests.
ResourceHttpMessageReader
`HttpMessageReader` that wraps and delegates to a `ResourceDecoder` that extracts the filename from the `"Content-Disposition"` header, if available, and passes it as the `ResourceDecoder.FILENAME_HINT`.
ResourceHttpMessageWriter
`HttpMessageWriter` that can write a `Resource` from both client and server perspectives.
ResourceRegionHttpMessageConverter
Implementation of `HttpMessageConverter` that can write a single `ResourceRegion` or Collections of `ResourceRegions`.
ResponseBody
Annotation that indicates a method return value should be bound to the web response body.
ResponseCookie
An `HttpCookie` subclass with the additional attributes allowed in the "Set-Cookie" response header.
ResponseCookie.ResponseCookieBuilder
A builder for a server-defined HttpCookie with attributes.
ResponseEntity<T>
Extension of `HttpEntity` that adds an `HttpStatusCode` status code.
ResponseEntity.BodyBuilder
Defines a builder that adds a body to the response entity.
ResponseEntity.HeadersBuilder<B extends ResponseEntity.HeadersBuilder<B>>
Defines a builder that adds headers to the response entity.
ResponseErrorHandler
Strategy interface used by the `RestTemplate` and `RestClient` to determine whether a particular response has an error or not.
ResponseExtractor<T>
Generic callback interface used by `RestTemplate`'s retrieval methods.
ResponseStatus
Marks a method or exception class with the status `ResponseStatus.code()` and `ResponseStatus.reason()` that should be returned.
ResponseStatusException
Subclass of `ErrorResponseException` that accepts a "reason", and by default maps that to the `"detail"` of the `ProblemDetail`.
ResponseStatusExceptionHandler
Handle `ResponseStatusException` by setting the response status.
RestClient
Client to perform HTTP requests, exposing a fluent, synchronous API over underlying HTTP client libraries such as the JDK `HttpClient`, Apache HttpComponents, and others.
RestClient.Builder
A mutable builder for creating a `RestClient`.
RestClient.RequestBodySpec
Contract for specifying request headers and body leading up to the exchange.
RestClient.RequestBodyUriSpec
Contract for specifying request headers, body and URI for a request.
RestClient.RequestHeadersSpec<S extends RestClient.RequestHeadersSpec<S>>
Contract for specifying request headers leading up to the exchange.
RestClient.RequestHeadersSpec.ConvertibleClientHttpResponse
Extension of `ClientHttpResponse` that can convert the body.
RestClient.RequestHeadersSpec.ExchangeFunction<T>
Defines the contract for `RestClient.RequestHeadersSpec.exchange(ExchangeFunction)`.
RestClient.RequestHeadersSpec.RequiredValueExchangeFunction<T>
Variant of `RestClient.RequestHeadersSpec.ExchangeFunction` returning a non-null required value.
RestClient.RequestHeadersUriSpec<S extends RestClient.RequestHeadersSpec<S>>
Contract for specifying request headers and URI for a request.
RestClient.ResponseSpec
Contract for specifying response operations following the exchange.
RestClient.ResponseSpec.ErrorHandler
Used in `RestClient.ResponseSpec.onStatus(Predicate, ErrorHandler)`.
RestClient.UriSpec<S extends RestClient.RequestHeadersSpec<?>>
Contract for specifying the URI for a request.
RestClientAdapter
`HttpExchangeAdapter` that enables an `HttpServiceProxyFactory` to use `RestClient` for request execution.
RestClientException
Base class for exceptions thrown by `RestClient` and `RestTemplate` in case a request fails because of a server error response, a failure to decode the response, or a low level I/O error.
RestClientResponseException
Common base class for exceptions that contain actual HTTP response data.
RestController
A convenience annotation that is itself annotated with `@Controller` and `@ResponseBody`.
RestControllerAdvice
A shortcut annotation that combines `@ControllerAdvice` with `@ResponseBody`, in effect simply an `@ControllerAdvice` whose exception handler methods render to the response body.
RestGatewaySupport
Convenient superclass for application classes that need REST access.
RestOperations
Interface specifying a basic set of RESTful operations.
RestTemplate
Synchronous client to perform HTTP requests, exposing a simple, template method API over underlying HTTP client libraries such as the JDK `HttpURLConnection`, Apache HttpComponents, and others.
RestTemplateAdapter
`HttpExchangeAdapter` that enables an `HttpServiceProxyFactory` to use `RestTemplate` for request execution.
RssChannelHttpMessageConverter
Implementation of `HttpMessageConverter` that can read and write RSS feeds.
ServerCodecConfigurer
Extension of `CodecConfigurer` for HTTP message reader and writer options relevant on the server side.
ServerCodecConfigurer.ServerDefaultCodecs
`CodecConfigurer.DefaultCodecs` extension with extra server-side options.
ServerErrorException
Exception for an `HttpStatus.INTERNAL_SERVER_ERROR` that exposes extra information about a controller method that failed, or a controller method argument that could not be resolved.
ServerHttpAsyncRequestControl
A control that can put the processing of an HTTP request in asynchronous mode during which the response remains open until explicitly closed.
ServerHttpObservationDocumentation
Documented `KeyValues` for the HTTP server observations for Servlet-based web applications.
ServerHttpObservationDocumentation
Documented `KeyValues` for the HTTP server observations for reactive web applications.
ServerHttpObservationDocumentation.HighCardinalityKeyNames
ServerHttpObservationDocumentation.HighCardinalityKeyNames
ServerHttpObservationDocumentation.LowCardinalityKeyNames
ServerHttpObservationDocumentation.LowCardinalityKeyNames
ServerHttpObservationFilter
Deprecated, for removal: This API element is subject to removal in a future version.
since 6.1 in favor of `WebHttpHandlerBuilder`.
ServerHttpObservationFilter
`Filter` that creates `observations` for HTTP exchanges.
ServerHttpRequest
Represents a reactive server-side HTTP request.
ServerHttpRequest
Represents a server-side HTTP request.
ServerHttpRequest.Builder
Builder for mutating an existing `ServerHttpRequest`.
ServerHttpRequestDecorator
Wraps another `ServerHttpRequest` and delegates all methods to it.
ServerHttpResponse
Represents a reactive server-side HTTP response.
ServerHttpResponse
Represents a server-side HTTP response.
ServerHttpResponseDecorator
Wraps another `ServerHttpResponse` and delegates all methods to it.
ServerRequestObservationContext
Context that holds information for metadata collection regarding `Servlet HTTP requests` observations.
ServerRequestObservationContext
Context that holds information for metadata collection regarding `reactive HTTP requests` observations.
ServerRequestObservationConvention
Interface for an `ObservationConvention` for `Servlet HTTP requests`.
ServerRequestObservationConvention
Interface for an `ObservationConvention` for `reactive HTTP requests`.
ServerSentEvent<T>
Representation for a Server-Sent Event for use with Spring's reactive Web support.
ServerSentEvent.Builder<T>
A mutable builder for a `ServerSentEvent`.
ServerSentEventHttpMessageReader
Reader that supports a stream of `ServerSentEvents` and also plain `Objects` which is the same as an `ServerSentEvent` with data only.
ServerSentEventHttpMessageWriter
`HttpMessageWriter` for `"text/event-stream"` responses.
ServerWebExchange
Contract for an HTTP request-response interaction.
ServerWebExchange.Builder
Builder for mutating an existing `ServerWebExchange`.
ServerWebExchangeContextFilter
Inserts an attribute in the Reactor `Context` that makes the current `ServerWebExchange` available under the attribute name `ServerWebExchangeContextFilter.EXCHANGE_CONTEXT_ATTRIBUTE`.
ServerWebExchangeDecorator
A convenient base class for classes that need to wrap another `ServerWebExchange`.
ServerWebInputException
Exception for errors that fit response status 400 (bad request) for use in Spring Web applications.
ServletConfigAware
Interface to be implemented by any object that wishes to be notified of the `ServletConfig` (typically determined by the `WebApplicationContext`) that it runs in.
ServletConfigPropertySource
`PropertySource` that reads init parameters from a `ServletConfig` object.
ServletContextAttributeExporter
Exporter that takes Spring-defined objects and exposes them as ServletContext attributes.
ServletContextAttributeFactoryBean
`FactoryBean` that fetches a specific, existing ServletContext attribute.
ServletContextAware
Interface to be implemented by any object that wishes to be notified of the `ServletContext` (typically determined by the `WebApplicationContext`) that it runs in.
ServletContextAwareProcessor
`BeanPostProcessor` implementation that passes the ServletContext to beans that implement the `ServletContextAware` interface.
ServletContextParameterFactoryBean
`FactoryBean` that retrieves a specific ServletContext init parameter (that is, a "context-param" defined in `web.xml`).
ServletContextPropertySource
`PropertySource` that reads init parameters from a `ServletContext` object.
ServletContextPropertyUtils
Helper class for resolving placeholders in texts.
ServletContextRequestLoggingFilter
Simple request logging filter that writes the request URI (and optionally the query string) to the ServletContext log.
ServletContextResource
`Resource` implementation for `ServletContext` resources, interpreting relative paths within the web application root directory.
ServletContextResourceLoader
ResourceLoader implementation that resolves paths as ServletContext resources, for use outside a WebApplicationContext (for example, in an HttpServletBean or GenericFilterBean subclass).
ServletContextResourcePatternResolver
ServletContext-aware subclass of `PathMatchingResourcePatternResolver`, able to find matching resources below the web application root directory via `ServletContext.getResourcePaths(java.lang.String)`.
ServletContextScope
`Scope` wrapper for a ServletContext, i.e.
ServletHttpHandlerAdapter
Adapt `HttpHandler` to an `HttpServlet` using Servlet Async support and Servlet non-blocking I/O.
ServletPathExtensionContentNegotiationStrategy
Deprecated.
as of 5.2.4.
ServletRequestAttributes
Servlet-based implementation of the `RequestAttributes` interface.
ServletRequestBindingException
Fatal binding exception, thrown when we want to treat binding exceptions as unrecoverable.
ServletRequestDataBinder
Special `DataBinder` to perform data binding from servlet request parameters to JavaBeans, including support for multipart files.
ServletRequestDataBinder.ServletRequestValueResolver
Resolver that looks up values to bind in a `ServletRequest`.
ServletRequestHandledEvent
Servlet-specific subclass of RequestHandledEvent, adding servlet-specific context information.
ServletRequestParameterPropertyValues
PropertyValues implementation created from parameters in a ServletRequest.
ServletRequestPathFilter
`Filter` that `parses and caches` a `RequestPath` that can then be accessed via `ServletRequestPathUtils.getParsedRequestPath(jakarta.servlet.ServletRequest)`.
ServletRequestPathUtils
Utility class to assist with preparation and access to the lookup path for request mapping purposes.
ServletRequestUtils
Parameter extraction methods, for an approach distinct from data binding, in which parameters of specific types are required.
ServletServerHttpAsyncRequestControl
A `ServerHttpAsyncRequestControl` to use on Servlet containers.
ServletServerHttpRequest
`ServerHttpRequest` implementation that is based on a `HttpServletRequest`.
ServletServerHttpResponse
`ServerHttpResponse` implementation that is based on a `HttpServletResponse`.
ServletWebRequest
`WebRequest` adapter for an `HttpServletRequest`.
SessionAttribute
Annotation to bind a method parameter to a session attribute.
SessionAttributes
Annotation that indicates the session attributes that a specific handler uses.
SessionAttributesHandler
Manages controller-specific session attributes declared via `@SessionAttributes`.
SessionAttributeStore
Strategy interface for storing model attributes in a backend session.
SessionScope
`@SessionScope` is a specialization of `@Scope` for a component whose lifecycle is bound to the current web session.
SessionScope
Session-backed `Scope` implementation.
SessionStatus
Simple interface that can be injected into handler methods, allowing them to signal that their session processing is complete.
SessionStatusMethodArgumentResolver
Resolves a `SessionStatus` argument by obtaining it from the `ModelAndViewContainer`.
ShallowEtagHeaderFilter
`Filter` that generates an `ETag` value based on the content on the response.
SimpleClientHttpRequestFactory
`ClientHttpRequestFactory` implementation that uses standard JDK facilities.
SimpleSessionStatus
Simple implementation of the `SessionStatus` interface, keeping the `complete` flag as an instance variable.
SmartHttpMessageConverter<T>
A specialization of `HttpMessageConverter` that can convert an HTTP request into a target object of a specified `ResolvableType` and a source object of a specified `ResolvableType` into an HTTP response with optional hints.
SourceHttpMessageConverter<T extends Source>
Implementation of `HttpMessageConverter` that can read and write `Source` objects.
SpringBeanAutowiringSupport
Convenient base class for self-autowiring classes that gets constructed within a Spring-based web application.
SpringBeanFacesELResolver
JSF `ELResolver` that delegates to the Spring root `WebApplicationContext`, resolving name references to Spring-defined beans.
SpringHandlerInstantiator
Allows for creating Jackson (`JsonSerializer`, `JsonDeserializer`, `KeyDeserializer`, `TypeResolverBuilder`, `TypeIdResolver`) beans with autowiring against a Spring `ApplicationContext`.
SpringServletContainerInitializer
A Spring-provided `ServletContainerInitializer` designed to support code-based configuration of the servlet container using Spring's `WebApplicationInitializer` SPI as opposed to (or possibly in combination with) the traditional `web.xml`-based approach.
SpringWebConstraintValidatorFactory
JSR-303 `ConstraintValidatorFactory` implementation that delegates to the current Spring `WebApplicationContext` for creating autowired `ConstraintValidator` instances.
SslInfo
A holder for SSL session information.
StandardMultipartHttpServletRequest
Spring MultipartHttpServletRequest adapter, wrapping a Servlet HttpServletRequest and its Part objects.
StandardServletAsyncWebRequest
A Servlet implementation of `AsyncWebRequest`.
StandardServletEnvironment
`Environment` implementation to be used by `Servlet`-based web applications.
StandardServletMultipartResolver
Standard implementation of the `MultipartResolver` interface, based on the Servlet `Part` API.
StandardServletPartUtils
Utility methods for standard Servlet `Part` handling.
StaticWebApplicationContext
Static `WebApplicationContext` implementation for testing.
StreamingHttpOutputMessage
Contract for `HttpOutputMessage` implementations to expose the ability to stream request body content by writing to an `OutputStream` from a callback.
StreamingHttpOutputMessage.Body
Contract to stream request body content to an `OutputStream`.
StringHttpMessageConverter
Implementation of `HttpMessageConverter` that can read and write strings.
StringMultipartFileEditor
Custom `PropertyEditor` for converting `MultipartFiles` to Strings.
TagUtils
Utility class for tag library related code, exposing functionality such as translating `Strings` to web scopes.
TimeoutCallableProcessingInterceptor
Sends a 503 (SERVICE_UNAVAILABLE) in case of a timeout if the response is not already committed.
TimeoutDeferredResultProcessingInterceptor
Sends a 503 (SERVICE_UNAVAILABLE) in case of a timeout if the response is not already committed.
TomcatHttpHandlerAdapter
`ServletHttpHandlerAdapter` extension that uses Tomcat APIs for reading from the request and writing to the response with `ByteBuffer`.
UndertowHttpHandlerAdapter
Deprecated, for removal: This API element is subject to removal in a future version.
as of 6.2.18 with no replacement
UnknownContentTypeException
Raised when no suitable `HttpMessageConverter` could be found to extract the response.
UnknownHttpStatusCodeException
Exception thrown when an unknown (or custom) HTTP status code is received.
UnsatisfiedRequestParameterException
`ServerWebInputException` subclass that indicates an unsatisfied parameter condition, as typically expressed using an `@RequestMapping` annotation at the `@Controller` type level.
UnsatisfiedServletRequestParameterException
`ServletRequestBindingException` subclass that indicates an unsatisfied parameter condition, as typically expressed using an `@RequestMapping` annotation at the `@Controller` type level.
UnsupportedMediaTypeStatusException
Exception for errors that fit response status 415 (unsupported media type).
UriBuilder
Builder-style methods to prepare and expand a URI template with variables.
UriBuilderFactory
Factory to create `UriBuilder` instances with shared configuration such as a base URI, an encoding mode strategy, and others across all URI builder instances created through a factory.
UriBuilderFactoryArgumentResolver
An `HttpServiceArgumentResolver` that uses the provided `UriBuilderFactory` to expand the `UriTemplate`.
UriComponents
Represents an immutable collection of URI components, mapping component type to String values.
UriComponents.UriTemplateVariables
Defines the contract for URI Template variables.
UriComponentsBuilder
Builder for `UriComponents`.
UriComponentsBuilder.ParserType
Enum to provide a choice of URI parsers to use in `UriComponentsBuilder.fromUriString(String, ParserType)`.
UriComponentsContributor
Strategy for contributing to the building of a `UriComponents` by looking at a method parameter and an argument value and deciding what part of the target URL should be updated.
UriTemplate
Representation of a URI template that can be expanded with URI variables via `UriTemplate.expand(Map)` or `UriTemplate.expand(Object[])`, or matched to a URL via `UriTemplate.match(String)`.
UriTemplateHandler
Defines methods for expanding a URI template with variables.
UriUtils
Utility methods for URI encoding and decoding based on RFC 3986.
UrlArgumentResolver
`HttpServiceArgumentResolver` that resolves the URL for the request from a `URI` argument.
UrlBasedCorsConfigurationSource
`CorsConfigurationSource` that uses URL patterns to select the `CorsConfiguration` for a request.
UrlBasedCorsConfigurationSource
`CorsConfigurationSource` that uses URL path patterns to select the `CorsConfiguration` for a request.
UrlHandlerFilter
`WebFilter` that modifies the URL, and then redirects or wraps the request to apply the change.
UrlHandlerFilter
`Filter` that modifies the URL, and then either redirects or wraps the request to effect the change.
UrlHandlerFilter.Builder
Builder for `UrlHandlerFilter`.
UrlHandlerFilter.Builder
Builder for `UrlHandlerFilter`.
UrlHandlerFilter.Builder.TrailingSlashSpec
A spec to configure a trailing slash handler.
UrlHandlerFilter.Builder.TrailingSlashSpec
A spec to configure a trailing slash handler.
UrlPathHelper
Helper class for URL path matching.
ValueConstants
Common value constants shared between bind annotations.
WebApplicationContext
Interface to provide configuration for a web application.
WebApplicationContextFacesELResolver
Special JSF `ELResolver` that exposes the Spring `WebApplicationContext` instance under a variable named "webApplicationContext".
WebApplicationContextUtils
Convenience methods for retrieving the root `WebApplicationContext` for a given `ServletContext`.
WebApplicationInitializer
Interface to be implemented in Servlet environments in order to configure the `ServletContext` programmatically -- as opposed to (or possibly in conjunction with) the traditional `web.xml`-based approach.
WebApplicationObjectSupport
Convenient superclass for application objects running in a `WebApplicationContext`.
WebAppRootListener
Listener that sets a system property to the web application root directory.
WebArgumentResolver
SPI for resolving custom arguments for a specific handler method parameter.
WebAsyncManager
The central class for managing asynchronous request processing, mainly intended as an SPI and not typically used directly by application classes.
WebAsyncTask<V>
Holder for a `Callable`, a timeout value, and a task executor.
WebAsyncUtils
Utility methods related to processing asynchronous web requests.
WebBindingInitializer
Callback interface for initializing a `WebDataBinder` for performing data binding in the context of a specific web request.
WebDataBinder
Special `DataBinder` for data binding from web request parameters to JavaBean objects.
WebDataBinderFactory
A factory for creating a `WebDataBinder` instance for a named target object.
WebExceptionHandler
Contract for handling exceptions during web server exchange processing.
WebExchangeBindException
`ServerWebInputException` subclass that indicates a data binding or validation failure.
WebExchangeDataBinder
Specialized `DataBinder` to perform data binding from URL query parameters or form data in the request data to Java objects.
WebFilter
Contract for interception-style, chained processing of Web requests that may be used to implement cross-cutting, application-agnostic requirements such as security, timeouts, and others.
WebFilterChain
Contract to allow a `WebFilter` to delegate to the next in the chain.
WebHandler
Contract to handle a web request.
WebHandlerDecorator
`WebHandler` that decorates and delegates to another `WebHandler`.
WebHttpHandlerBuilder
This builder has two purposes:
WebHttpHandlerBuilder.SpringWebBlockHoundIntegration
`BlockHoundIntegration` for spring-web classes.
WebRequest
Generic interface for a web request.
WebRequestDataBinder
Special `DataBinder` to perform data binding from web request parameters to JavaBeans, including support for multipart files.
WebRequestInterceptor
Interface for general web request interception.
WebSession
Main contract for using a server-side session that provides access to session attributes across HTTP requests.
WebSessionIdResolver
Contract for session ID resolution strategies.
WebSessionManager
Main class for access to the `WebSession` for an HTTP request.
WebSessionStore
Strategy for `WebSession` persistence.
WebUtils
Miscellaneous utilities for web applications.
XmlEventDecoder
Decodes a `DataBuffer` stream into a stream of `XMLEvents`.
XmlWebApplicationContext
`WebApplicationContext` implementation which takes its configuration from XML documents, understood by an `XmlBeanDefinitionReader`.
ZeroCopyHttpOutputMessage
Sub-interface of `ReactiveOutputMessage` that has support for "zero-copy" file transfers.