All Classes and Interfaces
Class
Description
Convenient base class for
AsyncHandlerMethodReturnValueHandler
implementations that support only asynchronous (Future-like) return values
and merely serve as adapters of such types to Spring's
ListenableFuture
.Abstract base class for a
MessageHandler
that broker messages to
registered subscribers.Base class for message broker registration classes.
An extension of
AbstractMessagingTemplate
that adds operations for sending
messages to a resolvable destination name.Base class for a return value handler that encodes return values to
Flux<DataBuffer>
through the configured Encoder
s.Cache exception handling method mappings and provide options to look up a method
that should handle an exception.
A base
HeaderMapper
implementation.Common base class for plain JSON converters, e.g.
Provides essential configuration for handling messages with simple messaging
protocols such as STOMP.
Abstract base class for
MessageChannel
implementations.Base class for
MessageCondition's
that pre-declares abstract methods
AbstractMessageCondition.getContent()
and AbstractMessageCondition.getToStringInfix()
in order to provide
implementations of AbstractMessageCondition.equals(Object)
, AbstractMessageCondition.hashCode()
, and
AbstractMessageCondition.toString()
.Abstract base class for
SmartMessageConverter
implementations including
support for common properties and a partial implementation of the conversion methods,
mainly to check if the converter supports the conversion based on the payload class
and MIME type.An extension of
AbstractMessageSendingTemplate
that adds support for
receive style operations as defined by MessageReceivingOperations
.Abstract base class for implementations of
MessageSendingOperations
.An extension of
AbstractMessageReceivingTemplate
that adds support for
request-reply style operations as defined by MessageRequestReplyOperations
.Abstract base class for HandlerMethod-based message handling.
Abstract base class for reactive HandlerMethod-based message handling.
Abstract base class to resolve method arguments from a named value, e.g.
Abstract base class to resolve method arguments from a named value, e.g.
Represents a named value declaration.
Represents a named value declaration.
Convenient base class for
ReactorNettyCodec
implementations that need
to work with NIO ByteBuffers
.Abstract base class for
SubscribableChannel
implementations.Abstract base class for implementations of
SubscriptionRegistry
that
looks up information in messages but delegates to abstract methods for the
actual storage and retrieval.A subclass of
AbstractExceptionHandlerMethodResolver
that looks for
MessageExceptionHandler
-annotated methods in a given class.Assist with configuration for handler method argument resolvers.
An extension of
HandlerMethodReturnValueHandler
for handling async,
Future-like return value types that support success and error callbacks.An implementation of
DestinationResolver
that interprets a destination
name as the bean name of a MessageChannel
and looks up the bean in
the configured BeanFactory
.Event raised when a broker's availability changes.
An extension of
StompDecoder
that buffers content remaining in the input ByteBuffer after the parent
class has read all (complete) STOMP frames from it.A
MessageConverter
that supports MIME type "application/octet-stream" with the
payload converted to and from a byte[].DestinationResolver
implementation that proxies a target DestinationResolver,
caching its CachingDestinationResolverProxy.resolveDestination(java.lang.String)
results.Interface for interceptors that are able to view and/or modify the
Messages
being sent-to and/or received-from a
MessageChannel
.A registration class for customizing the configuration for a
MessageChannel
.Support for
CompletableFuture
(and as of 4.3.7 also CompletionStage
)
as a return value type.Composite
MessageCondition
that delegates to other message conditions.A
MessageConverter
that delegates to a list of registered converters
to be invoked until one of them returns a non-null result.A
StompSession
that implements
TcpConnectionHandler
in order to send and receive messages.Raised when the connection for a STOMP session is lost rather than closed.
Annotation to map the initial
ConnectionSetupPayload
and subsequent
metadata pushes onto a handler method.Resolve the content type for a message.
No-op resolver for method arguments of type
Continuation
.A default
ContentTypeResolver
that checks the
MessageHeaders.CONTENT_TYPE
header or falls back to a default value.The default
MessageHandlerMethodFactory
implementation creating an
InvocableHandlerMethod
with the necessary
HandlerMethodArgumentResolver
instances to detect and process
most of the use cases defined by
MessageMapping
.Default
MetadataExtractor
implementation that relies on
Decoder
s to deserialize the content of metadata entries.Default implementation of
ConnectionHandlingStompSession
.Implementation of
SubscriptionRegistry
that stores subscriptions
in memory and uses a PathMatcher
for matching destinations.A default implementation of
UserDestinationResolver
that relies
on a SimpUserRegistry
to find active sessions for a user.MessageCondition
to match the destination header of a Message
against one or more patterns through a RouteMatcher
.Thrown by a
DestinationResolver
when it cannot resolve a destination.Strategy for resolving a String destination name to an actual destination
of type
<D>
.Extends
MessageReceivingOperations
and adds operations for receiving messages
from a destination specified as a (resolvable) String name.Extends
MessageRequestReplyOperations
and adds operations for sending and
receiving messages to and from a destination specified as a (resolvable) String name.Extends
MessageSendingOperations
and adds operations for sending messages
to a destination specified as a (resolvable) String name.Annotation that indicates a method parameter should be bound to a template variable
in a destination template string.
RSocketServiceArgumentResolver
for a
@DestinationVariable
annotated argument.Resolve for
@DestinationVariable
method parameters.Resolve for
@DestinationVariable
method parameters.A
GenericMessage
with a Throwable
payload.An extension of
ChannelInterceptor
with callbacks to intercept the
asynchronous sending of a Message
to
a specific subscriber through an Executor
.A
SubscribableChannel
that sends messages to each of its subscribers.A simple strategy for making reconnect attempts at a fixed interval.
An implementation of
Message
with a generic payload.An extension of the
SimpleMessageConverter
that uses a
ConversionService
to convert the payload of the message
to the requested type.A messaging template that resolves destinations names to
MessageChannel
's
to send and receive messages from.Implementation of
MessageConverter
that can read and write JSON
using Google Gson.Strategy interface for resolving method parameters into argument values
in the context of a given
Message
.Strategy interface for resolving method parameters into argument values
in the context of a given
Message
.Resolves method parameters by delegating to a list of registered
HandlerMethodArgumentResolvers
.Resolves method parameters by delegating to a list of registered
HandlerMethodArgumentResolvers
.Strategy interface to handle the value returned from the invocation of a
method handling a
Message
.Handle the return value from the invocation of an annotated
Message
handling method.A HandlerMethodReturnValueHandler that wraps and delegates to others.
A HandlerMethodReturnValueHandler that wraps and delegates to others.
Annotation which indicates that a method parameter should be bound to a message header.
Generic strategy interface for mapping
MessageHeaders
to and from other
types of objects.Resolver for
@Header
arguments.Resolver for
@Header
arguments.Annotation which indicates that a method parameter should be bound to the headers of a
message.
Argument resolver for headers.
Argument resolver for headers.
A
MessageHeaderInitializer
to customize the strategy for ID and TIMESTAMP message header generation.A simpler interceptor that calls
MessageHeaderAccessor.setImmutable()
on the headers of messages passed through the preSend method.A
MessageChannel
that
maintains a list ChannelInterceptors
and allows interception of message sending.Extension of
HandlerMethod
that invokes the underlying method with
argument values resolved from the current HTTP request through a list of
HandlerMethodArgumentResolver
.Extension of
HandlerMethod
that invokes the underlying method with
argument values resolved from the current HTTP request through a list of
HandlerMethodArgumentResolver
.Implementation of
MessageConverter
that can read and write JSON
using the JSON Binding API.Implementation of
MessageConverter
that can read and write JSON
using kotlinx.serialization.Deprecated.
A Jackson 2 based
MessageConverter
implementation.Implementation of
MessageConverter
that can read and write XML using Spring's
Marshaller
and Unmarshaller
abstractions.A generic message representation with headers and body.
A registry for configuring message broker options.
Defines methods for sending messages.
Contract for mapping conditions to messages.
An exception raised by
MessageConverter
implementations.A converter to turn the payload of a
Message
from serialized form to a typed
Object and vice versa.Exception that indicates an error occurred during message delivery.
Annotation for handling exceptions thrown from message-handling methods within a
specific handler class.
Simple contract for handling a
Message
.A factory for
InvocableHandlerMethod
that is suitable to process
an incoming Message
Exception that indicates an error occurred during message handling.
Extension of the
Runnable
interface with methods to obtain the
MessageHandler
and Message
to be handled.Wrapper around
MessageHeaders
that provides extra features such as
strongly typed accessors for specific headers, the ability to leave headers
in a Message
mutable, and the option to suppress automatic generation
of id
and timestamp
headers.Callback interface for initializing a
MessageHeaderAccessor
.The headers for a
Message
.Extension of
AbstractMethodMessageHandler
for reactive, non-blocking
handling of messages via @MessageMapping
methods.ReflectiveProcessor
implementation for types annotated
with @MessageMapping
,
@SubscribeMapping
and @MessageExceptionHandler
.HandlerMethodArgumentResolver
for Message
method arguments.A contract for processing a
Message
after it has been created, either
returning a modified (effectively new) message or returning the same.Operations for receiving messages from a destination.
Operations for sending messages to and receiving the reply from a destination.
Operations for sending messages to a destination.
Represents a Spring-managed bean with cross-cutting functionality to be
applied to one or more Spring beans with annotation-based message
handling methods.
The base exception for any failures related to messaging.
RSocketServiceArgumentResolver
for metadata entries.Strategy to extract a map of value(s) from
Payload
metadata, which
could be composite metadata with multiple entries.Stores registrations of extractors for metadata entries.
Exception to be thrown when a method argument fails validation perhaps as a
result of
@Valid
style validation, or perhaps because it is required.Common exception resulting from the invocation of
HandlerMethodArgumentResolver
.Exception that indicates that a method argument has not the expected type.
MessagingException
thrown when a session is missing.SimpUserRegistry
that looks up users in a "local" user registry as
well as a set of "remote" user registries.MessageHeaderAccessor
subclass that supports storage and access of
headers from an external source such as a message broker.Decorator for an
ExecutorSubscribableChannel
that ensures messages
are processed in the order they were published to the channel.Annotation that binds a method parameter to the payload of a message.
RSocketServiceArgumentResolver
for @Payload
annotated arguments.A resolver to extract and decode the payload of a message using a
Decoder
, where the payload is expected to be a Publisher
of DataBuffer
.A resolver to extract and convert the payload of a message using a
MessageConverter
.Static utility methods to create
Payload
from DataBuffer
s
and vice versa.A
MessageChannel
from which messages may be actively received through polling.Resolver for arguments of type
Principal
, including Optional<Principal>
.Subclass of
ProtobufMessageConverter
for use with the official
"com.google.protobuf:protobuf-java-util"
library for JSON support.An
MessageConverter
that reads and writes
com.google.protobuf.Messages
using
Google Protocol Buffers.Reactive contract for handling a
Message
.Support for single-value reactive types (like
Mono
or Single
)
as a return value type.Reactor Netty based implementation of
TcpOperations
.Reactor Netty based implementation of
TcpConnection
.Simple holder for a decoding
Function
and an encoding
BiConsumer
to use with Reactor Netty.Reactor Netty based implementation of
TcpOperations
.Reactor Netty based implementation of
TcpConnection
.A STOMP over TCP client, configurable with either
ReactorNettyTcpClient
or ReactorNetty2TcpClient
.A contract to determine the frequency of reconnect attempts after connection failure.
Assist with configuration for handler method return value handlers.
Strategy to apply configuration to an
RSocketConnector
.Annotation to declare a method on an RSocket service interface as an RSocket
endpoint.
A condition to assist with mapping onto handler methods based on the RSocket
frame type.
Extension of
MessageMappingMessageHandler
for handling RSocket
requests with @ConnectMapping
and
@MessageMapping
methods.Extension of
AbstractEncoderMethodReturnValueHandler
that
handles
encoded content by wrapping data buffers
as RSocket payloads and by passing those through the RSocketPayloadReturnValueHandler.RESPONSE_HEADER
header.A thin wrapper around a sending
RSocket
with a fluent API accepting
and returning higher level Objects for input and for output, along with
methods to prepare routing and other metadata.Builder to create a requester by connecting to a server.
Spec for providing additional composite metadata entries.
Spec to declare the input for an RSocket request.
Spec to declare the expected output for an RSocket request.
Resolves arguments of type
RSocket
that can be used for making
requests to the remote peer.Container for RSocket request values extracted from an
@RSocketExchange
-annotated
method and argument values passed to it.Builder for
RSocketRequestValues
.Resolve an argument from an
@RSocketExchange
-annotated
method to one or more RSocket request values.Factory for creating a client proxy given an RSocket service interface with
@RSocketExchange
methods.Builder to create an
RSocketServiceProxyFactory
.Access to strategies for use by RSocket requester and responder components.
The builder options for creating
RSocketStrategies
.Annotation that indicates a method's return value should be converted to
a
Message
if necessary and sent to the specified destination.A
HandlerMethodReturnValueHandler
for sending to destinations specified in a
SendTo
or SendToUser
method-level annotations.Indicates the return value of a message-handling method should be sent as a
Message
to the specified destination(s)
further prepended with "/user/{username}"
where the user name
is extracted from the headers of the input message being handled.A handler for messages delegating to
@MessageMapping
and @SubscribeMapping
annotated methods.A wrapper class for access to attributes associated with a SiMP session
(e.g.
Holder class to expose SiMP attributes associated with a session (e.g.
A "simple" message broker that recognizes the message types defined in
SimpMessageType
, keeps track of subscriptions with the help of a
SubscriptionRegistry
, and sends messages to subscribers.Registration class for configuring a
SimpleBrokerMessageHandler
.A simple converter that simply unwraps the message payload as long as it matches the
expected target class.
Holds the shared logger named "org.springframework.web.SimpLogging" to use
for STOMP over WebSocket messaging when logging for
"org.springframework.messaging.simp" is off but logging for
"org.springframework.web" is on.
A base class for working with message headers in simple messaging protocols that
support basic messaging patterns.
MessageCondition
for SImple Messaging Protocols.A specialization of
MessageSendingOperations
with methods for use with
the Spring Framework support for Simple Messaging Protocols (like STOMP).A generic representation of different kinds of messages found in simple messaging
protocols like STOMP.
MessageCondition
that matches by the message type obtained via
SimpMessageHeaderAccessor.getMessageType(Map)
.An implementation of
SimpMessageSendingOperations
.Represents a session of connected user.
A
Scope
implementation exposing the attributes of a SiMP session
(e.g.Represents a subscription within a user session.
A strategy for matching subscriptions.
Represents a connected user.
A registry of currently connected users.
An extended
MessageConverter
SPI with conversion hint support.A
MessageHandler
that handles messages by
forwarding them to a STOMP broker.Contract for access to session counters.
Registration class for configuring a
StompBrokerRelayMessageHandler
.Base class for STOMP client implementations.
Represents a STOMP command.
Raised after a failure to encode or decode a STOMP message.
Decodes one or more STOMP frames contained in a
ByteBuffer
.An encoder for STOMP frames.
Contract to handle a STOMP frame.
A
MessageHeaderAccessor
to use when creating a Message
from
a decoded STOMP frame, or when encoding a Message
to a STOMP frame.Represents STOMP frame headers.
Simple delegation to StompDecoder and StompEncoder.
Represents a STOMP session with operations to send messages,
create subscriptions and receive messages on those subscriptions.
A handle to use to track receipts.
A handle to use to unsubscribe or to track a receipt.
A contract for client STOMP session lifecycle events including a callback
when the session is established and notifications of transport or message
handling failures.
Abstract adapter class for
StompSessionHandler
with mostly empty
implementation methods except for StompSessionHandlerAdapter.getPayloadType(org.springframework.messaging.simp.stomp.StompHeaders)
which returns String
as the default Object type expected for STOMP ERROR frame payloads.A
TcpConnectionHandler
for use with STOMP connections, exposing
further information about the connection.A
MessageConverter
that supports MIME type "text/plain" with the
payload converted to and from a String.A
MessageChannel
that maintains a registry of subscribers and invokes
them to handle messages sent through this channel.Annotation for mapping subscription messages onto specific handler methods based
on the destination of a subscription.
HandlerMethodReturnValueHandler
for replying directly to a
subscription.A registry of subscription by session that allows looking up subscriptions.
An extension of
HandlerMethodArgumentResolver
for implementations
that are synchronous in nature and do not block to resolve values.A registration class for customizing the properties of
ThreadPoolTaskExecutor
.A contract for sending messages and managing a TCP connection.
A contract for managing lifecycle events for a TCP connection including
the handling of incoming messages.
Contract to encode and decode a
Message
to and from a ByteBuffer
allowing a higher-level protocol (e.g.A contract for establishing TCP connections.
MessageHandler
with support for "user" destinations.A strategy for resolving a "user" destination by translating it to one or more
actual destinations one per active user session.
Contains the result from parsing a "user" destination from a source message
and translating it to target destinations (one per active user session).
MessageHandler
that handles user registry broadcasts from other
application servers and periodically broadcasts the content of the local
user registry.Common annotation value constants.
CompletableFutureReturnValueHandler