All Classes and Interfaces
Class
Description
Abstract base for
ClientHttpRequest that makes sure that headers
and body are not written multiple times.Base class for
ClientHttpRequest implementations.Abstract base class for
ClientHttpRequestFactory implementations
that decorate another request factory.Deprecated.
as of 6.0, with no direct replacement; scheduled for removal in 6.2
Convenient base class for
WebApplicationInitializer implementations
that register a ContextLoaderListener in the servlet context.A base abstract class to resolve method arguments annotated with
@CookieValue.Abstract base class for most
GenericHttpMessageConverter implementations.Abstract base class for most
HttpMessageConverter implementations.Abstract base class for Jackson 2.x decoding, leveraging non-blocking parsing.
Base class providing support methods for Jackson 2.x encoding.
Abstract base class for Jackson based and content type independent
HttpMessageConverter implementations.Abstract base class for
HttpMessageConverters
that use JAXB2.Common base class for plain JSON converters, e.g.
AbstractKotlinSerializationHttpMessageConverter<T extends kotlinx.serialization.SerialFormat>
Abstract base class for
HttpMessageConverter implementations that
use Kotlin serialization.Abstract base class for
Publisher implementations that bridge between
event-listener read APIs and Reactive Streams.Abstract base class for listener-based server responses.
An alternative to
AbstractListenerWriteProcessor but instead writing
a Publisher<Publisher<T>> with flush boundaries enforces after
the completion of each nested Publisher.Abstract base class for
Processor implementations that bridge between
event-listener write APIs and Reactive Streams.Base class for
ContentNegotiationStrategy implementations with the
steps to resolve a request to media types.Abstract base implementation of the
MultipartHttpServletRequest interface.Base class for arguments that resolve to a named request value such as a
request header, path variable, cookie, and others.
Info about a request value, typically extracted from a method parameter annotation.
Abstract base class for resolving method arguments from a named value.
Represents the information about a named value, including name, whether it's required and a default value.
Base class for a
WebApplicationInitializer
that installs a Spring Reactive Web Application on a Servlet container.AbstractRefreshableApplicationContext
subclass which implements the
ConfigurableWebApplicationContext
interface for web environments.Abstract support class for RequestAttributes implementations,
offering a request completion mechanism for request-specific destruction
callbacks and for updating accessed session attributes.
Abstract
Scope implementation that reads from a particular scope
in the current thread-bound RequestAttributes object.Base class for
Filters that perform logging operations before and after a request
is processed.Common base class for
ServerHttpRequest implementations.Base class for
ServerHttpResponse implementations.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.
Abstract base class for
HttpMessageConverters
that convert from/to XML.LocaleContextResolver implementation that looks for a match between
locales in the Accept-Language header and a list of configured
supported locales.Extension of
FormHttpMessageConverter,
adding support for XML and JSON-based parts.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 is a specialization of @Scope for a
component whose lifecycle is bound to the current web application.A return value handler that supports async types.
Exception to be thrown when an async request times out.
Extends
NativeWebRequest with methods for asynchronous request processing.Extends
WebRequestInterceptor with a callback method invoked during
asynchronous request handling.Implementation of
HttpMessageConverter
that can read and write Atom feeds.ClientHttpRequestInterceptor to apply a given HTTP Basic Authentication
username/password pair, unless a custom Authorization header has
already been set.Implementation of
HttpMessageConverter that can read and write
BufferedImages.Wrapper for a
ClientHttpRequestFactory that buffers
all outgoing and incoming streams in memory.Implementation of
HttpMessageConverter that can read and write byte arrays.Custom
PropertyEditor for converting
MultipartFiles to byte arrays.A builder for creating "Cache-Control" HTTP response headers.
Intercepts concurrent request handling, where the concurrent result is
obtained by executing a
Callable on behalf of the application with
an AsyncTaskExecutor.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.Servlet Filter that allows one to specify a character encoding for requests.
Extension of
CodecConfigurer for HTTP message reader and writer
options relevant on the client side.CodecConfigurer.DefaultCodecs extension with extra client-side options.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.Documented
KeyValues for HTTP client observations.Represents a client-side HTTP request.
Represents a client-side reactive HTTP request.
Wraps another
ClientHttpRequest and delegates all methods to it.Represents the context of a client-side HTTP request execution.
Factory for
ClientHttpRequest objects.Callback interface for initializing a
ClientHttpRequest prior to it
being used.Intercepts client-side HTTP requests.
Represents a client-side HTTP response.
Represents a client-side reactive HTTP response.
Wraps another
ClientHttpResponse and delegates all methods to it.Context that holds information for metadata collection
during the
client HTTP exchanges observations.Interface for an
ObservationConvention for
client HTTP exchanges.Defines a common interface for configuring either client or server HTTP
message readers and writers.
Registry for custom HTTP message readers and writers.
Exposes the values of properties configured through
CodecConfigurer.defaultCodecs() that are applied to default codecs.Customize or replace the HTTP message readers and writers registered by
default.
Registry and container for multipart HTTP message writers.
Simple request logging filter that writes the request URI
(and optionally the query string) to the Commons Log.
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.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.Interface to be implemented by configurable web application contexts.
Convenient
WebBindingInitializer for declarative configuration
in a Spring application context.Specialization of
ConfigurableEnvironment allowing initialization of
servlet-related PropertySource objects at the
earliest moment that the ServletContext and (optionally) ServletConfig
become available.HttpServletRequest wrapper that caches all content read from
the input stream and reader,
and allows this content to be retrieved via a byte array.HttpServletResponse wrapper that caches all content written to
the output stream and writer,
and allows this content to be retrieved via a byte array.Representation of the Content-Disposition type and parameters as defined in RFC 6266.
A mutable builder for
ContentDisposition.Central class to determine requested media types
for a request.
Factory to create a
ContentNegotiationManager and configure it with
ContentNegotiationStrategy instances.A strategy for resolving the requested media types for a request.
Web application listener that cleans up remaining disposable attributes
in the ServletContext, i.e.
HttpServletRequest decorator that makes all Spring beans in a
given WebApplicationContext accessible as request attributes,
through lazy checking once an attribute gets accessed.
Performs the actual initialization work for the root application context.
Bootstrap listener to start up and shut down Spring's root
WebApplicationContext.HttpHandler delegating requests to one of several HttpHandler's
based on simple, prefix-based mappings.Specialization of
@Component for classes that declare
@ExceptionHandler, @InitBinder, or
@ModelAttribute methods to be shared across
multiple @Controller classes.Encapsulates information about an
@ControllerAdvice
Spring-managed bean without necessarily requiring it to be instantiated.Deprecated.
as of 6.0 in favor of
ResponseCookieAnnotation to indicate that a method parameter is bound to an HTTP cookie.
HttpServiceArgumentResolver for @CookieValue
annotated arguments.Cookie-based
WebSessionIdResolver.A container for CORS configuration along with methods to check against the
actual origin, HTTP methods, and headers of a given request.
Interface to be implemented by classes (usually HTTP request handlers) that
provides a
CorsConfiguration instance based on the provided request.Interface to be implemented by classes (usually HTTP request handlers) that
provides a
CorsConfiguration instance based on the provided reactive request.Filter to handle CORS pre-flight requests and intercept
CORS simple and actual requests with a CorsProcessor, and to update
the response, e.g.A strategy that takes a request and a
CorsConfiguration and updates
the response.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.Utility class for CORS request handling based on the
CORS W3C recommendation.
Utility class for CORS reactive request handling based on the
CORS W3C recommendation.
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.Annotation for permitting cross-origin requests on specific handler classes
and/or handler methods.
HttpMessageReader that wraps and delegates to a Decoder.Base class for JSF NavigationHandler implementations that want
to be capable of decorating an original NavigationHandler.
Default implementation of
ClientCodecConfigurer.Default implementation for a
ClientRequestObservationConvention,
extracting information from the ClientRequestObservationContext.The default implementation of
CorsProcessor, as defined by the
CORS W3C recommendation.The default implementation of
CorsProcessor,
as defined by the CORS W3C recommendation.Create a
WebRequestDataBinder instance and initialize it with a
WebBindingInitializer.Default implementation of the
MultipartHttpServletRequest
interface.Spring's default implementation of the
ResponseErrorHandler interface.Default implementation of
ServerCodecConfigurer.Default
ServerRequestObservationConvention.Default
ServerRequestObservationConvention.Default implementation of
ServerWebExchange.Default implementation of the
SessionAttributeStore interface,
storing the attributes in the WebRequest session (i.e.UriBuilderFactory that relies on UriComponentsBuilder for
the actual building of the URI.Enum to represent multiple URI encoding strategies.
Default implementation of
WebFilterChain.Default implementation of
WebSessionManager delegating to a
WebSessionIdResolver for session id resolution and to a
WebSessionStore.DeferredResult provides an alternative to using a Callable for
asynchronous request processing.Handles a DeferredResult value when set.
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 (e.g.Proxy for a standard Servlet Filter, delegating to a Spring-managed bean that
implements the Filter interface.
JSF NavigationHandler implementation that delegates to a NavigationHandler
bean obtained from the Spring root WebApplicationContext.
JSF PhaseListener implementation that delegates to one or more Spring-managed
PhaseListener beans coming from the Spring root WebApplicationContext.
Implementation of
ServerHttpResponse that delegates all calls to a
given target ServerHttpResponse.Shortcut for
@HttpExchange for HTTP DELETE requests.Annotation for mapping HTTP
DELETE requests onto specific handler
methods.Adapter that implements the Servlet HttpSessionBindingListener interface,
wrapping a session destruction callback.
HttpMessageWriter that wraps and delegates to an Encoder.Representation of a complete RFC 7807 error response including status,
headers, and an RFC 7807 formatted
ProblemDetail body.Builder for an
ErrorResponse.RuntimeException that implements ErrorResponse to expose
an HTTP status, response headers, and a body formatted as an RFC 7807
ProblemDetail.Resolves
Errors method arguments.Errors wrapper that adds automatic HTML escaping to the wrapped instance,
for convenient usage in HTML views.
Annotation for handling exceptions in specific handler classes and/or
handler methods.
Discovers @ExceptionHandler methods in a given class,
including all of its superclasses, and helps to resolve a given
Exception
to the exception types supported by a given Method.WebHandler decorator that invokes one or more
WebExceptionHandlers
after the delegate WebHandler.Resolves method arguments annotated with
@Value.Implementation of
ResponseErrorHandler that uses HttpMessageConverters to convert HTTP error responses to RestClientExceptions.Convenience methods to retrieve Spring's root
WebApplicationContext
for a given JSF FacesContext.RequestAttributes adapter for a JSF FacesContext.WebRequest adapter for a JSF FacesContext.Specialization of
Part that represents an uploaded file received in
a multipart request.Represents an event triggered for a file upload.
A
ContentNegotiationStrategy that returns a fixed content type.LocaleContextResolver implementation that always returns a fixed locale
and optionally time zone.Filter that parses form data for HTTP PUT, PATCH, and DELETE requests
and exposes it as Servlet request parameters.Specialization of
Part for a form field.Implementation of
HttpMessageConverter to read and write 'normal' HTML
forms and also to write (but not read) multipart data (e.g.Implementation of an
HttpMessageReader to read HTML form data, i.e.HttpMessageWriter for writing a MultiValueMap<String, String>
as HTML form data, i.e.Represents an event triggered for a form field.
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).Extract values from "Forwarded" and "X-Forwarded-*" headers to override
the request URI (i.e.
Simple base implementation of
Filter which treats
its config parameters (init-param entries within the
filter tag in web.xml) as bean properties.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.Subclass of
GenericApplicationContext, suitable for web environments.Shortcut for
@HttpExchange for HTTP GET requests.Annotation for mapping HTTP
GET requests onto specific handler
methods.WebApplicationContext implementation which takes
its configuration from Groovy bean definition scripts and/or XML files, as understood by
a GroovyBeanDefinitionReader.A simple utility class for obtaining a Google Gson 2.x
GsonBuilder
which Base64-encodes byte[] properties when reading and writing JSON.A
FactoryBean for creating a Google Gson 2.x Gson instance.Implementation of
HttpMessageConverter
that can read and write JSON using the
Google Gson library.Strategy interface for resolving method parameters into argument values in
the context of a given request.
Resolves method parameters by delegating to a list of registered
HandlerMethodArgumentResolvers.Strategy interface to handle the value returned from the invocation of a
handler method.
Handles method return values by delegating to a list of registered
HandlerMethodReturnValueHandlers.A
Predicate to match request handling component types if
any of the following selectors match:
Base packages -- for selecting handlers by their package.A
HandlerTypePredicate builder.A
ContentNegotiationStrategy that checks the 'Accept' request header.Request and response header-based
WebSessionIdResolver.Filter that converts posted method parameters into HTTP methods,
retrievable via HttpServletRequest.getMethod().Reactive
WebFilter that converts posted method parameters into HTTP methods,
retrievable via HttpRequest.getMethod().Utility class for HTML escaping.
Base class for
RestTemplate
and other HTTP accessing gateway helpers, defining common properties
such as the ClientHttpRequestFactory to operate on.Contract to abstract the underlying HTTP client and decouple it from the
HTTP service proxy.
Exception thrown when an HTTP 4xx is received.
HttpClientErrorException for status HTTP 400 Bad Request.HttpClientErrorException for status HTTP 409 Conflict.HttpClientErrorException for status HTTP 403 Forbidden.HttpClientErrorException for status HTTP 410 Gone.HttpClientErrorException for status HTTP 405 Method Not Allowed.HttpClientErrorException for status HTTP 406 Not Acceptable.HttpClientErrorException for status HTTP 404 Not Found.HttpClientErrorException for status HTTP 429 Too Many Requests.HttpClientErrorException for status HTTP 401 Unauthorized.HttpClientErrorException for status HTTP 422 Unprocessable Entity.HttpClientErrorException for status HTTP 415 Unsupported Media Type.ClientHttpConnector implementation for the Apache HttpComponents HttpClient 5.x.ClientHttpRequestFactory implementation that
uses Apache HttpComponents
HttpClient to create requests.Represents an HTTP cookie as a name-value pair consistent with the content of
the "Cookie" request header.
Represents an HTTP request or response entity, consisting of headers and body.
Annotation to declare a method on an HTTP service interface as an HTTP
endpoint.
Lowest level contract for reactive HTTP request handling that serves as a
common denominator across different runtimes.
Contract for applying a decorator to an
HttpHandler.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.
ServerHttpResponse decorator for HTTP HEAD requests.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.
Abstract base for exceptions related to media types.
Exception thrown when the request handler cannot generate a response that is
acceptable by the client.
Exception thrown when a client POSTs, PUTs, or PATCHes content of a type
not supported by request handler.
Represents the base interface for HTTP request and response messages.
Thrown by
HttpMessageConverter implementations when a conversion attempt fails.Strategy interface for converting from and to HTTP requests and responses.
Response extractor that uses the given entity converters
to convert the response into a type
T.Extension of
Decoder exposing extra methods relevant in the context
of HTTP request or response body decoding.Extension of
Encoder exposing extra methods relevant in the context
of HTTP request or response body encoding.Thrown by
HttpMessageConverter implementations when the
HttpMessageConverter.read(java.lang.Class<? extends T>, org.springframework.http.HttpInputMessage) method fails.Thrown by
HttpMessageConverter implementations when the
HttpMessageConverter.write(T, org.springframework.http.MediaType, org.springframework.http.HttpOutputMessage) method fails.Strategy for reading from a
ReactiveHttpInputMessage and decoding
the stream of bytes to Objects of type <T>.Strategy for encoding a stream of objects of type
<T> and writing
the encoded stream of bytes to an ReactiveHttpOutputMessage.Represents an HTTP request method.
HttpServiceArgumentResolver that resolves the target
request's HTTP method from an HttpMethod argument.Represents an HTTP (byte) range for use with the HTTP
"Range" header.Plain handler interface for components that process HTTP requests,
analogous to a Servlet.
Simple HttpServlet that delegates to an
HttpRequestHandler bean defined
in Spring's root web application context.Exception thrown when a request handler does not support a
specific request method.
Container for HTTP request values extracted from an
@HttpExchange-annotated
method and argument values passed to it.Builder for
HttpRequestValues.Provides a convenient implementation of the
HttpRequest interface
that can be overridden to adapt the request.Exception thrown when an HTTP 5xx is received.
HttpServerErrorException for HTTP status 502 Bad Gateway.HttpServerErrorException for status HTTP 504 Gateway Timeout.HttpServerErrorException for status HTTP 500 Internal Server Error.HttpServerErrorException for status HTTP 501 Not Implemented.HttpServerErrorException for status HTTP 503 Service Unavailable.Resolve an argument from an
@HttpExchange-annotated method
to one or more HTTP request values.Factory to create a client proxy from an HTTP service interface with
@HttpExchange methods.Builder to create an
HttpServiceProxyFactory.Servlet HttpSessionListener that automatically exposes the session mutex
when an HttpSession gets created.
Exception thrown when an HTTP request handler requires a pre-existing session.
Enumeration of HTTP status codes.
Enumeration of HTTP status series.
Represents an HTTP response status code.
Abstract base class for exceptions based on an
HttpStatusCode.Default adapter of
WebHandler to the HttpHandler contract.Annotation that identifies methods that initialize the
WebDataBinder which
will be used for populating command and form object arguments
of annotated handler methods.Adds initialization to a WebDataBinder via
@InitBinder methods.Simple Map-based storage for
WebSession instances.ClientHttpRequestFactory wrapper with support for
ClientHttpRequestInterceptors.Base class for
RestTemplate
and other HTTP accessing gateway helpers, adding interceptor-related
properties to HttpAccessor's common properties.Listener that flushes the JDK's
JavaBeans Introspector
cache on web app shutdown.Exception thrown from
MediaType.parseMediaType(String) in case of
encountering an invalid media type specification String.Extension of
HandlerMethod that invokes the underlying method with
argument values resolved from the current HTTP request through a list of
HandlerMethodArgumentResolver.Decode bytes into CBOR and convert to Object's with Jackson.
Encode from an
Object to bytes of CBOR objects using Jackson.Base class providing support methods for Jackson 2.x encoding and decoding.
Decode a byte stream into JSON and convert to Object's with Jackson 2.x,
leveraging non-blocking parsing.
Encode from an
Object stream to a byte stream of JSON objects using Jackson 2.x.A builder used to create
ObjectMapper instances with a fluent API.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.Decode a byte stream into Smile and convert to Object's with Jackson 2.x,
leveraging non-blocking parsing.
Encode from an
Object stream to a byte stream of Smile objects using Jackson 2.x.Utility class for JavaScript escaping.
An
HttpMessageConverter that can read XML collections using JAXB2.Implementation of
HttpMessageConverter that can read and write XML using JAXB2.Decode from a bytes stream containing XML elements to a stream of
Objects (POJOs).Encode from single value to a byte stream containing XML elements.
ClientHttpConnector for the Java HttpClient.Factory to manage JDK HttpClient resources such as a shared
Executor
within the lifecycle of a Spring ApplicationContext.ClientHttpConnector for the Jetty Reactive Streams HttpClient.ServletHttpHandlerAdapter extension that uses Jetty APIs for writing
to the response with ByteBuffer.Factory to manage Jetty resources, i.e.
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.Decode a byte stream into CBOR and convert to Objects with
kotlinx.serialization.
Encode from an
Object stream to a byte stream of CBOR objects using
kotlinx.serialization.Implementation of
HttpMessageConverter
that can read and write CBOR using
kotlinx.serialization.Decode a byte stream into JSON and convert to Object's with
kotlinx.serialization.
Encode from an
Object stream to a byte stream of JSON objects using
kotlinx.serialization.Implementation of
HttpMessageConverter
that can read and write JSON using
kotlinx.serialization.Decode a byte stream into a protocol Buffer and convert to Objects with
kotlinx.serialization.
Decode a byte stream into a Protocol Buffer and convert to Objects with
kotlinx.serialization.
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.
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.
Base class for
Encoder,
Decoder, HttpMessageReader, or
HttpMessageWriter that uses a logger and shows potentially sensitive
request data.Meta annotation that indicates a web mapping annotation.
Implementation of
HttpMessageConverter that can read and write the CBOR
data format using
the dedicated Jackson 2.x extension.Implementation of
HttpMessageConverter that can read and
write JSON using Jackson 2.x's ObjectMapper.Implementation of
HttpMessageConverter
that can read and write Smile data format ("binary JSON") using
the dedicated Jackson 2.x extension.Implementation of
HttpMessageConverter
that can read and write XML using
Jackson 2.x extension component for reading and writing XML encoded data.HttpInputMessage that can eventually stores a Jackson view that will be used
to deserialize the message.A simple holder for the POJO to serialize via
MappingJackson2HttpMessageConverter along with further
serialization instructions to be passed in to the converter.An implementation of
MediaTypeFileExtensionResolver that maintains
lookups between file extensions and MediaTypes in both directions.Implementation of
HttpMessageConverter
that can read and write XML using Spring's Marshaller and Unmarshaller abstractions.Annotation which indicates that a method parameter should be bound to a
name-value pair within a path segment.
MultipartException subclass thrown when an upload exceeds the
maximum upload size allowed.
A subclass of
MimeType that adds support for quality parameters
as defined in the HTTP specification.A factory delegate for resolving
MediaType objects
from Resource handles or filenames.Strategy to resolve a
MediaType to a list of file extensions —
for example, to resolve "application/json" to "json".A ConversionNotSupportedException raised while resolving a method argument.
Exception to be thrown when validation on an argument annotated with
@Valid fails.A TypeMismatchException raised while resolving a controller method argument.
Exception for errors that fit response status 405 (method not allowed).
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.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.ServletRequestBindingException subclass that indicates
that a request cookie expected in the method parameters of an
@RequestMapping method is not present.ServletRequestBindingException subclass that indicates
that a request header expected in the method parameters of an
@RequestMapping method is not present.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.ServerWebInputException subclass that indicates a missing request
value such as a request header, cookie value, query parameter, etc.ServletRequestBindingException subclass that indicates a missing parameter.Signals the part of a "multipart/form-data" request, identified by name
could not be found.
Records model and view related decisions made by
HandlerMethodArgumentResolvers and
HandlerMethodReturnValueHandlers during the course of invocation of
a controller method.Annotation that binds a method parameter or method return value
to a named model attribute, exposed to a web view.
Resolve
@ModelAttribute annotated method arguments and handle
return values from @ModelAttribute annotated methods.Assist with initialization of the
Model before controller method
invocation and with updates to it after the invocation.Resolves
Model arguments and handles Model return values.Prepare the body of a multipart request, resulting in a
MultiValueMap<String, HttpEntity>.Builder that allows for further customization of part headers.
Exception thrown when multipart resolution fails.
A representation of an uploaded file received in a multipart request.
Servlet Filter that resolves multipart requests via a
MultipartResolver.HttpMessageReader for reading "multipart/form-data" requests
into a MultiValueMap<String, Part>.HttpMessageWriter for writing a MultiValueMap<String, ?>
as multipart form data, i.e.Provides additional methods for dealing with multipart content within a
servlet request, allowing to access uploaded files.
This interface defines the multipart request access operations that are exposed
for actual multipart requests.
A common delegate for
HandlerMethodArgumentResolver implementations
which need to resolve MultipartFile and Part arguments.A strategy interface for multipart file upload resolution in accordance
with RFC 1867.
Support class for multipart HTTP message writers.
Extension of the
WebRequest interface, exposing the
native request and response objects in a generic fashion.Deprecated.
as of 6.0, in favor of standard
ServletException nestingException for errors that fit response status 406 (not acceptable).
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.ClientHttpRequestFactory implementation that uses
OkHttp 3.x to create requests.Filter base class that aims to guarantee a single execution per request
dispatch, on any servlet container.
Strategy that resolves the requested content type from a query parameter.
Representation for a part in a "multipart/form-data" request.
Represents an event for a "multipart/form-data" request.
HttpMessageWriter for writing PartEvent objects.HttpMessageWriter for writing with Part.Shortcut for
@HttpExchange for HTTP PATCH requests.Annotation for mapping HTTP
PATCH requests onto specific handler
methods.Structured representation of a URI path parsed via
PathContainer.parsePath(String)
into a sequence of PathContainer.Separator and PathContainer.PathSegment elements.A path element, either separator or path segment.
Options to customize parsing based on the type of input path.
Path segment element.
Path separator element.
Deprecated.
as of 5.2.4.
Representation of a parsed path pattern.
Holder for URI variables and path parameters (matrix variables) extracted
based on the pattern for a given matched path.
Holder for the result of a match on the start of a pattern.
Parser for URI path patterns producing
PathPattern instances that can
then be matched to requests.RouteMatcher built on PathPatternParser that uses
PathContainer and PathPattern as parsed representations of
routes and patterns.Annotation which indicates that a method parameter should be bound to a URI template
variable.
HttpServiceArgumentResolver for @PathVariable
annotated arguments.Exception that is thrown when there is a problem with the pattern being parsed.
The messages that can be included in a
PatternParseException when there is a parse failure.Shortcut for
@HttpExchange for HTTP POST requests.Annotation for mapping HTTP
POST requests onto specific handler
methods.Handler for CORS pre-flight requests.
WebFilter that handles pre-flight requests through a
PreFlightRequestHandler and bypasses the rest of the chain.Representation for an RFC 7807 problem detail.
An interface to associate Jackson annotations with
ProblemDetail to avoid a hard dependency on
the Jackson library.Provides the same declarations as
ProblemDetailJacksonMixin and some
additional ones to support XML serialization when jackson-dataformat-xml
is on the classpath.Base class providing support methods for Protobuf encoding and decoding.
An
HttpMessageConverter that reads and writes
com.google.protobuf.Messages using
Google Protocol Buffers.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.Subclass of
ProtobufHttpMessageConverter which enforces the use of Protobuf 3 and
its official library "com.google.protobuf:protobuf-java-util" for JSON processing.FactoryBean that creates a java.net.Proxy.Shortcut for
@HttpExchange for HTTP PUT requests.Annotation for mapping HTTP
PUT requests onto specific handler
methods.A "reactive" HTTP input message that exposes the input as
Publisher.A "reactive" HTTP output message that accepts output as a
Publisher.Reactor-Netty implementation of
ClientHttpConnector.Adapt
HttpHandler to the Reactor Netty channel handling function.Reactor Netty 2 (Netty 5) implementation of
ClientHttpConnector.Adapt
HttpHandler to the Reactor Netty 5 channel handling function.Factory to manage Reactor Netty resources, i.e.
Factory to manage Reactor Netty resources, i.e.
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.Annotation to bind a method parameter to a request attribute.
HttpServiceArgumentResolver for @RequestAttribute
annotated arguments.Abstraction for accessing attribute objects associated with a request.
Annotation indicating a method parameter should be bound to the body of the web request.
HttpServiceArgumentResolver for @RequestBody
annotated arguments.Callback interface for code that operates on a
ClientHttpRequest.Servlet Filter that exposes the request to the current thread,
through both
LocaleContextHolder and
RequestContextHolder.Holder class to expose the web request in the form of a thread-bound
RequestAttributes object.Servlet listener that exposes the request to the current thread,
through both
LocaleContextHolder and
RequestContextHolder.Extension of
HttpEntity that also exposes the HTTP method and the
target URL.Defines a builder that adds a body to the response entity.
Defines a builder that adds headers to the request entity.
RequestEntity initialized with a URI template and variables instead of a
URI.Event raised when a request is handled within an ApplicationContext.
Annotation which indicates that a method parameter should be bound to a web request header.
HttpServiceArgumentResolver for @RequestHeader
annotated arguments.Resolves
Map method arguments annotated with @RequestHeader.Resolves method arguments annotated with
@RequestHeader except for
Map arguments.Annotation for mapping web requests onto methods in request-handling classes
with flexible method signatures.
Enumeration of HTTP request methods.
Annotation which indicates that a method parameter should be bound to a web
request parameter.
HttpServiceArgumentResolver for @RequestParam
annotated arguments.Resolves
Map method arguments annotated with an @RequestParam
where the annotation does not specify a request parameter name.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.Annotation that can be used to associate the part of a "multipart/form-data" request
with a method argument.
HttpServiceArgumentResolver for @RequestPart
annotated arguments.ServerHttpRequest implementation that accesses one part of a multipart
request.Specialization of
PathContainer that subdivides the path into a
RequestPath.contextPath() and the remaining RequestPath.pathWithinApplication().@RequestScope is a specialization of @Scope for a
component whose lifecycle is bound to the current web request.Request-backed
Scope
implementation.Exception thrown when an I/O error occurs.
Implementation of
HttpMessageConverter that can read/write Resources
and supports byte range requests.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.HttpMessageWriter that can write a Resource.Implementation of
HttpMessageConverter that can write a single
ResourceRegion or Collections of ResourceRegions.Annotation that indicates a method return value should be bound to the web
response body.
An
HttpCookie subclass with the additional attributes allowed in
the "Set-Cookie" response header.A builder for a server-defined HttpCookie with attributes.
Extension of
HttpEntity that adds an HttpStatusCode status code.Defines a builder that adds a body to the response entity.
Defines a builder that adds headers to the response entity.
Strategy interface used by the
RestTemplate to determine
whether a particular response has an error or not.Generic callback interface used by
RestTemplate's retrieval methods.Marks a method or exception class with the status
ResponseStatus.code() and
ResponseStatus.reason() that should be returned.Subclass of
ErrorResponseException that accepts a "reason", and by
default maps that to the "detail"
of the ProblemDetail.Handle
ResponseStatusException by setting the response status.Base class for exceptions thrown by
RestTemplate in case a request
fails because of a server error response, as determined via
ResponseErrorHandler.hasError(ClientHttpResponse), failure to decode
the response, or a low level I/O error.Common base class for exceptions that contain actual HTTP response data.
A convenience annotation that is itself annotated with
@Controller and @ResponseBody.A convenience annotation that is itself annotated with
@ControllerAdvice
and @ResponseBody.Convenient superclass for application classes that need REST access.
Interface specifying a basic set of RESTful operations.
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.Implementation of
HttpMessageConverter
that can read and write RSS feeds.Extension of
CodecConfigurer for HTTP message reader and writer
options relevant on the server side.CodecConfigurer.DefaultCodecs extension with extra server-side options.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.A control that can put the processing of an HTTP request in asynchronous mode during
which the response remains open until explicitly closed.
Documented
KeyValues for the HTTP server observations
for Servlet-based web applications.Documented
KeyValues for the HTTP server observations
for reactive web applications.WebFilter that creates observations
for HTTP exchanges.Filter that creates observations
for HTTP exchanges.Represents a reactive server-side HTTP request.
Represents a server-side HTTP request.
Builder for mutating an existing
ServerHttpRequest.Wraps another
ServerHttpRequest and delegates all methods to it.Represents a reactive server-side HTTP response.
Represents a server-side HTTP response.
Wraps another
ServerHttpResponse and delegates all methods to it.Context that holds information for metadata collection regarding
Servlet HTTP requests observations.Context that holds information for metadata collection regarding
reactive HTTP requests
observations.Interface for an
ObservationConvention for Servlet HTTP requests.Interface for an
ObservationConvention for reactive HTTP requests.Representation for a Server-Sent Event for use with Spring's reactive Web support.
A mutable builder for a
SseEvent.Reader that supports a stream of
ServerSentEvents and also plain
Objects which is the same as an ServerSentEvent with data only.HttpMessageWriter for "text/event-stream" responses.Contract for an HTTP request-response interaction.
Builder for mutating an existing
ServerWebExchange.Inserts an attribute in the Reactor
Context that makes the current
ServerWebExchange available under the attribute name
ServerWebExchangeContextFilter.EXCHANGE_CONTEXT_ATTRIBUTE.A convenient base class for classes that need to wrap another
ServerWebExchange.Exception for errors that fit response status 400 (bad request) for use in
Spring Web applications.
Interface to be implemented by any object that wishes to be notified of the
ServletConfig (typically determined by the WebApplicationContext)
that it runs in.PropertySource that reads init parameters from a ServletConfig object.Exporter that takes Spring-defined objects and exposes them as
ServletContext attributes.
FactoryBean that fetches a specific, existing ServletContext attribute.Interface to be implemented by any object that wishes to be notified of the
ServletContext (typically determined by the WebApplicationContext)
that it runs in.BeanPostProcessor
implementation that passes the ServletContext to beans that implement
the ServletContextAware interface.FactoryBean that retrieves a specific ServletContext init parameter
(that is, a "context-param" defined in web.xml).PropertySource that reads init parameters from a ServletContext object.Helper class for resolving placeholders in texts.
Simple request logging filter that writes the request URI
(and optionally the query string) to the ServletContext log.
Resource implementation for
ServletContext resources, interpreting
relative paths within the web application root directory.ResourceLoader implementation that resolves paths as ServletContext
resources, for use outside a WebApplicationContext (for example,
in an HttpServletBean or GenericFilterBean subclass).
ServletContext-aware subclass of
PathMatchingResourcePatternResolver,
able to find matching resources below the web application root directory
via ServletContext.getResourcePaths(java.lang.String).Scope wrapper for a ServletContext, i.e.Adapt
HttpHandler to an HttpServlet using Servlet Async support
and Servlet non-blocking I/O.Deprecated.
as of 5.2.4.
Servlet-based implementation of the
RequestAttributes interface.Fatal binding exception, thrown when we want to
treat binding exceptions as unrecoverable.
Special
DataBinder to perform data binding
from servlet request parameters to JavaBeans, including support for multipart files.Servlet-specific subclass of RequestHandledEvent,
adding servlet-specific context information.
PropertyValues implementation created from parameters in a ServletRequest.
Filter that parses and
caches a RequestPath that can then
be accessed via ServletRequestPathUtils.getParsedRequestPath(jakarta.servlet.ServletRequest).Utility class to assist with preparation and access to the lookup path for
request mapping purposes.
Parameter extraction methods, for an approach distinct from data binding,
in which parameters of specific types are required.
A
ServerHttpAsyncRequestControl to use on Servlet containers.ServerHttpRequest implementation that is based on a HttpServletRequest.ServerHttpResponse implementation that is based on a HttpServletResponse.WebRequest adapter for an HttpServletRequest.Annotation to bind a method parameter to a session attribute.
Annotation that indicates the session attributes that a specific handler uses.
Manages controller-specific session attributes declared via
@SessionAttributes.Strategy interface for storing model attributes in a backend session.
@SessionScope is a specialization of @Scope for a
component whose lifecycle is bound to the current web session.Session-backed
Scope
implementation.Simple interface that can be injected into handler methods, allowing them to
signal that their session processing is complete.
Resolves a
SessionStatus argument by obtaining it from
the ModelAndViewContainer.Filter that generates an ETag value based on the
content on the response.ClientHttpRequestFactory implementation that uses standard JDK facilities.Simple implementation of the
SessionStatus interface,
keeping the complete flag as an instance variable.Implementation of
HttpMessageConverter
that can read and write Source objects.Convenient base class for self-autowiring classes that gets constructed
within a Spring-based web application.
JSF
ELResolver that delegates to the Spring root WebApplicationContext,
resolving name references to Spring-defined beans.Allows for creating Jackson (
JsonSerializer, JsonDeserializer,
KeyDeserializer, TypeResolverBuilder, TypeIdResolver)
beans with autowiring against a Spring ApplicationContext.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.JSR-303
ConstraintValidatorFactory implementation that delegates to
the current Spring WebApplicationContext for creating autowired
ConstraintValidator instances.A holder for SSL session information.
Spring MultipartHttpServletRequest adapter, wrapping a Servlet HttpServletRequest
and its Part objects.
A Servlet implementation of
AsyncWebRequest.Environment implementation to be used by Servlet-based web
applications.Standard implementation of the
MultipartResolver interface,
based on the Servlet Part API.Utility methods for standard Servlet
Part handling.Static
WebApplicationContext
implementation for testing.Represents an HTTP output message that allows for setting a streaming body.
Defines the contract for bodies that can be written directly to an
OutputStream.Implementation of
HttpMessageConverter that can read and write strings.Custom
PropertyEditor for converting
MultipartFiles to Strings.Utility class for tag library related code, exposing functionality
such as translating
Strings to web scopes.Sends a 503 (SERVICE_UNAVAILABLE) in case of a timeout if the response is not
already committed.
Sends a 503 (SERVICE_UNAVAILABLE) in case of a timeout if the response is not
already committed.
ServletHttpHandlerAdapter extension that uses Tomcat APIs for reading
from the request and writing to the response with ByteBuffer.Adapt
HttpHandler to the Undertow HttpHandler.Raised when no suitable
HttpMessageConverter could be
found to extract the response.Exception thrown when an unknown (or custom) HTTP status code is received.
ServerWebInputException subclass that indicates an unsatisfied
parameter condition, as typically expressed using an @RequestMapping
annotation at the @Controller type level.ServletRequestBindingException subclass that indicates an unsatisfied
parameter condition, as typically expressed using an @RequestMapping
annotation at the @Controller type level.Exception for errors that fit response status 415 (unsupported media type).
Builder-style methods to prepare and expand a URI template with variables.
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.Represents an immutable collection of URI components, mapping component type to
String values.
Defines the contract for URI Template variables.
Builder for
UriComponents.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.Representation of a URI template that can be expanded with URI variables via
UriTemplate.expand(Map), UriTemplate.expand(Object[]), or matched to a URL via
UriTemplate.match(String).Defines methods for expanding a URI template with variables.
Utility methods for URI encoding and decoding based on RFC 3986.
HttpServiceArgumentResolver that resolves the URL for the request
from a URI argument.CorsConfigurationSource that uses URL patterns to select the
CorsConfiguration for a request.CorsConfigurationSource that uses URL path patterns to select the
CorsConfiguration for a request.Helper class for URL path matching.
Common value constants shared between bind annotations.
Interface to provide configuration for a web application.
Special JSF
ELResolver that exposes the Spring WebApplicationContext
instance under a variable named "webApplicationContext".Convenience methods for retrieving the root
WebApplicationContext for
a given ServletContext.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.Convenient superclass for application objects running in a
WebApplicationContext.Listener that sets a system property to the web application root directory.
SPI for resolving custom arguments for a specific handler method parameter.
The central class for managing asynchronous request processing, mainly intended
as an SPI and not typically used directly by application classes.
Holder for a
Callable, a timeout value, and a task executor.Utility methods related to processing asynchronous web requests.
Callback interface for initializing a
WebDataBinder for performing
data binding in the context of a specific web request.Special
DataBinder for data binding from web request parameters
to JavaBean objects.A factory for creating a
WebDataBinder instance for a named target object.Contract for handling exceptions during web server exchange processing.
ServerWebInputException subclass that indicates a data binding or
validation failure.Specialized
DataBinder to perform data
binding from URL query parameters or form data in the request data to Java objects.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.
Contract to allow a
WebFilter to delegate to the next in the chain.Contract to handle a web request.
WebHandler that decorates and delegates to another WebHandler.This builder has two purposes:
BlockHoundIntegration for spring-web classes.Generic interface for a web request.
Special
DataBinder to perform data binding
from web request parameters to JavaBeans, including support for multipart files.Interface for general web request interception.
Main contract for using a server-side session that provides access to session
attributes across HTTP requests.
Contract for session ID resolution strategies.
Main class for access to the
WebSession for an HTTP request.Strategy for
WebSession persistence.Miscellaneous utilities for web applications.
Decodes a
DataBuffer stream into a stream of XMLEvents.WebApplicationContext implementation
which takes its configuration from XML documents, understood by an
XmlBeanDefinitionReader.Sub-interface of
ReactiveOutputMessage that has support for "zero-copy"
file transfers.