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
StandardWebSocketClient
Jetty
@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.