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 Encoders.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
Decoders 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 MessageException 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 DataBuffers
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