All Classes and Interfaces
Class
Description
Abstract base class for filename suffix based
VersionStrategy
implementations, e.g.Abstract base class for
HandlerMapping
implementations.Abstract base class for
HandlerMapping implementations that define
a mapping between a request and a HandlerMethod.Base class for
WebSocketSession implementations that bridge between
event-listener WebSocket APIs (e.g.Abstract base class for argument resolvers that resolve method arguments
by reading the request body with an
HttpMessageReader.Abstract base class for result handlers that handle return values by writing
to the response with
HttpMessageWriter.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.
An extension of
AbstractNamedValueArgumentResolver for named value
resolvers that are synchronous and yet non-blocking.Abstract base class for
VersionStrategy implementations that insert
a prefix into the URL path, e.g.A base class for
RequestCondition types providing implementations of
AbstractRequestCondition.equals(Object), AbstractRequestCondition.hashCode(), and AbstractRequestCondition.toString().Base
ResourceResolver providing consistent logging.Abstract base class for URL-based views.
Abstract base class for URL-mapped
HandlerMapping implementations.Base class for
View implementations.Convenient base class for
WebSocketSession implementations that
holds common fields and exposes accessors.Helps to configure resolvers for Controller method arguments.
Context to assist with binding request data onto Objects and provide access
to a shared
Model with controller-specific attributes.Simple adapter to expose the bind status of a field or object.
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.A
ResourceResolver that resolves resources from a Cache or
otherwise delegates to the resolver chain and caches the result.A
ResourceTransformer that checks a Cache to see if a
previously transformed resource exists in the cache and returns it if found,
or otherwise delegates to the resolver chain and caches the result.Documented
KeyValues for the HTTP client observations.Represents a typed, immutable, client-side HTTP request, as executed by the
ExchangeFunction.Defines a builder for a request.
Context that holds information for metadata collection
during the
HTTP client exchange observations.Interface for an
ObservationConvention related to
HTTP client exchange observations.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.Representation of WebSocket "close" status codes and reasons.
Implements the
RequestCondition contract by delegating to multiple
RequestCondition types and using a logical conjunction (' && ') to
ensure all conditions match a given request.A logical disjunction (' || ') request condition to match a request's
'Content-Type' header to a list of media type expressions.
A
VersionStrategy that calculates a Hex MD5 hash from the content
of the resource and appends it to the file name, e.g.WebSocketHandler decorator that enriches the context of the target handler.No-op resolver for method arguments of type
Continuation.Resolve method arguments annotated with
@CookieValue.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.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.
Default implementation for a
ClientRequestObservationConvention,
extracting information from the ClientRequestObservationContext.A subclass of
WebFluxConfigurationSupport that detects and delegates
to all beans of type WebFluxConfigurer allowing them to customize the
configuration provided by WebFluxConfigurationSupport.Central dispatcher for HTTP request handlers/controllers.
Contract to map a
Throwable to a HandlerResult.Adding this annotation to an
@Configuration class imports the Spring
WebFlux configuration from WebFluxConfigurationSupport that enables
use of annotated controllers and functional endpoints.Resolver that delegates to the chain, and if a resource is found, it then
attempts to find an encoded (e.g.
Entity-specific subtype of
ServerResponse that exposes entity data.Defines a builder for
EntityResponse.Resolve
Errors or BindingResult method arguments.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.Deprecated.
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.Resolver that always resolves to a fixed list of media types.
A
VersionStrategy that relies on a fixed version applied as a request
path prefix, e.g.Interface to be implemented by objects that configure and manage a
FreeMarker Configuration object in a web environment.
Configures FreeMarker for web usage via the "configLocation" and/or
"freemarkerSettings" and/or "templateLoaderPath" properties.
A
View implementation that uses the FreeMarker template engine.A
ViewResolver for resolving FreeMarkerView instances, i.e.Contract to abstract the details of invoking a handler of a given type.
Represents a function that filters a handler function.
Represents a function that handles a request.
HandlerAdapter implementation that supports HandlerFunctions.Interface to be implemented by objects that define a mapping between
requests and handler objects.
Strategy to resolve the argument value for a method parameter in the context
of the current HTTP request.
Base class for
HandlerMethodArgumentResolver implementations with access to a
ReactiveAdapterRegistry and methods to check for method parameter support.Represent the result of the invocation of a handler or a handler method.
Process the
HandlerResult, usually returned by a HandlerAdapter.Base class for
HandlerResultHandler with support for content negotiation and access to a
ReactiveAdapter registry.Defines the strategies to be used for processing
HandlerFunctions.A mutable builder for a
HandlerStrategies.Simple container of information related to the handshake request that started
the
WebSocketSession session.WebSocketService implementation that handles a WebSocket HTTP
handshake request by delegating to a RequestUpgradeStrategy which
is either auto-detected (no-arg constructor) from the classpath but can
also be explicitly configured.Resolver that looks at the 'Accept' header of the request.
A logical conjunction (
' && ') request condition that matches a request against
a set of header expressions with syntax defined in RequestMapping.headers().Resolves method arguments of type
HttpEntity or RequestEntity
by reading the body of the request through a compatible
HttpMessageReader.View that writes model attribute(s) with an HttpMessageWriter.Extended interface for a
Resource to be written to an
HTTP response.Extension of
HandlerMethod that invokes the underlying method with
argument values resolved from the current HTTP request through a list of
HandlerMethodArgumentResolver.A WebSocket
RequestUpgradeStrategy for Jetty 11.Deprecated, for removal: This API element is subject to removal in a future version.
as of 6.0.3, in favor of
StandardWebSocketClientJetty
@WebSocket handler that delegates events to a
reactive WebSocketHandler and its session.Spring
WebSocketSession implementation that adapts to a Jetty
WebSocket Session.Resolves arguments of type
Map annotated with @MatrixVariable
where the annotation does not specify a name.Resolves arguments annotated with
@MatrixVariable.A contract for media type expressions (e.g.
Resolve
@ModelAttribute annotated method arguments.Resolver for a controller method argument of type
Model that can
also be resolved as a Map.A contract for
"name!=value" style expression used to specify request
parameters and request header conditions in @RequestMapping.Base class for Netty-based
WebSocketSession adapters that provides
convenience methods to convert Netty WebSocketFrames to and from
WebSocketMessages.Base class for Netty-based
WebSocketSession adapters that provides
convenience methods to convert Netty WebSocketFrames to and from
WebSocketMessages.Resolver that checks a query parameter and uses it to look up a matching
MediaType.
A logical conjunction (
' && ') request condition that matches a request against
a set parameter expressions with syntax defined in RequestMapping.params().Assist with configuring
HandlerMapping's with path matching options.A simple
ResourceResolver that tries to find a resource under the given
locations matching to the request path.Resolver for
Map method arguments annotated with
@PathVariable where the annotation does not specify a
path variable name.Resolves method arguments annotated with @
PathVariable.A logical disjunction (' || ') request condition that matches a request
against a set of URL path patterns.
Resolves method argument value of type
Principal.A logical disjunction (' || ') request condition to match a request's 'Accept' header
to a list of media type expressions.
A WebSocket
RequestUpgradeStrategy for Reactor Netty for Netty 5.WebSocketClient implementation for use with Reactor Netty for Netty 5.WebSocketSession implementation for use with the Reactor Netty's (Netty 5)
NettyInbound and NettyOutbound.Simple container for
NettyInbound and NettyOutbound.A WebSocket
RequestUpgradeStrategy for Reactor Netty.WebSocketClient implementation for use with Reactor Netty.Simple container for
NettyInbound and NettyOutbound.View that redirects to an absolute or context relative URL.
Public API for HTML rendering.
Defines a builder for
Rendering.Extends
Rendering.Builder with extra options for redirect scenarios.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.Resolves method arguments annotated with an @
RequestAttribute.Resolves method arguments annotated with
@RequestBody by reading the
body of the request through a compatible HttpMessageReader.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.Context holder for request-specific state, like the
MessageSource to
use, current locale, binding errors, etc.A contract for inspecting and potentially modifying request data values such
as URL query parameters or form field values before they are rendered by a
view or before a redirect.
Strategy to resolve the requested media types for a
ServerWebExchange.Builder for a composite
RequestedContentTypeResolver that delegates
to other resolvers each implementing a different strategy to determine the
requested content type -- e.g.Helper to create and configure
ParameterContentTypeResolver.Resolves
Map method arguments annotated with @RequestHeader.Resolves method arguments annotated with
@RequestHeader except for
Map arguments.Supports the invocation of
@RequestMapping
handler methods.An extension of
RequestMappingInfoHandlerMapping that creates
RequestMappingInfo instances from class-level and method-level
@RequestMapping annotations.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.A logical disjunction (' || ') request condition that matches a request
against a set of
RequestMethods.Resolver for
Map method arguments annotated with
@RequestParam where the annotation does not specify a
request parameter name.Resolver for method arguments annotated with @
RequestParam from URI
query string parameters.Resolver for
@RequestPart arguments where the named part is decoded
much like an @RequestBody argument but based on the content of an
individual part instead.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.Receives notifications from the logical structure of request predicates.
A strategy for upgrading an HTTP request to a WebSocket session depending
on the underlying network runtime.
Assists with the registration of resource resolvers and transformers.
Assist with creating and configuring a static resources handler.
Stores registrations of resource handlers for serving static resources such
as images, css files and others through Spring WebFlux including setting cache
headers optimized for efficient loading in a web browser.
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.
HttpRequestHandler that serves static resources in an optimized way
according to the guidelines of Page Speed, YSlow, etc.HandlerResultHandler that handles return values from methods annotated
with @ResponseBody writing to the body of the request or response with
an HttpMessageWriter.A class with an
@ExceptionHandler method that handles all Spring
WebFlux raised exceptions by returning a ResponseEntity with
RFC 7807 formatted error details in the body.Handles return values of type
HttpEntity, ResponseEntity,
HttpHeaders, ErrorResponse, and ProblemDetail.Represents a function that routes to a handler function.
HandlerMapping implementation that supports RouterFunctions.Central entry point to Spring's functional web framework.
Exposes routing functionality, such as to create a
RouterFunction using a discoverable builder-style API, to
create a RouterFunction
given a RequestPredicate and HandlerFunction, and to do further
subrouting on an existing routing
function.Represents a discoverable builder for router functions.
Receives notifications from the logical structure of router functions.
Interface to be implemented by objects that configure and manage a
JSR-223
ScriptEngine for automatic lookup in a web environment.An implementation of the Spring WebFlux
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.Convenience subclass of
UrlBasedViewResolver that supports
ScriptTemplateView and custom subclasses of 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.
Implementation of the
ServerRequest interface that can be subclassed
to adapt the request in a
handler filter function.Implementation of the
Headers interface that can be subclassed
to adapt the headers in a
handler filter function.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(ServerWebExchange, Context).Defines a builder that adds headers to the response.
HandlerResultHandler implementation that supports ServerResponses.Resolves method arguments annotated with an @
SessionAttribute.Resolver for a
SessionStatus argument obtaining it from the
BindingContext.Implementation of the
HandlerMapping
interface to map from URLs to request handler beans.WebSocketClient implementation for use with the Jakarta WebSocket API.Adapter for the Jakarta WebSocket API (JSR-356) that delegates events to a
reactive
WebSocketHandler and its session.Spring
WebSocketSession adapter for a standard Java (JSR 356)
Session.A WebSocket
RequestUpgradeStrategy for the Jakarta WebSocket API 2.1+.An extension of
HandlerMethodArgumentResolver for implementations
that are synchronous in nature and do not block to resolve values.Extension of
HandlerMethod that invokes the underlying method via
InvocableHandlerMethod but uses sync argument resolvers only and
thus can return directly a HandlerResult with no async wrappers.A WebSocket
RequestUpgradeStrategy for Apache Tomcat.WebSocketClient implementation for use with Tomcat,
based on the Jakarta WebSocket API.Spring
WebSocketSession adapter for Tomcat's
Session.An extension of
ByteArrayResource that a ResourceTransformer
can use to represent an original resource preserving all other information
except the content.A WebSocket
RequestUpgradeStrategy for Undertow.Undertow based implementation of
WebSocketClient.Undertow
WebSocketConnectionCallback implementation that adapts and
delegates to a Spring WebSocketHandler.Spring
WebSocketSession implementation that adapts to an Undertow
WebSocketChannel.Exception thrown when an unknown (or custom) HTTP status code is received.
Exception thrown to indicate that a
Content-Type is not supported.A
ViewResolver that allows direct resolution of symbolic view names
to URLs without explicit mapping definitions.Assist with configuring properties of a
UrlBasedViewResolver.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.
A strategy to determine the version of a static resource and to apply and/or
extract it from the URL path.
Contract to render
HandlerResult to the HTTP response.HandlerResultHandler that encapsulates the view resolution algorithm
supporting the following return types:
Void or no value -- default view name
String -- view name unless @ModelAttribute-annotated
View -- View to render with
Model -- attributes to add to the model
Map -- attributes to add to the model
Rendering -- use case driven API for view resolution
@ModelAttribute -- attribute for the model
Non-simple value -- attribute for the model
Contract to resolve a view name to a
View instance.Assist with the configuration of a chain of
ViewResolver's supporting
different template mechanisms.Base class for
ViewResolver implementations with shared properties.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.
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 HTTP status 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.The main class for Spring WebFlux configuration.
Defines callback methods to customize the configuration for WebFlux
applications enabled via
@EnableWebFlux.A
WebFluxConfigurer that delegates to one or more others.Common WebFlux exception handler that detects instances of
ResponseStatusException
(inherited from the base class) as well as exceptions annotated with
@ResponseStatus by determining the HTTP status
for them and updating the status of the response accordingly.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.Resolves method argument value of type
WebSession.Contract for reactive-style handling of a WebSocket session.
Handler for a WebSocket session.
HandlerAdapter that allows
DispatcherHandler to support
handlers of type WebSocketHandler with such handlers mapped to
URL patterns via
SimpleUrlHandlerMapping.Representation of a WebSocket message.
WebSocket message types.
A service to delegate WebSocket-related HTTP requests to.
Represents a WebSocket session.
A predicate for use with
AbstractUrlHandlerMapping.setHandlerPredicate(java.util.function.BiPredicate<java.lang.Object, org.springframework.web.server.ServerWebExchange>)
to ensure only WebSocket handshake requests are matched to handlers of type
WebSocketHandler.
HttpHeaders.setBasicAuth(String, String)while building the request.