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
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
Filter
s 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
ResponseCookie
Annotation 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
Object
s (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.