All Classes and Interfaces
类
说明
Abstract base class for
HandlerExceptionHandler
implementations that support handling exceptions from handlers of type
ActionMappingAnnotationHandler.Abstract superclass for Atom Feed views, using the
ROME package.
Base implementation of
ClientHttpRequest that buffers output
in a byte array before sending it over the wire.Convenient base class for
ViewResolver
implementations.Filter that determines if view should be cached.
Abstract base for
ClientHttpRequest that makes sure that headers
and body are not written multiple times.Base class for
ClientHttpRequest implementations.COMMITTING -> COMMITTED is the period after doCommit is called but before
the response status and headers have been applied to the underlying
response during which time pre-commit actions can still make changes to
the response status and headers.
Convenient superclass for controller implementations, using the Template Method
design pattern.
Abstract implementation of the
HandlerMapping interface,
detecting URL mappings for handler beans through introspection of all
defined beans in the application context.AbstractFeedView<T extends com.rometools.rome.feed.WireFeed>
Abstract base class for Atom and RSS Feed views, using the
ROME package.
Abstract base class for most
GenericHttpMessageConverter implementations.Abstract base class for
HandlerExceptionHandler implementations.Abstract base class for
HandlerMapping
implementations.Abstract base class for
HandlerAdapter implementations that support
handlers of type HandlerMethod.Abstract base class for
HandlerMapping implementations that define
a mapping between a request and a HandlerMethod.A thin wrapper around a matched HandlerMethod and its mapping, for the purpose of
comparing the best match with a comparator in the context of the current request.
Abstract base class for most
HttpMessageConverter implementations.Abstract base class for Jackson 2.9 decoding, leveraging non-blocking parsing.
Base class providing support methods for Jackson 2.9 encoding.
Abstract base class for Jackson based and content type independent
HttpMessageConverter implementations.Abstract base class for Jackson based and content type independent
AbstractView implementations.Abstract base class for
HttpMessageConverters
that use JAXB2.Common base class for plain JSON converters, e.g.
Abstract base class for
Publisher implementations that bridge between
event-listener read APIs and Reactive Streams.Represents a state for the
Publisher to be in.Abstract base class for listener-based server responses, e.g.
An alternative to
AbstractListenerWriteProcessor but instead writing
a Publisher<Publisher<T>> with flush boundaries enforces after
the completion of each nested Publisher.Represents a state for the
Processor to be in.Subscriber to receive and delegate completion notifications for from
the current Publisher, i.e. for the current flush boundary.
Abstract base class for
Processor implementations that bridge between
event-listener write APIs and Reactive Streams.Represents a state for the
Processor to be in.Abstract base class for
LocaleContextResolver implementations.Abstract base class for
LocaleResolver implementations.Base class for
ContentNegotiationStrategy implementations with the
steps to resolve a request to media types.A convenient base class for
ResponseBodyAdvice implementations
that customize the response before JSON serialization with
AbstractJackson2HttpMessageConverter's concrete subclasses.A base class for resolving method argument values by reading from the body of
a request with
HttpMessageConverters.Extends
AbstractMessageConverterMethodArgumentResolver with the ability to handle method
return values by writing to the response with HttpMessageConverters.Abstract base implementation of the
MultipartRequest 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.
Supports "name=value" style expressions as described in:
RequestMapping.params() and
RequestMapping.headers().Abstract superclass for PDF views that operate on an existing
document with an AcroForm.
Abstract superclass for PDF views.
Convenient base class for a
ReactorHttpExchangeAdapter implementation
adapting to the synchronous HttpExchangeAdapter contract.A base class for
RedirectModelManager implementations.AbstractRefreshableApplicationContext
subclass which implements the
ConfigurableWebApplicationContext
interface for web environments.A base class for
RequestCondition types providing implementations of
AbstractRequestCondition.equals(Object), AbstractRequestCondition.hashCode(), and AbstractRequestCondition.toString().Abstract
Scope implementation that reads from a particular scope
in the current thread-bound AttributeAccessor object.Base class for
ResourceResolver
implementations.Abstract superclass for RSS Feed views, using the
ROME package.
Common base class for
ServerHttpRequest implementations.Base class for
ServerHttpResponse implementations.COMMITTING -> COMMITTED is the period after doCommit is called but before
the response status and headers have been applied to the underlying
response during which time pre-commit actions can still make changes to
the response status and headers.
Abstract base class for
ServerResponse implementations.Abstract base for
ClientHttpRequest that also implement
StreamingHttpOutputMessage.Adapter base class for template-based view technologies such as FreeMarker,
with the ability to use request and session attributes in their model and
the option to expose helper objects for Framework's FreeMarker macro library.
Abstract base class for template view resolvers, in particular for FreeMarker views.
Abstract base class for
UriTemplateHandler implementations.Abstract base class for URL-based views.
Abstract base class for URL-mapped
HandlerMapping implementations.Abstract base class for
Controllers that return a view name
based on the request URL.Abstract base class for
VersionStrategy implementations.File name-based
VersionPathStrategy,
e.g.A prefix-based
VersionPathStrategy,
e.g.Abstract base class for
View
implementations.Session events supported WebSession
AbstractWireFeedHttpMessageConverter<T extends com.rometools.rome.feed.WireFeed>
Abstract base class for Atom and RSS Feed message converters, using the
ROME tools project.
Convenient superclass for Excel document views in traditional XLS format.
Convenient superclass for Excel document views in the Office 2007 XLSX format,
using POI's streaming variant.
Convenient superclass for Excel document views in the Office 2007 XLSX format
(as supported by POI-OOXML).
Abstract base class for
HttpMessageConverters
that convert from/to XML.LocaleResolver implementation that looks for a match between locales
in the Accept-Language header and a list of configured supported
locales.HTTP Request Annotation Handler
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.OncePerRequestFilter to add an X-Application-Context header that
contains the ApplicationContext ID.Exception to be thrown when an async request times out.
Asynchronous subtype of
ServerResponse that exposes the future
response.Helps with configuring options for asynchronous request processing.
for WebAsyncTask
Extends
RequestContext with methods for asynchronous request processing.Implementation of
HttpMessageConverter
that can read and write Atom feeds.Causes an object to be notified when it is bound to or unbound from a session.
Default implementation of
CodecConfigurer that serves as a base for
client and server specific variants.Default implementation of
CustomCodecs.Default implementation of
CodecConfigurer.DefaultCodecs that serves
as a base for client and server specific variants.Basic authentication details to be applied to
HttpHeaders.ClientHttpRequestInterceptor to apply a given HTTP Basic Authentication
username/password pair, unless a custom Authorization header has
already been set.Allows for creating Jackson (
JsonSerializer, JsonDeserializer,
KeyDeserializer, TypeResolverBuilder, TypeIdResolver)
beans with autowiring against a ApplicationContext.Implementation of the
HandlerMapping interface that maps from URLs
to beans with names that start with a slash ("/"), similar to how Struts
maps URLs to action names.A simple implementation of
ViewResolver
that interprets a view name as a bean name in the current application context,
i.e. typically in the XML file of the executing DispatcherServlet
or in a corresponding configuration class.Subclass of
ModelMap that automatically removes a BindingResult
object if the corresponding target attribute gets replaced through regular
Map operations.Context to assist with binding request data onto Objects and provide access
to a shared
Model with controller-specific attributes.Annotation to bind values from a web request such as request parameters or
path variables to fields of a Java object.
DataBinder.NameResolver that determines
the bind value name from a @BindParam method parameter
annotation.A function that can extract data from a
ReactiveHttpInputMessage body.Defines the context used during the extraction.
Static factory methods for
BodyExtractor implementations.A combination of functions that can populate a
ReactiveHttpOutputMessage body.Defines the context used during the insertion.
Static factory methods for
BodyInserter implementations.Extension of
BodyInserter that allows for adding form data or
multipart form data.Extension of
BodyInserters.FormInserter that allows for adding asynchronous parts.Implementation of
HttpMessageConverter that can read and write
BufferedImages.Wrapper for a
ClientHttpRequestFactory that buffers
all outgoing and incoming streams in memory.Simple implementation of
ClientHttpRequest that wraps another request.Simple implementation of
ClientHttpResponse that reads the response's body
into memory, thus allowing for multiple invocations of BufferingClientHttpResponseWrapper.getBody().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.
A
ResourceResolver that
resolves resources from a Cache or otherwise
delegates to the resolver chain and saves the result in the cache.A
ResourceTransformer that checks a
Cache to see if a previously transformed resource
exists in the cache and returns it if found, and otherwise delegates to the resolver
chain and saves the result in the cache.Assists with the invocation of
CallableProcessingInterceptor's.Handles return values of type
Callable.Intercepts concurrent request handling, where the concurrent result is
obtained by executing a
Callable on behalf of the application with
an AsyncTaskExecutor.A path element representing capturing the rest of a path.
A path element representing capturing a piece of the path as a variable.
Implementation of
RouterFunctions.Visitor that changes the
PathPatternParser on path-related request predicates
(i.e.Interface implemented by predicates that can change the parser.
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.Default implementation of
ClientCodecConfigurer.ClientDefaultCodecs.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.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.
Utility class that can be used to create
ClientHttpRequestFactory instances
configured using given ClientHttpRequestFactorySettings.Support for
HttpComponentsClientHttpRequestFactory.Support for
JdkClientHttpRequestFactory.Support for
JettyClientHttpRequestFactory.Support for reflective configuration of an unknown
ClientHttpRequestFactory
implementation.Support for
SimpleClientHttpRequestFactory.ClientHttpRequestFactories.Simple.SimpleClientHttpsRequestFactory to configure SSL from an
SslBundle.RuntimeHintsRegistrar for ClientHttpRequestFactories.Factory for
ClientHttpRequest objects.Settings that can be applied when creating a
ClientHttpRequestFactory.Abstract base class for
ClientHttpRequestFactory implementations
that decorate another request factory.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.
ClientHttpResponse Decorator
Wraps another
ClientHttpResponse and delegates all methods to it.Represents a typed, immutable, client-side HTTP request, as executed by the
ExchangeFunction.Defines a builder for a request.
Represents an HTTP response, as returned by
WebClient and also
ExchangeFunction.Defines a builder for a response.
Represents the headers of the HTTP response.
Implementation of the
ClientResponse interface that can be subclassed
to adapt the request in a
exchange filter function.Implementation of the
Headers interface that can be subclassed
to adapt the headers in a
exchange filter function.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.
Internal delegate for loading the default codec configurer class names.
RuntimeHintsRegistrar implementation that registers runtime hints for
implementations listed in CodecConfigurer.properties.Callback interface that can be used to customize codecs configuration for an HTTP
client and/or server with a
CodecConfigurer.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.Implements the
RequestCondition contract by delegating to multiple
RequestCondition types and using a logical conjunction (' && ') to
ensure all conditions match a given request.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 Infra application context.Specialization of
ConfigurableEnvironment allowing initialization of
servlet-related PropertySource objects at the
earliest moment that the ServletContext and (optionally) ServletConfig
become available.A logical disjunction (' || ') request condition to match a request's
'Content-Type' header to a list of media type expressions.
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.Represent the Content-Disposition type and parameters as defined in RFC 6266.
A mutable builder for
ContentDisposition.Implementation of
ViewResolver that resolves a view based on the request file name
or Accept header.Creates a
ContentNegotiationManager and configures it with
one or more ContentNegotiationStrategy instances.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.
A
VersionStrategy that calculates an Hex MD5 hashes from the content
of the resource and appends it to the file name, e.g.Web application listener that cleans up remaining disposable attributes
in the ServletContext, i.e. attributes which implement
DisposableBean
and haven't been removed before.RequestContext decorator that makes all 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 Framework's root
WebApplicationContext.HttpHandler delegating requests to one of several HttpHandler's
based on simple, prefix-based mappings.Base Controller interface, representing a component that receives
RequestContext instances just like a HttpServlet
but is able to participate in an MVC workflow.Specialization of
@Component for classes that declare
@ExceptionHandler methods to be shared across
multiple @Controller classes.Encapsulates information about an
@ControllerAdvice
Framework-managed bean without necessarily requiring it to be instantiated.ReflectiveProcessor implementation for Controller and
controller-specific annotated methods.Helper class for cookie generation, carrying cookie descriptor settings
as bean properties and being able to add and remove cookie to/from a
given response.
LocaleResolver implementation that uses a cookie sent back to the user
in case of a custom setting, with a fallback to the configured default locale,
the request's Accept-Language header, or the default locale for the server.Cookie properties.
A
SessionIdResolver that uses a cookie to obtain the session from.Annotation which indicates that a method parameter should be bound to an HTTP
cookie.
HttpServiceArgumentResolver for @CookieValue
annotated arguments.A container for CORS configuration along with methods to check against the
actual origin, HTTP methods, and headers of a given request.
Contains both the user-declared pattern (e.g.
Interface to be implemented by classes (usually HTTP request handlers) that
provides a
CorsConfiguration instance based on the provided request.Filter 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
CorsConfigurationSourceA strategy that takes a request and a
CorsConfiguration and updates
the response.Assists with the creation of a
CorsConfiguration instance for a given
URL path pattern.Assists with the registration of global, URL pattern based
CorsConfiguration mappings.Annotation for permitting cross-origin requests on specific handler classes
and/or handler methods.
A
ResourceTransformer implementation that modifies links in a CSS
file to match the public URL paths that should be exposed to clients (e.g.Abstract base class for
CssLinkResourceTransformer.LinkParser implementations.Extract content chunks that represent links.
for
DateFormatters for dates, times, and date-times.HttpMessageReader that wraps and delegates to a Decoder.Decorating RequestContext
Default
AsyncServerResponse implementation.Default implementation of
ClientCodecConfigurer.Default implementation of
ClientRequest.Builder.Default implementation of
ClientResponse.Default implementation of
ClientResponse.Builder.The default implementation of
CorsProcessor, as defined by the
CORS W3C recommendation.Default
EntityResponse.Builder implementation.EntityResponse implementation for asynchronous CompletionStage bodies.Default
EntityResponse implementation for synchronous bodies.EntityResponse implementation for asynchronous Publisher bodies.Default implementation of
ExchangeStrategies.Builder.Default HttpHeaders
Default implementations of
PartEvent and subtypes.Default implementation of
FilePartEvent.Default implementation of
FormPartEvent.Default implementation of
PartEvent.Default implementations of
Part and subtypes.Abstract base class.
Part content abstraction.
Default implementation of
FilePart.Default implementation of
FormFieldPart.Default implementation of
Part.Content implementation based on a file.Content implementation based on a flux of data buffers.Default implementation of
PathContainer.Default
RenderingResponse.Builder implementation.Default implementation of
RequestPath.RequestToViewNameTranslator that simply transforms the URI of
the incoming request into a view name.Default immutable implementation of
ResourceResolvingChain.Default immutable implementation of
ResourceTransformerChain.Default implementation of the
ResponseErrorHandler interface.Default implementation of
RestClient.Default implementation of
RestClient.Builder.Default implementation of
ServerCodecConfigurer.Package-private default implementation of
ServerHttpRequest.Builder.ServerRequest implementation based on a RequestContext.Default implementation of
ServerRequest.Headers.Default
ServerRequest.Builder implementation.Default
ServerResponse.BodyBuilder implementation.Configures a request handler for serving static resources by forwarding
the request to the Servlet container's "default" Servlet.
An
HttpRequestHandler for serving static files using the Servlet container's "default" Servlet.Default implementation of the
SessionAttributeStore interface,
storing the attributes in the RequestContext session (i.e.Default implementation of
SessionManager delegating to a
SessionIdResolver for session id resolution and to a
SessionRepository.Default implementation of
SslInfo.UriBuilderFactory that relies on UriComponentsBuilder for
the actual building of the URI.Enum to represent multiple URI encoding strategies.
Default implementation of
UriTemplateHandler based on the use of
UriComponentsBuilder for expanding and encoding variables.Default implementation of
WebClient.Default implementation of
WebClient.Builder.DeferredResult provides an alternative to using a Callable for
asynchronous request processing.Handles a DeferredResult value when set.
Assists with the invocation of
DeferredResultProcessingInterceptor's.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. in response to some external event).Proxy for a standard Servlet Filter, delegating to a Frameworkmanaged bean that
implements the Filter interface.
Implementation of
ServerHttpResponse that delegates all calls to a
given target ServerHttpResponse.A subclass of
WebMvcConfigurationSupport that detects and delegates
to all beans of type WebMvcConfigurer allowing them to customize the
configuration provided by WebMvcConfigurationSupport.Annotation for mapping HTTP
DELETE requests onto specific handler
methods.Shortcut for
@HttpExchange for HTTP DELETE requests.Annotation for mapping HTTP
DELETE requests onto specific handler
methods.Central dispatcher for HTTP request handlers/controllers
Central dispatcher for HTTP request handlers/controllers in Servlet
Adding this annotation to an
@Configuration class imports the Web MVC
configuration from WebMvcConfigurationSupport, e.g.:Enable web-session supports, like servlet's http-session
Resolver that delegates to the chain, and if a resource is found, it then
attempts to find an encoded (e.g. gzip, brotli) variant that is acceptable
based on the "Accept-Encoding" request header.
An encoded
HttpResource.HttpMessageWriter that wraps and delegates to an Encoder.Entity-specific subtype of
ServerResponse that exposes entity data.Defines a builder for
EntityResponse.Base class for
ServerResponse implementations with error handling.Representation of a complete RFC 7807 error response including status,
headers, and an RFC 7807 formatted
ProblemDetail body.RuntimeException that implements ErrorResponse to expose
an HTTP status, response headers, and a body formatted as an RFC 7807
ProblemDetail.Resolves
Errors method arguments.Annotation for handling exceptions in specific handler classes and/or
handler methods.
Handle
ExceptionHandler annotated methodDiscovers @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.ControllerMappingReflectiveProcessor specific implementation that
handles @ExceptionHandler-specific types.Represents a function that filters an exchange function.
Static factory methods providing access to built-in implementations of
ExchangeFilterFunction for basic authentication, error handling, etc.Stores username and password for HTTP basic authentication.
Represents a function that exchanges a request for a (delayed)
ClientResponse.
Static factory methods to create an
ExchangeFunction.Provides strategies for use in an
ExchangeFunction.A mutable builder for an
ExchangeStrategies.Resolves method arguments annotated with
@Value.Implementation of
ResponseErrorHandler that uses HttpMessageConverters to convert HTTP error responses to RestClientExceptions.Specialization of
Part that represents an uploaded file received in
a multipart request.Represents an event triggered for a file upload.
Concrete implementation of the SessionPersister interface that utilizes
a file per saved Session in a configured directory.
Represents a directory used to store parts larger than
DefaultPartHttpMessageReader.setMaxInMemorySize(int).A
ContentNegotiationStrategy that returns a fixed content type.LocaleResolver implementation
that always returns a fixed default locale and optionally time zone.A
VersionStrategy that relies on a fixed version applied as a request
path prefix, e.g. reduced SHA, version name, release date, etc.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. file uploads).Inner class to avoid a hard dependency on the JavaMail API.
Implementation of
HttpOutputMessage used
to write a MIME multipart.OutputStream that neither flushes nor closes.
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 and use "Forwarded" or "X-Forwarded-*" headers.
Hide "Forwarded" or "X-Forwarded-*" headers.
Responsible for the contextPath, requestURI, and requestURL with forwarded
headers in mind, and also taking into account changes to the path of the
underlying delegate request (e.g. on a Servlet FORWARD).
Extract values from "Forwarded" and "X-Forwarded-*" headers to override
the request URI (i.e.
Utility class to assist with processing "Forwarded" and "X-Forwarded-*" headers.
Interface to be implemented by objects that configure and manage a
FreeMarker Configuration object in a web environment.
JavaBean to configure FreeMarker for web usage, via the "configLocation"
and/or "freemarkerSettings" and/or "templateLoaderPath" properties.
View using the FreeMarker template engine.
Extension of FreeMarker
SimpleHash, adding a fallback to request attributes.Convenience subclass of
UrlBasedViewResolver
that supports FreeMarkerView (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 servlet environments.Annotation for mapping HTTP
GET requests onto specific handler
methods.Shortcut for
@HttpExchange for HTTP GET requests.Annotation for mapping HTTP
GET requests onto specific handler
methods.Interface to be implemented by objects that configure and manage a Groovy
MarkupTemplateEngine for automatic lookup in a web environment.An extension of Groovy's
TemplateConfiguration and
an implementation of Framework MVC's GroovyMarkupConfig for creating
a MarkupTemplateEngine for use in a web application.An
AbstractTemplateView subclass based on Groovy XML/XHTML markup templates.Convenience subclass of
AbstractTemplateViewResolver that supports
GroovyMarkupView (i.e.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.MVC framework SPI, allowing parameterization of the core MVC workflow.
HandlerAdapter can be injected at runtime
For
HandlerAdapter not found
Note: This framework allows hander use
HandlerAdapterCapable
to specific a HandlerAdapter at startup timecomposite HandlerAdapter
Handle Exception from handler
Handler execution chain, consisting of handler object and any handler interceptors.
Represents a function that filters a handler function.
Represents a function that handles a request.
HandlerAdapter implementation that supports HandlerFunctions.Handler process around Handler.
for holding
HandlerInterceptorsInterface to be implemented by objects that define a mapping between
requests and handler objects.
A strategy for assigning a name to a handler method's mapping.
just for HandlerMethod return-value handling
By default when the DispatcherHandler can't find a handler for a request it
sends a 404 response.
Composite HandlerMapping
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.A
HeaderSessionIdResolver that uses a header to resolve the session id.A logical conjunction (
' && ') request condition that matches a request against
a set of header expressions with syntax defined in RequestMapping.headers().Parses and matches a single header expression to a request.
Filter that converts posted method parameters into HTTP methods,
retrievable via HttpServletRequest.getMethod().Simple
HttpServletRequest wrapper that returns the supplied method for
HttpServletRequest.getMethod().Extension of
UriComponents for hierarchical URIs.Represents a path backed by a String.
Defines the contract for path (segments).
Represents a collection of PathComponents.
Represents a path backed by a String list (i.e. path segments).
Enumeration used to identify the allowed characters per URI component.
Helper for decoding HTML Strings by replacing character
entity references with the referred character.
Represents a set of character entity references defined by the
HTML 4.0 standard.
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.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.Callback that invoked when a response is received.
Callback that invoked when a request is executed.
ClientHttpRequest implementation based on
Apache HttpComponents HttpClient.ClientHttpRequest implementation for the Apache HttpComponents HttpClient 5.x.ClientHttpRequestFactory implementation that
uses Apache HttpComponents
HttpClient to create requests.ClientHttpResponse implementation based on
Apache HttpComponents HttpClient.ClientHttpResponse implementation for the Apache HttpComponents HttpClient 5.x.MultiValueMap implementation for wrapping Apache HttpComponents
HttpClient headers.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.
Resolves
HttpEntity and RequestEntity method argument values
and also handles HttpEntity and ResponseEntity return values.Annotation to declare a method on an HTTP service interface as an HTTP
endpoint.
Contract to abstract an HTTP client from HttpServiceProxyFactory
and make it pluggable.
AOT
BeanRegistrationAotProcessor that detects the presence of
@HttpExchange on methods and creates the required proxy
hints.ReflectiveProcessor implementation for @HttpExchange
annotated methods.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.
Handles return values of type
HttpHeaders.ServerHttpResponse decorator for HTTP HEAD requests.Holds the shared logger named "cn.taketoday.http.HttpLogging" for HTTP
related logging when "cn.taketoday.http" is not enabled but
"cn.taketoday.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.Bean used to manage the
HttpMessageConverters used in application.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>, cn.taketoday.http.HttpInputMessage) method fails.Thrown by
HttpMessageConverter implementations when the
HttpMessageConverter.write(T, cn.taketoday.http.MediaType, cn.taketoday.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.Enumeration of HTTP request methods.
HttpServiceArgumentResolver that resolves the target
request's HTTP method from an HttpMethod argument.RuntimeHintsRegistrar implementation that makes sure mime types
are available in constrained environments.Represents an HTTP (byte) range for use with the HTTP
"Range" header.Represents an HTTP/1.1 byte range, with a first and optional last position.
Represents an HTTP/1.1 suffix byte range, with a number of suffix bytes.
Provides a convenient implementation of the
HttpRequest interface
that can be overridden to adapt the request.Plain handler interface for components that process HTTP requests
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.Extended interface for a
Resource to be written to an
HTTP response.Exception thrown when an HTTP 5xx is received.
HttpServerErrorException for status HTTP HTTP 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.Implements the invocation of an
@HttpExchange-annotated,
HTTP service proxy method
by delegating to an HttpExchangeAdapter to perform actual requests.Factory for
HttpRequestValues with values extracted from the type
and method-level @HttpRequest annotations.Execute a request, obtain a response, and adapt to the expected return type.
Factory to create a client proxy from an HTTP service interface with
@HttpExchange methods.Builder to create an
HttpServiceProxyFactory.MethodInterceptor that invokes an HttpServiceMethod.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.For Framework Configuration errors
Infrastructure Handler
Annotation that identifies methods which initialize the
WebDataBinder which
will be used for populating command and form object arguments
of annotated handler methods.Extends
BindingContext with @InitBinder method initialization.Memory based
SessionRepositoryWrapper for a
ClientHttpRequest that has support for ClientHttpRequestInterceptors.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.Declarative interceptor configuration
HandlerInterceptor execution chain
Assists with the creation of a
MappedInterceptor.Helps with configuring a list of mapped interceptors.
Parser for URI template patterns.
Wrapper for a JSP or other resource within the same web application.
Convenient subclass of
UrlBasedViewResolver that supports
InternalResourceView (i.e.Implementation of
ClientHttpResponse that can not only check if
the response has a message body, but also if its length is 0 (i.e. empty)
by actually reading the input stream.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
ParameterResolvingStrategy.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.9 encoding and decoding.
Decode a byte stream into JSON and convert to Object's with Jackson 2.9,
leveraging non-blocking parsing.
Encode from an
Object stream to a byte stream of JSON objects using Jackson 2.9.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.9,
leveraging non-blocking parsing.
Encode from an
Object stream to a byte stream of Smile objects using Jackson 2.9.Function to transform a JSON stream of arbitrary size, byte array
chunks into a Flux<TokenBuffer> where each token buffer is a
well-formed JSON object.RuntimeHintsRegistrar implementation that registers reflection entries
for Jackson2ObjectMapperBuilder well-known modules.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.ClientHttpConnector for the Java HttpClient.ClientHttpRequest implementation based the Java HttpClient.ClientHttpRequest for the Java HttpClient.ClientHttpRequestFactory implementation based on the Java
HttpClient.ClientHttpResponse implementation based on the Java HttpClient.ClientHttpResponse for the Java HttpClient.Factory to manage JDK HttpClient resources such as a shared
Executor
within the lifecycle of a Infra ApplicationContext.ClientHttpConnector for the Jetty Reactive Streams HttpClient.ClientHttpRequest implementation based on Jetty's
HttpClient.ClientHttpRequest implementation for the Jetty ReactiveStreams HTTP client.ClientHttpRequestFactory implementation based on Jetty's HttpClient.ClientHttpResponse implementation based on based on Jetty's
HttpClient.ClientHttpResponse implementation for the Jetty ReactiveStreams HTTP client.MultiValueMap implementation for wrapping Jetty HTTP headers.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.A
RequestBodyAdvice implementation that adds support for Jackson's
@JsonView annotation declared on MVC @HttpEntity or
@RequestBody method parameter.A
ResponseBodyAdvice implementation that adds support for Jackson's
@JsonView annotation declared on MVC @RequestMapping or
@ExceptionHandler method.Helper class for preparing JSTL views,
in particular for exposing a JSTL localization context.
Framework-specific LocalizationContext adapter that merges session-scoped
JSTL LocalizationContext/Locale attributes with the local Framework request context.
Specialization of
InternalResourceView for JSTL pages,
i.e.A literal path element.
for
LocalDatefor
LocalDateTimeInterceptor that allows for changing the current locale on every request,
via a configurable request parameter (default parameter name: "locale").
Extension of
LocaleResolver, adding support for a rich locale context
(potentially including locale and time zone information).Interface for web-based locale resolution strategies that allows for
both locale resolution via the request and locale modification via
request and response.
for
LocalTimeBase class for
Encoder,
Decoder, HttpMessageReader, or
HttpMessageWriter that uses a logger and shows potentially sensitive
request data.Resolves
Map<String, Object> model method arguments and handles Map return values.Wraps a
HandlerInterceptor and uses URL patterns to determine whether
it applies to a given request.Contains both the parsed
PathPattern and the raw String pattern,
and uses the former when the cached path is PathContainer or the
latter otherwise.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.Framework MVC
View that renders JSON content by serializing the model for the current request
using Jackson 2'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.Framework MVC
View that renders XML content by serializing the model for the current request
using Jackson 2's XmlMapper.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.
A
WebSession implementation that is backed by a Map.Implementation of
HttpMessageConverter
that can read and write XML using Infra Marshaller and Unmarshaller abstractions.Web-MVC
View that allows for response context to be rendered as the result
of marshalling by a Marshaller.Binds the value(s) of a URI matrix parameter to a resource method parameter,
resource class field, or resource class bean property.
Resolves arguments of type
Map annotated with @MatrixParam
where the annotation does not specify a name.Resolves arguments annotated with
@MatrixParam.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 contract for media type expressions (e.g.
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).
MethodParameter can't be resolved
RequestBindingException 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.RequestBindingException 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.RequestBindingException subclass that indicates
that a request cookie expected in the method parameters of an
@RequestMapping method is not present.RequestBindingException subclass that indicates
that a request header expected in the method parameters of an
@RequestMapping method is not present.RequestBindingException subclass that indicates a missing parameter.Raised when the part of a "multipart/form-data" request identified by its
name cannot be found.
Base class for
RequestBindingException exceptions that could
not bind because the request value is required but is either missing or
otherwise resolves to null after conversion.Holder for both Model and View in the web MVC framework.
for ModelAndView
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.Representation for a part in a "multipart/form-data" request.
Prepare the body of a multipart request, resulting in a
MultiValueMap<String, HttpEntity>.Builder that allows for further customization of part headers.
Specialization of
HttpEntity for use with a
Publisher-based body, for which we also need to keep track of
the element type.Properties to be used in configuring a
MultipartConfigElement.Multipart cannot be parsed include
MultipartFile and normal partA representation of an uploaded file received in a multipart request.
Adapt
MultipartFile to Resource,
exposing the content as InputStream and also overriding
MultipartFileResource.contentLength() as well as MultipartFileResource.getName().HttpMessageReader for reading "multipart/form-data" requests
into a MultiValueMap<String, Part>.HttpMessageWriter for writing a MultiValueMap<String, ?>
as multipart form data, i.e.Subscribes to a buffer stream and produces a flux of
MultipartParser.Token instances.Represents a token that contains
DataBuffer.The state of the parser when finished, either due to seeing the final
boundary or to a malformed message.
Represents a token that contains
HttpHeaders.Represents the internal state of the
MultipartParser.Represents the output of
MultipartParser.parse(Flux, byte[], int, Charset).This interface defines the multipart request access operations that are exposed
for actual multipart requests.
A common delegate for
ParameterResolvingStrategy implementations
which need to resolve MultipartFile and Part arguments.Various static utility methods for dealing with multipart parsing.
Support class for multipart HTTP message writers.
Creates instances of
UriComponentsBuilder
by pointing to @RequestMapping methods on MVC controllers.Builder class to create URLs for method arguments.
Method invocation information.
Represents the information about a named value,
including name, whether it's required and a default value.
A contract for
"name!=value" style expression used to specify request
parameters and request header conditions in @RequestMapping.MultiValueMap implementation for wrapping Netty 4 HTTP headers.MultiValueMap implementation for wrapping Netty HTTP headers.FactoryBean that creates a java.net.Proxy.Exception for errors that fit response status 406 (not acceptable).
Process Handler not found
Not A Multipart Request Exception
HandlerMethod return Object
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.Filter base class that aims to guarantee a single execution per request
dispatch, on any servlet container.
Extension of
UriComponents for opaque URIs.An
Ordered Filter.FormContentFilter that also implements Ordered.HiddenHttpMethodFilter that also implements Ordered.Bridges between
OutputStream and
Flow.Publisher<T>.Maps bytes written to in
OutputStreamPublisher.OutputStreamHandler.handle(OutputStream)
to published items.Defines the contract for handling the
OutputStream provided by
the OutputStreamPublisher.Strategy that resolves the requested content type from a query parameter.
Parameter can't convert to target class
Trivial controller that always returns a pre-configured view and optionally
sets the response status code.
Parameter read failed
For
ParameterResolvingStrategy NotFound ExceptionParameterResolvingStrategy registry
Composite ParameterResolvingStrategy
Strategy interface for method parameter resolving.
A logical conjunction (
' && ') request condition that matches a request against
a set parameter expressions with syntax defined in RequestMapping.params().Parses and matches a single param expression to a request.
Representation for a part in a "multipart/form-data" request.
Represents an event for a "multipart/form-data" request.
HttpMessageWriter for writing PartEvent objects.Subscribes to a token stream (i.e. the result of
MultipartParser.parse(Flux, byte[], int, Charset), and produces a flux of Part objects.Represents the internal state of the
PartGenerator for
creating a single Part.HttpMessageWriter for writing with Part.Annotation for mapping HTTP
PATCH requests onto specific handler
methods.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.
Common supertype for the Ast nodes created to represent a path pattern.
A
ContentNegotiationStrategy that resolves the file extension in the
request path to a key to be used to look up a media type.Assist with configuring
HandlerMapping's with path matching options.Holder for URI variables and path parameters (matrix variables) extracted
based on the pattern for a given matched path.
Representation of a parsed path pattern.
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 request.RouteMatcher built on PathPatternParser that uses
PathContainer and PathPattern as parsed representations of
routes and patterns.A logical disjunction (' || ') request condition that matches a request
against a set of URL path patterns.
Lookup function used by
RouterFunctions.resources(String, Resource).A simple
ResourceResolver that tries to find a resource under the given
locations matching to the request path.This annotation may be used to annotate method parameters on request mappings
where a URI-template has been used in the path-mapping of the
RequestMapping
annotation.HttpServiceArgumentResolver for @PathVariable
annotated arguments.Resolves
Map method arguments annotated with an @PathVariable
where the annotation does not specify a path variable name.Resolves method arguments annotated with an @
PathVariable.Pattern handler match in runtime
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.SessionRepository implementation for session persistence
Annotation for mapping HTTP
POST requests onto specific handler
methods.Shortcut for
@HttpExchange for HTTP POST requests.Annotation for mapping HTTP
POST requests onto specific handler
methods.Resolves an argument of type
Principal, similar to
ServletRequestMethodArgumentResolver but irrespective of whether the
argument is annotated or not.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.RuntimeHintsRegistrar implementation that registers binding reflection entries
for ProblemDetail serialization support with Jackson.A logical disjunction (' || ') request condition to match a request's 'Accept' header
to a list of media type expressions.
Base class providing support methods for Protobuf encoding and decoding.
An
HttpMessageConverter that reads and writes
com.google.protobuf.Messages using
Google Protocol Buffers.Protobuf format support.
ProtobufHttpMessageConverter.ProtobufFormatSupport implementation used when
com.googlecode.protobuf.format.FormatFactory is available.ProtobufHttpMessageConverter.ProtobufFormatSupport implementation used when
com.google.protobuf.util.JsonFormat is available.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.Annotation for mapping HTTP
PUT requests onto specific handler
methods.Shortcut for
@HttpExchange for HTTP PUT requests.Annotation for mapping HTTP
PUT requests onto specific handler
methods.An "reactive" HTTP input message that exposes the input as
Publisher.A "reactive" HTTP output message that accepts output as a
Publisher.HttpRequestValues extension for use with ReactorHttpExchangeAdapter.Builder for
ReactiveHttpRequestValues.Private helper class to assist with handling "reactive" return values types
that can be adapted to a Reactive Streams
Publisher through the
ReactiveAdapterRegistry.List of collect values where all elements are a specified type.
Reactor-Netty implementation of
ClientHttpConnector.ClientHttpRequest implementation for the Reactor-Netty HTTP client.ClientHttpResponse implementation for the Reactor-Netty HTTP client.Contract to abstract a reactive, HTTP client from
HttpServiceProxyFactory and make it pluggable.
Adapt
HttpHandler to the Reactor Netty channel handling function.Reactor Netty 2 (Netty 5) implementation of
ClientHttpConnector.ClientHttpRequest implementation for the Reactor Netty 2 (Netty 5) HTTP client.ClientHttpResponse implementation for the Reactor Netty 2 (Netty 5) HTTP client.Adapt
HttpHandler to the Reactor Netty 5 channel handling function.Factory to manage Reactor Netty resources, i.e.
Adapt
ServerHttpRequest to the Reactor HttpServerRequest.Adapt
ServerHttpResponse to the HttpServerResponse.ClientHttpRequest implementation for the Reactor-Netty HTTP client.Reactor-Netty implementation of
ClientHttpRequestFactory.ClientHttpResponse implementation for the Reactor-Netty HTTP client.Factory to manage Reactor Netty resources, i.e.
Adapt
ServerHttpRequest to the Reactor HttpServerRequest.Adapt
ServerHttpResponse to the HttpServerResponse.Helper class for creating a
URI from a reactor HttpServerRequest.HttpHeaders object that can only be read, not written to.A specialization of the
Model interface that controllers can use to
select attributes for a redirect scenario.RedirectModel saving strategy
View that redirects to an absolute, context relative, or current request
relative URL.
Assist with the registration of a single redirect view controller.
A regex path element.
ParameterResolvingRegistry ResolvableParameterFactory
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.A response wrapper used for the implementation of
RelativeRedirectFilter also shared with ForwardedHeaderFilter.Render an image to HTTP response-body
Context passed to
ScriptTemplateView render function in order to make
the application context, the locale, the template loader and the url available on
scripting side.Rendering-specific subtype of
ServerResponse that exposes model and template data.Defines a builder for
RenderingResponse.Defines a builder for
RenderingResponse.Annotation to bind a method parameter to a request attribute.
HttpServiceArgumentResolver for @RequestAttribute
annotated arguments.Fatal binding exception, thrown when we want to
treat binding exceptions as unrecoverable.
Annotation indicating a method parameter should be bound to the body of the web request.
Allows customizing the request before its body is read and converted into an
Object and also allows for processing of the resulting Object before it is
passed into a controller method as an
@RequestBody or an
HttpEntity method argument.HttpServiceArgumentResolver for @RequestBody
annotated arguments.Callback interface for code that operates on a
ClientHttpRequest.Contract for request mapping conditions.
A holder for a
RequestCondition useful when the type of the request
condition is not known ahead of time, e.g. custom condition.Context holder for request-specific state.
Provides a convenient implementation of the RequestContext
that can be subclassed by developers wishing to adapt the request to web.
Holder class to expose the web request in the form of a thread-bound
RequestContext object.Resolves servlet backed request-related method arguments.
Parameter extraction methods, for an approach distinct from data binding,
in which parameters of specific types are required.
Factory that exposes the current request-context object on demand.
Factory that exposes the current web-session object on demand.
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.
publish
RequestHandledEventAnnotation 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.
Creates
RequestMappingInfo instances from type and method-level
@RequestMapping annotations in
@Controller classes.Request mapping information.
Defines a builder for creating a RequestMappingInfo.
Container for configuration options used for request mapping purposes.
Abstract base class for classes for which
RequestMappingInfo defines
the mapping between a request and a handler method.Default handler for HTTP OPTIONS.
Aggregate all partial matches and expose methods checking across them.
Container for a RequestMappingInfo that matches the URL path at least.
A
HandlerMethodMappingNamingStrategy
for RequestMappingInfo-based handler method mappings.A logical disjunction (' || ') request condition that matches a request
against a set of
HttpMethods.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 MultipartRequest
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.Resolves the following method arguments:
Annotated with @
RequestPart
Of type MultipartFile
Of type jakarta.servlet.http.Part in conjunction with Servlet multipart requests
HttpRequest implementation that accesses one part of a multipart
request.Specialization of
PathContainer that sub-divides the path into a
RequestPath.contextPath() and the remaining RequestPath.pathWithinApplication().Represents a function that evaluates on a given
ServerRequest.Implementations of
RequestPredicate that implement various useful
request matching operations, such as matching based on path, HTTP method, etc.RequestPredicate that negates a delegate predicate.Extension of
RequestPredicate that can modify the ServerRequest.Receives notifications from the logical structure of request predicates.
Invokes
RequestBodyAdvice and ResponseBodyAdvice where each
instance may be (and is most likely) wrapped with
ControllerAdviceBean.Resolves method arguments annotated with
@RequestBody and handles return
values from methods annotated with @ResponseBody by reading and writing
to the body of the request or response with an HttpMessageConverter.@RequestScope is a specialization of @Scope for a
component whose lifecycle is bound to the current web request.RequestScope beans just available in current
RequestContextStrategy interface for translating an incoming
RequestContext
into a logical view name when no view name is explicitly supplied.Abstraction for Parameter
Build
ResolvableMethodParameter arrayException thrown when an I/O error occurs.
Assists with the registration of resource resolvers and transformers.
Resource-based implementation of
HandlerFunction.Encapsulates information required to create a resource handler.
Stores registrations of resource handlers for serving static resources such
as images, css files and others through Web MVC including setting cache
headers optimized for efficient loading in a web browser.
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.HttpRequestHandler that serves static resources in an optimized way
according to the guidelines of Page Speed, YSlow, etc.Implementation of
HttpMessageConverter that can write a single
ResourceRegion or Collections of ResourceRegions.A strategy for resolving a request to a server-side resource.
A contract for invoking a chain of
ResourceResolvers where each resolver
is given a reference to the chain allowing it to delegate when necessary.An abstraction for transforming the content of a resource.
A contract for invoking a chain of
ResourceTransformers where each resolver
is given a reference to the chain allowing it to delegate when necessary.A base class for a
ResourceTransformer with an optional helper method
for resolving public links within a transformed resource.A central component to use to obtain the public URL path that clients should
use to access a static resource.
Allows customizing the response after the execution of an
@ResponseBody
or a ResponseEntity controller method but before the body is written
with an HttpMessageConverter.A controller method return value type for asynchronous request processing
where one or more objects are written to the response.
A simple holder of data to be written along with a MediaType hint for
selecting a message converter to write with.
Contract to handle the sending of event data, the completion of event
sending, and the registration of callbacks to be invoked in case of
timeout, error, and completion for any reason (including from the
container side).
Handler for return values of type
ResponseBodyEmitter and sub-classes
such as SseEmitter including the same types wrapped with
ResponseEntity.An
HttpCookie subclass with the additional attributes allowed in
the "Set-Cookie" response header.Default implementation of
ResponseCookie.ResponseCookieBuilder.A builder for a server-defined HttpCookie with attributes.
Extension of
HttpEntity that adds a HttpStatusCode status code.Defines a builder that adds a body to the response entity.
Defines a builder that adds headers to the response entity.
A convenient base class for
@ControllerAdvice classes
that wish to provide centralized exception handling across all
@RequestMapping methods through @ExceptionHandler methods.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.value() and
ResponseStatus.reason() that should be returned.Subclass of
ErrorResponseException that accepts a "reason" and maps
it to the "detail" property of ProblemDetail.A
HandlerExceptionHandler that uses
the @ResponseStatus annotation to map exceptions
to HTTP status codes.Client to perform HTTP requests, exposing a fluent, synchronous API over
underlying HTTP client libraries such the JDK
HttpClient, Apache
HttpComponents, and others.A mutable builder for creating a
RestClient.Contract for specifying request headers and body leading up to the exchange.
Contract for specifying request headers, body and URI for a request.
Contract for specifying request headers leading up to the exchange.
Defines the contract for
RestClient.RequestHeadersSpec.exchange(ExchangeFunction).Contract for specifying request headers and URI for a request.
Contract for specifying response operations following the exchange.
Contract for specifying the URI for a request.
HttpExchangeAdapter that enables an HttpServiceProxyFactory
to use RestClient for request execution.Callback interface that can be used to customize a
RestClient.Builder.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.
Internal methods shared between types in this package.
A convenience annotation that is itself annotated with
@Controller and @ResponseBody.A convenience annotation that is itself annotated with
@ControllerAdvice
and @ResponseBody.Convenient super class 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.Response extractor that extracts the response
HttpHeaders.HttpExchangeAdapter that enables an HttpServiceProxyFactory
to use RestTemplate for request execution.Builder that can be used to configure and create a
RestTemplate.ClientHttpRequestFactory to apply customizations from the
RestTemplateBuilder.Callback interface that can be used to customize a
RestTemplate.Callback interface that can be used to customize the
ClientHttpRequest sent
from a RestTemplate.handler return-value Handler
Decorator Pattern
return-value handler manager
For
ReturnValueHandler not foundUriTemplateHandler to set the root for URI that starts with '/'.Represents a function that routes to a handler function.
Default implementation of
RouterFunctions.Builder.Router function returned by
RouterFunctionBuilder.build() that simply iterates over the registered routes.HandlerMapping implementation that supports RouterFunctions.Central entry point to Infra functional web framework.
Exposes routing functionality, such as to create a
RouterFunction using a discoverable builder-style API, to
create a RouterFunction
given a RequestPredicate and HandlerFunction, and to do further
subrouting on an existing routing
function.Represents a discoverable builder for router functions.
A composed routing function that first invokes one function, and then invokes
another function (of a different response type) if this route had
no result.
Filter the specified handler functions with the given
filter function.
A composed routing function that first invokes one function, and then invokes the
another function (of the same response type
T) if this route had
no result.Receives notifications from the logical structure of router functions.
Implementation of
HttpMessageConverter
that can read and write RSS feeds.SameSite values.
Interface to be implemented by objects that configure and manage a
JSR-223
ScriptEngine for automatic lookup in a web environment.An implementation of Framework Web's
ScriptTemplateConfig for creating
a ScriptEngine for use in a web application.An
AbstractUrlBasedView subclass designed to run any template library
based on a JSR-223 script engine.Key class for the
enginesHolder ThreadLocal.Convenience subclass of
UrlBasedViewResolver that supports
ScriptTemplateView and custom subclasses of it.A
SessionIdGenerator that uses a secure random to generate a
session ID.select
ReturnValueHandler handler in listA separator path element.
Extension of
CodecConfigurer for HTTP message reader and writer
options relevant on the server side.CodecConfigurer.DefaultCodecs extension with extra server-side options.Default implementation of
ServerCodecConfigurer.ServerDefaultCodecs.A control that can put the processing of an HTTP request in asynchronous mode during
which the response remains open until explicitly closed.
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.Represents a server-side HTTP request, as handled by a
HandlerFunction.Defines a builder for a request.
Represents the headers of the HTTP request.
Represents a typed server-side HTTP response, as returned
by a handler function or
filter function.
Defines a builder that adds a body to the response.
Defines the context used during the
ServerResponse.writeTo(RequestContext, Context).Defines a builder that adds headers to the response.
Defines the contract for
ServerResponse.HeadersBuilder.build(WriteFunction).Defines a builder for a body that sends server-sent events.
Representation for a Server-Sent Event for use with 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.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 Frameworkdefined 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.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
PathMatchingPatternResourceLoader,
able to find matching resources below the web application root directory
via ServletContext.getResourcePaths(java.lang.String).A common delegate for detecting Servlet's presence AND its features
Controller implementation that forwards to a named servlet,
i.e. the "servlet-name" in web.xml rather than a URL path mapping.
Adapt
HttpHandler to an HttpServlet using Servlet Async support
and Servlet 3.1 non-blocking I/O.AsyncListener to complete the
AsyncContext in case of error or
timeout notifications from the containerInterface to indicate
RequestContext running in servletFor Servlet Multipart
Servlet based
AbstractMultipartMultipartFile adapter, wrapping a Servlet Part object.
Servlet environment implementation
Simple wrapper around the default
RequestPath implementation that
supports a servletPath as an additional prefix to be omitted from
ServletRequestContext.ServletRequestPath.pathWithinApplication().Special
DataBinder to perform data binding
from servlet request parameters to JavaBeans, including support for multipart files.Resolves servlet backed request-related method arguments.
PropertyValues implementation created from parameters in a ServletRequest.
A
ServerHttpAsyncRequestControl to use on Servlet containers (Servlet 3.0+).Adapt
ServerHttpRequest to the Servlet HttpServletRequest.ServerHttpRequest implementation that is based on a HttpServletRequest.Adapt
ServerHttpResponse to the Servlet HttpServletResponse.ServerHttpResponse implementation that is based on a HttpServletResponse.UriComponentsBuilder with additional static factory methods to create links
based on the current HttpServletRequest.
A Servlet
ViewResolver that delegates to others.Framework Controller implementation that wraps a servlet instance which it manages
internally.
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.
SessionManager supported HandlerInterceptor
Strategy for generating session ID's.
Contract for session id resolution strategies.
LocaleResolver implementation that
uses a locale attribute in the user's session in case of a custom setting,
with a fallback to the configured default locale, the request's
Accept-Language header, or the default locale for the server.Main class for access to the
WebSession for an HTTP request.Help to find SessionManager in BeanFactory and request-context
SessionManager
for
WebSession Type-based parameter resolvingA SessionPersister that provides persistent storage and loading
of Sessions and their associated user data.
Session properties.
Store
RedirectModel in WebSessionWebSession Storage@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 BindingContext.Available session tracking modes (mirrors
SessionTrackingMode.Filter that generates an ETag value based on the
content on the response.Returns the raw OutputStream, instead of the one that does caching,
if
ShallowEtagHeaderFilter.isContentCachingDisabled(jakarta.servlet.http.HttpServletRequest).write 'classpath:error/xxx.png' for RenderedImage
ClientHttpRequest implementation that uses standard JDK facilities to
execute buffered requests.ClientHttpRequestFactory implementation that uses standard JDK facilities.ClientHttpResponse implementation that uses standard JDK facilities.The default implementation of the
HandlerExceptionHandler
interface, resolving standard Framework MVC exceptions and translating them to corresponding
HTTP status codes.simple HttpOutputMessage
Simple implementation of
HttpStatusCode.HandlerExceptionHandler implementation that allows for mapping exception
class names to view names, either for a set of given handlers or for all handlers
in the DispatcherHandler.Simple implementation of the
SessionStatus interface,
keeping the complete flag as an instance variable.Simple
javax.xml.transform.ErrorListener implementation:
logs warnings using the given Commons Logging logger instance,
and rethrows errors to discontinue the XML transformation.Implementation of the
HandlerMapping interface that maps from URLs
to request handler beans.A literal path element that does includes the single character wildcard '?'
let user determine the handler and returnValue relationship
Provides additional information about a View such as whether it
performs redirects.
Implementation of
HttpMessageConverter
that can read and write Source objects.A specialization of
ResponseBodyEmitter for sending
Server-Sent Events.A builder for an SSE event.
Default implementation of SseEventBuilder.
Implementation of
ServerResponse for sending
Server-Sent Events.A holder for SSL session information.
A Servlet implementation of
AsyncWebRequest.Environment implementation to be used by Servlet-based web
applications.Static
WebApplicationContext
implementation for testing.Used by
DefaultRestClient and DefaultRestClientBuilder.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.A controller method return value type for asynchronous request processing
where the application can write directly to the response
OutputStream
without holding up the Servlet container thread.Supports return values of type
StreamingResponseBody and also ResponseEntity<StreamingResponseBody>.Implementation of
HttpMessageConverter that can read and write strings.Custom
PropertyEditor for converting
MultipartFiles to Strings.Sends a 503 (SERVICE_UNAVAILABLE) in case of a timeout if the response is not
already committed. this is done indirectly by setting the result
to an
AsyncRequestTimeoutException which is then handled by
MVC's default exception handling as a 503 error.MultiValueMap implementation for wrapping Tomcat HTTP headers.ServletHttpHandlerAdapter extension that uses Tomcat APIs for reading
from the request and writing to the response with ByteBuffer.An exception that indicates the maximum number of active sessions has been
reached and the server is refusing to create any new sessions.
Implementation of
RouterFunctions.Visitor that creates a formatted
string representation of router functions.An extension of
ByteArrayResource that a ResourceTransformer
can use to represent an original resource preserving all other information
except the content.MultiValueMap implementation for wrapping Undertow HTTP headers.Adapt
HttpHandler to the Undertow HttpHandler.Adapt
ServerHttpRequest to the Undertow HttpServerExchange.Adapt
ServerHttpResponse to the Undertow HttpServerExchange.Raised when no suitable
HttpMessageConverter could be
found to extract the response.Exception thrown when an unknown (or custom) HTTP status code is received.
Exception thrown when an unknown (or custom) HTTP status code is received.
RequestBindingException subclass that indicates an unsatisfied
parameter condition, as typically expressed using an @RequestMapping
annotation at the @Controller type level.Exception thrown to indicate that a
Content-Type is not supported.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.
URI template variables backed by a map.
Defines the contract for URI Template variables.
URI template variables backed by a variable argument array.
Builder for
UriComponents.Resolvers argument values of type
UriComponentsBuilder.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).Helper to extract variable names and regex for matching to actual URLs.
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.Provide a per request
CorsConfiguration instance based on a
collection of CorsConfiguration mapped on path patterns.Simple implementation of the
ViewResolver
interface, allowing for direct resolution of symbolic view names to URLs,
without explicit mapping definitions.Assist with configuring a
UrlBasedViewResolver.Simple
Controller implementation that transforms the virtual
path of a URL into a view name and returns that view.Helper class for URL path matching.
A strategy for extracting and embedding a resource version in its URL path.
Resolves request paths containing a version string that can be used as part
of an HTTP caching strategy in which a resource is cached with a date in the
distant future (e.g. 1 year) and cached until the version, and therefore the
URL, is changed.
An extension of
VersionPathStrategy that adds a method
to determine the actual version of a Resource.View for a web interaction.
Assist with the registration of a single view controller.
Assists with the registration of simple automated controllers pre-configured
with status code and/or a view.
ViewRef contains a view-name and locale
Interface to be implemented by objects that can resolve views by name.
A
ViewResolver that delegates to others.Assist with the configuration of a chain of
ViewResolver instances.for
Void or void typeInterface to provide configuration for a servlet web application.
Convenience methods for retrieving the root
WebApplicationContext for
a given ServletContext.Factory that exposes the current request object on demand.
Factory that exposes the current response object on demand.
Factory that exposes the current session object on demand.
Convenient superclass for application objects running in a
WebApplicationContext.The central class for managing asynchronous request processing, mainly intended
as an SPI and not typically used directly by application classes.
WebAsyncManager Factory
A default MVC AsyncTaskExecutor that warns if used.
Holder for a
Callable, a timeout value, and a task executor.Callback interface for initializing a
WebDataBinder for performing
data binding in the context of a specific web request.Non-blocking, reactive client to perform HTTP requests, exposing a fluent,
reactive API over underlying HTTP client libraries such as Reactor Netty.
A mutable builder for creating a
WebClient.Contract for specifying request headers and body leading up to the exchange.
Contract for specifying request headers, body and URI for a request.
Contract for specifying request headers leading up to the exchange.
Contract for specifying request headers and URI for a request.
Contract for specifying response operations following the exchange.
Contract for specifying the URI for a request.
ReactorHttpExchangeAdapter that enables an HttpServiceProxyFactory
to use WebClient for request execution.Abstract base class for exception published by
WebClient in case of errors.Exceptions that contain actual HTTP request data.
Exceptions that contain actual HTTP response data.
WebClientResponseException for status HTTP HTTP 502 Bad Gateway.WebClientResponseException for status HTTP 400 Bad Request.WebClientResponseException for status HTTP 409 Conflict.WebClientResponseException for status HTTP 403 Forbidden.WebClientResponseException for status HTTP 504 Gateway Timeout.WebClientResponseException for status HTTP 410 Gone.WebClientResponseException for status HTTP 500 Internal Server Error.WebClientResponseException for status HTTP 405 Method Not Allowed.WebClientResponseException for status HTTP 406 Not Acceptable.WebClientResponseException for status HTTP 404 Not Found.WebClientResponseException for status HTTP 501 Not Implemented.WebClientResponseException for status HTTP 503 Service Unavailable.WebClientResponseException for status HTTP 429 Too Many Requests.WebClientResponseException for status HTTP 401 Unauthorized.WebClientResponseException for status HTTP 422 Unprocessable Entity.WebClientResponseException for status HTTP 415 Unsupported Media Type.Internal methods shared between
DefaultWebClient and
DefaultClientResponse.Convenient superclass for any kind of web content generator
Handler interceptor that checks the request for supported methods and a
required session and prepares the response by applying the configured
cache settings.
FormattingConversionService dedicated to web
applications for formatting and converting values to/from the web.Special
DataBinder for data binding from web request parameters
to JavaBean objects.Resolver that looks up values to bind in a
ServletRequest.A
ResourceResolver that delegates to the chain to locate a resource and then
attempts to find a matching versioned resource contained in a WebJar JAR file.This is the main class providing the configuration behind the MVC Java config.
Defines callback methods to customize the Java-based configuration for
framework enabled via
@EnableWebMvc.Main contract for using a server-side session that provides access to session
attributes across HTTP requests.
This listener interface can be implemented in order to get notifications of
changes to the attribute lists of sessions within this web application.
resolve attribute from
WebSessionThis is the class representing event notifications for
changes to sessions within a web application.
Interface for receiving notification events about WebSession lifecycle changes.
WebSessionListener that automatically exposes the session mutex
when an WebSession gets created.
The mutex to be registered.
Exception thrown when an HTTP request handler requires a pre-existing session.
RuntimeHintsRegistrar implementation that registers resource
hints for web util resources.Miscellaneous utilities for web applications.
A wildcard path element.
A path element representing wildcarding the rest of a path.
Publisher returned from
ReactiveHttpOutputMessage.writeWith(Publisher).Represents a state for the
Publisher to be in.Subscription to receive and delegate request and cancel signals from the
subscriber to this publisher.
WebApplicationContext implementation
which takes its configuration from XML documents, understood by an
XmlBeanDefinitionReader.XSLT-driven View that allows for response context to be rendered as the
result of an XSLT transformation.
ViewResolver implementation that
resolves instances of XsltView by translating the supplied view name
into the URL of the XSLT stylesheet.Sub-interface of
ReactiveOutputMessage that has support for "zero-copy"
file transfers.