Uses of Interface
org.springframework.messaging.Message

Packages that use Message

Package	Description
org.springframework.jms.core	Core package of the JMS support.
org.springframework.jms.listener.adapter	Message listener adapter mechanism that delegates to target listener methods, converting messages to appropriate message content types (such as String or byte array) that get passed into listener methods.
org.springframework.jms.support	This package provides generic JMS support classes, to be used by higher-level classes like JmsTemplate.
org.springframework.messaging	Support for working with messaging APIs and protocols.
org.springframework.messaging.converter	Provides support for message conversion.
org.springframework.messaging.core	Defines interfaces and implementation classes for messaging templates.
org.springframework.messaging.handler	Basic abstractions for working with message handler methods.
org.springframework.messaging.handler.annotation.reactive	Support classes for working with annotated message-handling methods with non-blocking, reactive contracts.
org.springframework.messaging.handler.annotation.support	Support classes for working with annotated message-handling methods.
org.springframework.messaging.handler.invocation	Common infrastructure for invoking message handler methods.
org.springframework.messaging.handler.invocation.reactive	Common infrastructure for invoking message handler methods with non-blocking, and reactive contracts.
org.springframework.messaging.rsocket.annotation.support	Support classes for working with annotated RSocket stream handling methods.
org.springframework.messaging.simp	Generic support for Simple Messaging Protocols including protocols such as STOMP.
org.springframework.messaging.simp.annotation.support	Support classes for handling messages from simple messaging protocols (like STOMP).
org.springframework.messaging.simp.broker	Provides a "simple" message broker implementation along with an abstract base class and other supporting types such as a registry for subscriptions.
org.springframework.messaging.simp.stomp	Generic support for simple messaging protocols (like STOMP).
org.springframework.messaging.simp.user	Support for handling messages to "user" destinations (i.e.
org.springframework.messaging.support	Provides implementations of Message along with a MessageBuilder and MessageHeaderAccessor for building and working with messages and message headers, as well as various MessageChannel implementations and channel interceptor support.
org.springframework.messaging.tcp	Contains abstractions and implementation classes for establishing TCP connections via TcpOperations, handling messages via TcpConnectionHandler, as well as sending messages via TcpConnection.
org.springframework.messaging.tcp.reactor	Contains support for TCP messaging based on Reactor.
org.springframework.web.socket.messaging	WebSocket integration for Spring's messaging module.

Uses of Message in org.springframework.jms.core

Methods in org.springframework.jms.core that return Message

Modifier and Type	Method	Description
protected @Nullable Message<?>	JmsMessagingTemplate.convertJmsMessage(@Nullable Message message)
protected @Nullable Message<?>	JmsMessagingTemplate.doReceive(Destination destination)
protected @Nullable Message<?>	JmsMessagingTemplate.doReceive(String destinationName)
protected @Nullable Message<?>	JmsMessagingTemplate.doSendAndReceive(Destination destination, Message<?> requestMessage)
protected @Nullable Message<?>	JmsMessagingTemplate.doSendAndReceive(String destinationName, Message<?> requestMessage)
@Nullable Message<?>	JmsMessageOperations.receive(String destinationName)	Receive a message from the given destination.
@Nullable Message<?>	JmsMessagingTemplate.receive()
@Nullable Message<?>	JmsMessagingTemplate.receive(String destinationName)
@Nullable Message<?>	JmsMessageOperations.sendAndReceive(String destinationName, Message<?> requestMessage)	Send a request message and receive the reply from the given destination.
@Nullable Message<?>	JmsMessagingTemplate.sendAndReceive(String destinationName, Message<?> requestMessage)
@Nullable Message<?>	JmsMessagingTemplate.sendAndReceive(Message<?> requestMessage)

Methods in org.springframework.jms.core with parameters of type Message

Modifier and Type	Method	Description
protected void	JmsMessagingTemplate.doSend(Destination destination, Message<?> message)
protected void	JmsMessagingTemplate.doSend(String destinationName, Message<?> message)
protected @Nullable Message<?>	JmsMessagingTemplate.doSendAndReceive(Destination destination, Message<?> requestMessage)
protected @Nullable Message<?>	JmsMessagingTemplate.doSendAndReceive(String destinationName, Message<?> requestMessage)
void	JmsMessageOperations.send(String destinationName, Message<?> message)	Send a message to the given destination.
void	JmsMessagingTemplate.send(String destinationName, Message<?> message)
void	JmsMessagingTemplate.send(Message<?> message)
@Nullable Message<?>	JmsMessageOperations.sendAndReceive(String destinationName, Message<?> requestMessage)	Send a request message and receive the reply from the given destination.
@Nullable Message<?>	JmsMessagingTemplate.sendAndReceive(String destinationName, Message<?> requestMessage)
@Nullable Message<?>	JmsMessagingTemplate.sendAndReceive(Message<?> requestMessage)

Uses of Message in org.springframework.jms.listener.adapter

Methods in org.springframework.jms.listener.adapter that return Message

Modifier and Type	Method	Description
protected Message<?>	MessagingMessageListenerAdapter.toMessagingMessage(Message jmsMessage)

Uses of Message in org.springframework.jms.support

Methods in org.springframework.jms.support with parameters of type Message

Modifier and Type	Method	Description
static JmsMessageHeaderAccessor	JmsMessageHeaderAccessor.wrap(Message<?> message)	Create a JmsMessageHeaderAccessor from the headers of an existing message.

Constructors in org.springframework.jms.support with parameters of type Message

Modifier	Constructor	Description
protected	JmsMessageHeaderAccessor(Message<?> message)

Uses of Message in org.springframework.messaging

Methods in org.springframework.messaging that return Message

Modifier and Type	Method	Description
@Nullable Message<?>	MessagingException.getFailedMessage()
@Nullable Message<?>	PollableChannel.receive()	Receive a message from this channel, blocking indefinitely if necessary.
@Nullable Message<?>	PollableChannel.receive(long timeout)	Receive a message from this channel, blocking until either a message is available or the specified timeout period elapses.

Methods in org.springframework.messaging with parameters of type Message

Modifier and Type	Method	Description
void	MessageHandler.handleMessage(Message<?> message)	Handle the given message.
reactor.core.publisher.Mono<Void>	ReactiveMessageHandler.handleMessage(Message<?> message)	Handle the given message.
default boolean	MessageChannel.send(Message<?> message)	Send a Message to this channel.
boolean	MessageChannel.send(Message<?> message, long timeout)	Send a message, blocking until either the message is accepted or the specified timeout period elapses.

Constructors in org.springframework.messaging with parameters of type Message

Modifier	Constructor	Description
	MessageDeliveryException(Message<?> undeliveredMessage)
	MessageDeliveryException(Message<?> message, @Nullable Throwable cause)
	MessageDeliveryException(Message<?> undeliveredMessage, String description)
	MessageDeliveryException(Message<?> undeliveredMessage, String description, @Nullable Throwable cause)
	MessageHandlingException(Message<?> failedMessage)
	MessageHandlingException(Message<?> message, String description)
	MessageHandlingException(Message<?> message, String description, Throwable cause)
	MessageHandlingException(Message<?> failedMessage, Throwable cause)
	MessagingException(Message<?> message)
	MessagingException(Message<?> message, @Nullable String description, @Nullable Throwable cause)
	MessagingException(Message<?> message, @Nullable Throwable cause)
	MessagingException(Message<?> message, String description)

Uses of Message in org.springframework.messaging.converter

Methods in org.springframework.messaging.converter that return Message

Modifier and Type	Method	Description
final @Nullable Message<?>	AbstractMessageConverter.toMessage(Object payload, @Nullable MessageHeaders headers)
final @Nullable Message<?>	AbstractMessageConverter.toMessage(Object payload, @Nullable MessageHeaders headers, @Nullable Object conversionHint)
@Nullable Message<?>	CompositeMessageConverter.toMessage(Object payload, @Nullable MessageHeaders headers)
@Nullable Message<?>	CompositeMessageConverter.toMessage(Object payload, @Nullable MessageHeaders headers, @Nullable Object conversionHint)
@Nullable Message<?>	MessageConverter.toMessage(Object payload, @Nullable MessageHeaders headers)	Create a Message whose payload is the result of converting the given payload Object to serialized form.
Message<?>	SimpleMessageConverter.toMessage(Object payload, @Nullable MessageHeaders headers)
@Nullable Message<?>	SmartMessageConverter.toMessage(Object payload, @Nullable MessageHeaders headers, @Nullable Object conversionHint)	A variant of MessageConverter.toMessage(Object, MessageHeaders) which takes an extra conversion context as an argument, allowing to take, for example, annotations on a return type into account.

Methods in org.springframework.messaging.converter with parameters of type Message

Modifier and Type	Method	Description
protected boolean	AbstractMessageConverter.canConvertFrom(Message<?> message, Class<?> targetClass)
protected boolean	MappingJackson2MessageConverter.canConvertFrom(Message<?> message, @Nullable Class<?> targetClass)
protected boolean	MarshallingMessageConverter.canConvertFrom(Message<?> message, Class<?> targetClass)
protected @Nullable Object	AbstractJsonMessageConverter.convertFromInternal(Message<?> message, Class<?> targetClass, @Nullable Object conversionHint)
protected @Nullable Object	AbstractMessageConverter.convertFromInternal(Message<?> message, Class<?> targetClass, @Nullable Object conversionHint)	Convert the message payload from serialized form to an Object.
protected @Nullable Object	ByteArrayMessageConverter.convertFromInternal(Message<?> message, @Nullable Class<?> targetClass, @Nullable Object conversionHint)
protected @Nullable Object	MappingJackson2MessageConverter.convertFromInternal(Message<?> message, Class<?> targetClass, @Nullable Object conversionHint)
protected @Nullable Object	MarshallingMessageConverter.convertFromInternal(Message<?> message, Class<?> targetClass, @Nullable Object conversionHint)
protected Object	ProtobufMessageConverter.convertFromInternal(Message<?> message, Class<?> targetClass, @Nullable Object conversionHint)
protected Object	StringMessageConverter.convertFromInternal(Message<?> message, Class<?> targetClass, @Nullable Object conversionHint)
final @Nullable Object	AbstractMessageConverter.fromMessage(Message<?> message, Class<?> targetClass)
final @Nullable Object	AbstractMessageConverter.fromMessage(Message<?> message, Class<?> targetClass, @Nullable Object conversionHint)
@Nullable Object	CompositeMessageConverter.fromMessage(Message<?> message, Class<?> targetClass)
@Nullable Object	CompositeMessageConverter.fromMessage(Message<?> message, Class<?> targetClass, @Nullable Object conversionHint)
@Nullable Object	GenericMessageConverter.fromMessage(Message<?> message, Class<?> targetClass)
@Nullable Object	MessageConverter.fromMessage(Message<?> message, Class<?> targetClass)	Convert the payload of a Message from a serialized form to a typed Object of the specified target class.
@Nullable Object	SimpleMessageConverter.fromMessage(Message<?> message, Class<?> targetClass)
@Nullable Object	SmartMessageConverter.fromMessage(Message<?> message, Class<?> targetClass, @Nullable Object conversionHint)	A variant of MessageConverter.fromMessage(Message, Class) which takes an extra conversion context as an argument, allowing to take, for example, annotations on a payload parameter into account.

Constructors in org.springframework.messaging.converter with parameters of type Message

Modifier	Constructor	Description
	MessageConversionException(Message<?> failedMessage, @Nullable String description, @Nullable Throwable cause)
	MessageConversionException(Message<?> failedMessage, String description)

Uses of Message in org.springframework.messaging.core

Methods in org.springframework.messaging.core that return Message

Modifier and Type	Method	Description
protected Message<?>	AbstractMessageSendingTemplate.doConvert(Object payload, @Nullable Map<String,Object> headers, @Nullable MessagePostProcessor postProcessor)	Convert the given Object to serialized form, possibly using a MessageConverter, wrap it as a message with the given headers and apply the given post processor.
protected abstract @Nullable Message<?>	AbstractMessageReceivingTemplate.doReceive(D destination)	Actually receive a message from the given destination.
protected final @Nullable Message<?>	GenericMessagingTemplate.doReceive(MessageChannel channel)
protected final @Nullable Message<?>	GenericMessagingTemplate.doReceive(MessageChannel channel, long timeout)
protected abstract @Nullable Message<?>	AbstractMessagingTemplate.doSendAndReceive(D destination, Message<?> requestMessage)
protected final @Nullable Message<?>	GenericMessagingTemplate.doSendAndReceive(MessageChannel channel, Message<?> requestMessage)
Message<?>	MessagePostProcessor.postProcessMessage(Message<?> message)	Process the given message.
@Nullable Message<?>	AbstractDestinationResolvingMessagingTemplate.receive(String destinationName)
@Nullable Message<?>	AbstractMessageReceivingTemplate.receive()
@Nullable Message<?>	AbstractMessageReceivingTemplate.receive(D destination)
@Nullable Message<?>	DestinationResolvingMessageReceivingOperations.receive(String destinationName)	Resolve the given destination name and receive a message from it.
@Nullable Message<?>	MessageReceivingOperations.receive()	Receive a message from a default destination.
@Nullable Message<?>	MessageReceivingOperations.receive(D destination)	Receive a message from the given destination.
@Nullable Message<?>	AbstractDestinationResolvingMessagingTemplate.sendAndReceive(String destinationName, Message<?> requestMessage)
@Nullable Message<?>	AbstractMessagingTemplate.sendAndReceive(D destination, Message<?> requestMessage)
@Nullable Message<?>	AbstractMessagingTemplate.sendAndReceive(Message<?> requestMessage)
@Nullable Message<?>	DestinationResolvingMessageRequestReplyOperations.sendAndReceive(String destinationName, Message<?> requestMessage)	Resolve the given destination name to a destination and send the given message, receive a reply and return it.
@Nullable Message<?>	MessageRequestReplyOperations.sendAndReceive(D destination, Message<?> requestMessage)	Send a request message and receive the reply from the given destination.
@Nullable Message<?>	MessageRequestReplyOperations.sendAndReceive(Message<?> requestMessage)	Send a request message and receive the reply from a default destination.

Methods in org.springframework.messaging.core with parameters of type Message

Modifier and Type	Method	Description
protected <T> @Nullable T	AbstractMessageReceivingTemplate.doConvert(Message<?> message, Class<T> targetClass)	Convert from the given message to the given target class.
protected abstract void	AbstractMessageSendingTemplate.doSend(D destination, Message<?> message)
protected final void	GenericMessagingTemplate.doSend(MessageChannel channel, Message<?> message)
protected final void	GenericMessagingTemplate.doSend(MessageChannel channel, Message<?> message, long timeout)
protected abstract @Nullable Message<?>	AbstractMessagingTemplate.doSendAndReceive(D destination, Message<?> requestMessage)
protected final @Nullable Message<?>	GenericMessagingTemplate.doSendAndReceive(MessageChannel channel, Message<?> requestMessage)
Message<?>	MessagePostProcessor.postProcessMessage(Message<?> message)	Process the given message.
void	AbstractDestinationResolvingMessagingTemplate.send(String destinationName, Message<?> message)
void	AbstractMessageSendingTemplate.send(D destination, Message<?> message)
void	AbstractMessageSendingTemplate.send(Message<?> message)
void	DestinationResolvingMessageSendingOperations.send(String destinationName, Message<?> message)	Resolve the given destination name to a destination and send a message to it.
void	MessageSendingOperations.send(D destination, Message<?> message)	Send a message to the given destination.
void	MessageSendingOperations.send(Message<?> message)	Send a message to a default destination.
@Nullable Message<?>	AbstractDestinationResolvingMessagingTemplate.sendAndReceive(String destinationName, Message<?> requestMessage)
@Nullable Message<?>	AbstractMessagingTemplate.sendAndReceive(D destination, Message<?> requestMessage)
@Nullable Message<?>	AbstractMessagingTemplate.sendAndReceive(Message<?> requestMessage)
@Nullable Message<?>	DestinationResolvingMessageRequestReplyOperations.sendAndReceive(String destinationName, Message<?> requestMessage)	Resolve the given destination name to a destination and send the given message, receive a reply and return it.
@Nullable Message<?>	MessageRequestReplyOperations.sendAndReceive(D destination, Message<?> requestMessage)	Send a request message and receive the reply from the given destination.
@Nullable Message<?>	MessageRequestReplyOperations.sendAndReceive(Message<?> requestMessage)	Send a request message and receive the reply from a default destination.

Uses of Message in org.springframework.messaging.handler

Methods in org.springframework.messaging.handler with parameters of type Message

Modifier and Type	Method	Description
int	CompositeMessageCondition.compareTo(CompositeMessageCondition other, Message<?> message)
int	DestinationPatternsMessageCondition.compareTo(DestinationPatternsMessageCondition other, Message<?> message)	Compare the two conditions based on the destination patterns they contain.
int	MessageCondition.compareTo(T other, Message<?> message)	Compare this condition to another in the context of a specific message.
@Nullable CompositeMessageCondition	CompositeMessageCondition.getMatchingCondition(Message<?> message)
@Nullable DestinationPatternsMessageCondition	DestinationPatternsMessageCondition.getMatchingCondition(Message<?> message)	Check if any of the patterns match the given Message destination and return an instance that is guaranteed to contain matching patterns, sorted via PathMatcher.getPatternComparator(String).
@Nullable T	MessageCondition.getMatchingCondition(Message<?> message)	Check if this condition matches the given Message and returns a potentially new condition with content tailored to the current message.

Uses of Message in org.springframework.messaging.handler.annotation.reactive

Methods in org.springframework.messaging.handler.annotation.reactive with parameters of type Message

Modifier and Type	Method	Description
protected @Nullable RouteMatcher.Route	MessageMappingMessageHandler.getDestination(Message<?> message)
protected Comparator<CompositeMessageCondition>	MessageMappingMessageHandler.getMappingComparator(Message<?> message)
protected @Nullable CompositeMessageCondition	MessageMappingMessageHandler.getMatchingMapping(CompositeMessageCondition mapping, Message<?> message)
protected @Nullable MimeType	PayloadMethodArgumentResolver.getMimeType(Message<?> message)	Return the mime type for the content.
protected reactor.core.publisher.Mono<Void>	MessageMappingMessageHandler.handleMatch(CompositeMessageCondition mapping, HandlerMethod handlerMethod, Message<?> message)
protected abstract void	AbstractNamedValueMethodArgumentResolver.handleMissingValue(String name, MethodParameter parameter, Message<?> message)	Invoked when a value is required, but AbstractNamedValueMethodArgumentResolver.resolveArgumentInternal(org.springframework.core.MethodParameter, org.springframework.messaging.Message<?>, java.lang.String) returned null and there is no default value.
protected void	DestinationVariableMethodArgumentResolver.handleMissingValue(String name, MethodParameter parameter, Message<?> message)
protected void	HeaderMethodArgumentResolver.handleMissingValue(String headerName, MethodParameter parameter, Message<?> message)
reactor.core.publisher.Mono<Object>	ContinuationHandlerMethodArgumentResolver.resolveArgument(MethodParameter parameter, Message<?> message)
final reactor.core.publisher.Mono<Object>	PayloadMethodArgumentResolver.resolveArgument(MethodParameter parameter, Message<?> message)	Decode the content of the given message payload through a compatible Decoder.
protected abstract @Nullable Object	AbstractNamedValueMethodArgumentResolver.resolveArgumentInternal(MethodParameter parameter, Message<?> message, String name)	Resolves the given parameter type and value name into an argument value.
protected @Nullable Object	DestinationVariableMethodArgumentResolver.resolveArgumentInternal(MethodParameter parameter, Message<?> message, String name)
protected @Nullable Object	HeaderMethodArgumentResolver.resolveArgumentInternal(MethodParameter parameter, Message<?> message, String name)
@Nullable Object	AbstractNamedValueMethodArgumentResolver.resolveArgumentValue(MethodParameter parameter, Message<?> message)
@Nullable Object	HeadersMethodArgumentResolver.resolveArgumentValue(MethodParameter parameter, Message<?> message)

Uses of Message in org.springframework.messaging.handler.annotation.support

Methods in org.springframework.messaging.handler.annotation.support with parameters of type Message

Modifier and Type	Method	Description
protected Class<?>	MessageMethodArgumentResolver.getPayloadType(MethodParameter parameter, Message<?> message)	Resolve the target class to convert the payload to.
protected abstract void	AbstractNamedValueMethodArgumentResolver.handleMissingValue(String name, MethodParameter parameter, Message<?> message)	Invoked when a value is required, but AbstractNamedValueMethodArgumentResolver.resolveArgumentInternal(org.springframework.core.MethodParameter, org.springframework.messaging.Message<?>, java.lang.String) returned null and there is no default value.
protected void	DestinationVariableMethodArgumentResolver.handleMissingValue(String name, MethodParameter parameter, Message<?> message)
protected void	HeaderMethodArgumentResolver.handleMissingValue(String headerName, MethodParameter parameter, Message<?> message)
protected void	AbstractNamedValueMethodArgumentResolver.handleResolvedValue(@Nullable Object arg, String name, MethodParameter parameter, Message<?> message)	Invoked after a value is resolved.
@Nullable Object	AbstractNamedValueMethodArgumentResolver.resolveArgument(MethodParameter parameter, Message<?> message)
@Nullable Object	HeadersMethodArgumentResolver.resolveArgument(MethodParameter parameter, Message<?> message)
Object	MessageMethodArgumentResolver.resolveArgument(MethodParameter parameter, Message<?> message)
@Nullable Object	PayloadMethodArgumentResolver.resolveArgument(MethodParameter parameter, Message<?> message)
protected abstract @Nullable Object	AbstractNamedValueMethodArgumentResolver.resolveArgumentInternal(MethodParameter parameter, Message<?> message, String name)	Resolves the given parameter type and value name into an argument value.
protected @Nullable Object	DestinationVariableMethodArgumentResolver.resolveArgumentInternal(MethodParameter parameter, Message<?> message, String name)
protected @Nullable Object	HeaderMethodArgumentResolver.resolveArgumentInternal(MethodParameter parameter, Message<?> message, String name)
protected Class<?>	PayloadMethodArgumentResolver.resolveTargetClass(MethodParameter parameter, Message<?> message)	Resolve the target class to convert the payload to.
protected void	PayloadMethodArgumentResolver.validate(Message<?> message, MethodParameter parameter, Object target)	Validate the payload if applicable.

Constructors in org.springframework.messaging.handler.annotation.support with parameters of type Message

Modifier	Constructor	Description
	MethodArgumentNotValidException(Message<?> message, MethodParameter parameter)	Create a new instance with the invalid MethodParameter.
	MethodArgumentNotValidException(Message<?> message, MethodParameter parameter, BindingResult bindingResult)	Create a new instance with the invalid MethodParameter and a BindingResult.
	MethodArgumentTypeMismatchException(Message<?> message, MethodParameter parameter, String description)

Uses of Message in org.springframework.messaging.handler.invocation

Methods in org.springframework.messaging.handler.invocation with parameters of type Message

Modifier and Type	Method	Description
protected abstract @Nullable String	AbstractMethodMessageHandler.getDestination(Message<?> message)
protected abstract Comparator<T>	AbstractMethodMessageHandler.getMappingComparator(Message<?> message)	Return a comparator for sorting matching mappings.
protected abstract @Nullable T	AbstractMethodMessageHandler.getMatchingMapping(T mapping, Message<?> message)	Check if a mapping matches the current message and return a possibly new mapping with conditions relevant to the current request.
protected @Nullable Object[]	InvocableHandlerMethod.getMethodArgumentValues(Message<?> message, @Nullable Object... providedArgs)	Get the method argument values for the current message, checking the provided argument values and falling back to the configured argument resolvers.
protected void	AbstractMethodMessageHandler.handleMatch(T mapping, HandlerMethod handlerMethod, String lookupDestination, Message<?> message)
void	AbstractMethodMessageHandler.handleMessage(Message<?> message)
protected void	AbstractMethodMessageHandler.handleMessageInternal(Message<?> message, String lookupDestination)
protected void	AbstractMethodMessageHandler.handleNoMatch(Set<T> ts, String lookupDestination, Message<?> message)
void	AbstractAsyncReturnValueHandler.handleReturnValue(@Nullable Object returnValue, MethodParameter returnType, Message<?> message)
void	HandlerMethodReturnValueHandler.handleReturnValue(@Nullable Object returnValue, MethodParameter returnType, Message<?> message)	Handle the given return value.
void	HandlerMethodReturnValueHandlerComposite.handleReturnValue(@Nullable Object returnValue, MethodParameter returnType, Message<?> message)
@Nullable Object	InvocableHandlerMethod.invoke(Message<?> message, @Nullable Object... providedArgs)	Invoke the method after resolving its argument values in the context of the given message.
protected void	AbstractMethodMessageHandler.processHandlerMethodException(HandlerMethod handlerMethod, Exception exception, Message<?> message)
@Nullable Object	HandlerMethodArgumentResolver.resolveArgument(MethodParameter parameter, Message<?> message)	Resolves a method parameter into an argument value from a given message.
@Nullable Object	HandlerMethodArgumentResolverComposite.resolveArgument(MethodParameter parameter, Message<?> message)	Iterate over registered HandlerMethodArgumentResolvers and invoke the one that supports it.

Constructors in org.springframework.messaging.handler.invocation with parameters of type Message

Modifier	Constructor	Description
	MethodArgumentResolutionException(Message<?> message, MethodParameter parameter)	Create a new instance providing the invalid MethodParameter.
	MethodArgumentResolutionException(Message<?> message, MethodParameter parameter, String description)	Create a new instance providing the invalid MethodParameter and a prepared description.
	MethodArgumentResolutionException(Message<?> message, MethodParameter parameter, String description, @Nullable Throwable cause)	Create a new instance providing the invalid MethodParameter, prepared description, and a cause.

Uses of Message in org.springframework.messaging.handler.invocation.reactive

Methods in org.springframework.messaging.handler.invocation.reactive with parameters of type Message

Modifier and Type	Method	Description
protected abstract @Nullable RouteMatcher.Route	AbstractMethodMessageHandler.getDestination(Message<?> message)	Extract the destination from the given message.
protected abstract Comparator<T>	AbstractMethodMessageHandler.getMappingComparator(Message<?> message)	Return a comparator for sorting matching mappings.
protected abstract @Nullable T	AbstractMethodMessageHandler.getMatchingMapping(T mapping, Message<?> message)	Check if a mapping matches the current message and return a possibly new mapping with conditions relevant to the current request.
protected abstract reactor.core.publisher.Mono<Void>	AbstractEncoderMethodReturnValueHandler.handleEncodedContent(reactor.core.publisher.Flux<DataBuffer> encodedContent, MethodParameter returnType, Message<?> message)	Subclasses implement this method to handle encoded values in some way such as creating and sending messages.
protected reactor.core.publisher.Mono<Void>	AbstractMethodMessageHandler.handleMatch(T mapping, HandlerMethod handlerMethod, Message<?> message)
reactor.core.publisher.Mono<Void>	AbstractMethodMessageHandler.handleMessage(Message<?> message)
protected abstract reactor.core.publisher.Mono<Void>	AbstractEncoderMethodReturnValueHandler.handleNoContent(MethodParameter returnType, Message<?> message)	Invoked for a null return value, which could mean a void method or method returning an async type parameterized by void.
protected void	AbstractMethodMessageHandler.handleNoMatch(@Nullable RouteMatcher.Route destination, Message<?> message)	Invoked when no matching handler is found.
reactor.core.publisher.Mono<Void>	AbstractEncoderMethodReturnValueHandler.handleReturnValue(@Nullable Object returnValue, MethodParameter returnType, Message<?> message)
reactor.core.publisher.Mono<Void>	HandlerMethodReturnValueHandler.handleReturnValue(@Nullable Object returnValue, MethodParameter returnType, Message<?> message)	Handle the given return value.
reactor.core.publisher.Mono<Void>	HandlerMethodReturnValueHandlerComposite.handleReturnValue(@Nullable Object returnValue, MethodParameter returnType, Message<?> message)
reactor.core.publisher.Mono<Object>	InvocableHandlerMethod.invoke(Message<?> message, Object... providedArgs)	Invoke the method for the given exchange.
reactor.core.publisher.Mono<Object>	HandlerMethodArgumentResolver.resolveArgument(MethodParameter parameter, Message<?> message)	Resolves a method parameter into an argument value from a given message.
reactor.core.publisher.Mono<Object>	HandlerMethodArgumentResolverComposite.resolveArgument(MethodParameter parameter, Message<?> message)	Iterate over registered HandlerMethodArgumentResolvers and invoke the one that supports it.
default reactor.core.publisher.Mono<Object>	SyncHandlerMethodArgumentResolver.resolveArgument(MethodParameter parameter, Message<?> message)	Resolves a method parameter into an argument value from a given message.
@Nullable Object	SyncHandlerMethodArgumentResolver.resolveArgumentValue(MethodParameter parameter, Message<?> message)	Resolve the value for the method parameter synchronously.

Uses of Message in org.springframework.messaging.rsocket.annotation.support

Methods in org.springframework.messaging.rsocket.annotation.support with parameters of type Message

Modifier and Type	Method	Description
int	RSocketFrameTypeMessageCondition.compareTo(RSocketFrameTypeMessageCondition other, Message<?> message)
static @Nullable io.rsocket.frame.FrameType	RSocketFrameTypeMessageCondition.getFrameType(Message<?> message)	Find the RSocket frame type in the message headers.
@Nullable RSocketFrameTypeMessageCondition	RSocketFrameTypeMessageCondition.getMatchingCondition(Message<?> message)
protected reactor.core.publisher.Mono<Void>	RSocketPayloadReturnValueHandler.handleEncodedContent(reactor.core.publisher.Flux<DataBuffer> encodedContent, MethodParameter returnType, Message<?> message)
protected reactor.core.publisher.Mono<Void>	RSocketPayloadReturnValueHandler.handleNoContent(MethodParameter returnType, Message<?> message)
protected void	RSocketMessageHandler.handleNoMatch(@Nullable RouteMatcher.Route destination, Message<?> message)
reactor.core.publisher.Mono<Object>	RSocketRequesterMethodArgumentResolver.resolveArgument(MethodParameter parameter, Message<?> message)

Uses of Message in org.springframework.messaging.simp

Methods in org.springframework.messaging.simp with parameters of type Message

Modifier and Type	Method	Description
int	SimpMessageMappingInfo.compareTo(SimpMessageMappingInfo other, Message<?> message)
int	SimpMessageTypeMessageCondition.compareTo(SimpMessageTypeMessageCondition other, Message<?> message)
protected MessageHeaderAccessor	SimpMessageHeaderAccessor.createAccessor(Message<?> message)
protected void	SimpMessagingTemplate.doSend(String destination, Message<?> message)
static SimpAttributes	SimpAttributes.fromMessage(Message<?> message)	Extract the SiMP session attributes from the given message and wrap them in a SimpAttributes instance.
@Nullable SimpMessageMappingInfo	SimpMessageMappingInfo.getMatchingCondition(Message<?> message)
@Nullable SimpMessageTypeMessageCondition	SimpMessageTypeMessageCondition.getMatchingCondition(Message<?> message)
void	SimpMessagingTemplate.send(Message<?> message)	If the headers of the given message already contain a SimpMessageHeaderAccessor#DESTINATION_HEADER then the message is sent without further changes.
static void	SimpAttributesContextHolder.setAttributesFromMessage(Message<?> message)	Extract the SiMP session attributes from the given message, wrap them in a SimpAttributes instance and bind it to the current thread.
static SimpMessageHeaderAccessor	SimpMessageHeaderAccessor.wrap(Message<?> message)	Create an instance by copying the headers of a Message.

Constructors in org.springframework.messaging.simp with parameters of type Message

Modifier	Constructor	Description
protected	SimpMessageHeaderAccessor(Message<?> message)	A constructor for accessing and modifying existing message headers.

Uses of Message in org.springframework.messaging.simp.annotation.support

Methods in org.springframework.messaging.simp.annotation.support with parameters of type Message

Modifier and Type	Method	Description
protected @Nullable String	SimpAnnotationMethodMessageHandler.getDestination(Message<?> message)
protected Comparator<SimpMessageMappingInfo>	SimpAnnotationMethodMessageHandler.getMappingComparator(Message<?> message)
protected @Nullable SimpMessageMappingInfo	SimpAnnotationMethodMessageHandler.getMatchingMapping(SimpMessageMappingInfo mapping, Message<?> message)
protected String[]	SendToMethodReturnValueHandler.getTargetDestinations(@Nullable Annotation annotation, Message<?> message, String defaultPrefix)
protected @Nullable String	SendToMethodReturnValueHandler.getUserName(Message<?> message, MessageHeaders headers)
protected void	SimpAnnotationMethodMessageHandler.handleMatch(SimpMessageMappingInfo mapping, HandlerMethod handlerMethod, String lookupDestination, Message<?> message)
void	SendToMethodReturnValueHandler.handleReturnValue(@Nullable Object returnValue, MethodParameter returnType, Message<?> message)
void	SubscriptionMethodReturnValueHandler.handleReturnValue(@Nullable Object returnValue, MethodParameter returnType, Message<?> message)
@Nullable Object	PrincipalMethodArgumentResolver.resolveArgument(MethodParameter parameter, Message<?> message)

Constructors in org.springframework.messaging.simp.annotation.support with parameters of type Message

Modifier	Constructor	Description
	MissingSessionUserException(Message<?> message)

Uses of Message in org.springframework.messaging.simp.broker

Methods in org.springframework.messaging.simp.broker with parameters of type Message

Modifier and Type	Method	Description
protected abstract void	AbstractSubscriptionRegistry.addSubscriptionInternal(String sessionId, String subscriptionId, String destination, Message<?> message)
protected void	DefaultSubscriptionRegistry.addSubscriptionInternal(String sessionId, String subscriptionId, String destination, Message<?> message)
final MultiValueMap<String,String>	AbstractSubscriptionRegistry.findSubscriptions(Message<?> message)
MultiValueMap<String,String>	SubscriptionRegistry.findSubscriptions(Message<?> message)	Find all subscriptions that should receive the given message.
protected abstract MultiValueMap<String,String>	AbstractSubscriptionRegistry.findSubscriptionsInternal(String destination, Message<?> message)
protected MultiValueMap<String,String>	DefaultSubscriptionRegistry.findSubscriptionsInternal(String destination, Message<?> message)
static @Nullable Runnable	OrderedMessageChannelDecorator.getNextMessageTask(Message<?> message)	Obtain the task to release the next message, if found.
void	AbstractBrokerMessageHandler.handleMessage(Message<?> message)
protected abstract void	AbstractBrokerMessageHandler.handleMessageInternal(Message<?> message)
protected void	SimpleBrokerMessageHandler.handleMessageInternal(Message<?> message)
final void	AbstractSubscriptionRegistry.registerSubscription(Message<?> message)
void	SubscriptionRegistry.registerSubscription(Message<?> subscribeMessage)	Register a subscription represented by the given message.
protected abstract void	AbstractSubscriptionRegistry.removeSubscriptionInternal(String sessionId, String subscriptionId, Message<?> message)
protected void	DefaultSubscriptionRegistry.removeSubscriptionInternal(String sessionId, String subscriptionId, Message<?> message)
boolean	OrderedMessageChannelDecorator.send(Message<?> message)
boolean	OrderedMessageChannelDecorator.send(Message<?> message, long timeout)
protected void	SimpleBrokerMessageHandler.sendMessageToSubscribers(@Nullable String destination, Message<?> message)
final void	AbstractSubscriptionRegistry.unregisterSubscription(Message<?> message)
void	SubscriptionRegistry.unregisterSubscription(Message<?> unsubscribeMessage)	Unregister a subscription.

Uses of Message in org.springframework.messaging.simp.stomp

Methods in org.springframework.messaging.simp.stomp that return types with arguments of type Message

Modifier and Type	Method	Description
List<Message<byte[]>>	BufferingStompDecoder.decode(ByteBuffer newBuffer)	Decodes one or more STOMP frames from the given ByteBuffer into a list of Messages.
List<Message<byte[]>>	StompDecoder.decode(ByteBuffer byteBuffer)	Decodes one or more STOMP frames from the given ByteBuffer into a list of Messages.
List<Message<byte[]>>	StompDecoder.decode(ByteBuffer byteBuffer, @Nullable MultiValueMap<String,String> partialMessageHeaders)	Decodes one or more STOMP frames from the given buffer and returns a list of Messages.
List<Message<byte[]>>	StompTcpMessageCodec.decode(ByteBuffer nioBuffer)
protected List<Message<byte[]>>	StompReactorNettyCodec.decodeInternal(ByteBuffer nioBuffer)

Methods in org.springframework.messaging.simp.stomp with parameters of type Message

Modifier and Type	Method	Description
protected MessageHeaderAccessor	StompHeaderAccessor.createAccessor(Message<?> message)
byte[]	StompEncoder.encode(Message<byte[]> message)	Encodes the given STOMP message into a byte[].
ByteBuffer	StompTcpMessageCodec.encode(Message<byte[]> message)
protected ByteBuffer	StompReactorNettyCodec.encodeInternal(Message<byte[]> message)
void	DefaultStompSession.handleMessage(Message<byte[]> message)
protected void	StompBrokerRelayMessageHandler.handleMessageInternal(Message<?> message)
static StompHeaderAccessor	StompHeaderAccessor.wrap(Message<?> message)	Create an instance from the payload and headers of the given Message.

Uses of Message in org.springframework.messaging.simp.user

Methods in org.springframework.messaging.simp.user with parameters of type Message

Modifier and Type	Method	Description
void	UserDestinationMessageHandler.handleMessage(Message<?> sourceMessage)
void	UserRegistryMessageHandler.handleMessage(Message<?> message)
@Nullable UserDestinationResult	DefaultUserDestinationResolver.resolveDestination(Message<?> message)
@Nullable UserDestinationResult	UserDestinationResolver.resolveDestination(Message<?> message)	Resolve the given message with a user destination to one or more messages with actual destinations, one for each active user session.

Uses of Message in org.springframework.messaging.support

Classes in org.springframework.messaging.support that implement Message

Modifier and Type	Class	Description
class	ErrorMessage	A GenericMessage with a Throwable payload.
class	GenericMessage<T>	An implementation of Message with a generic payload.

Methods in org.springframework.messaging.support that return Message

Modifier and Type	Method	Description
@Nullable Message<?>	AbstractMessageChannel.ChannelInterceptorChain.applyPostReceive(Message<?> message, MessageChannel channel)
@Nullable Message<?>	AbstractMessageChannel.ChannelInterceptorChain.applyPreSend(Message<?> message, MessageChannel channel)
default @Nullable Message<?>	ExecutorChannelInterceptor.beforeHandle(Message<?> message, MessageChannel channel, MessageHandler handler)	Invoked inside the Runnable submitted to the Executor just before calling the target MessageHandler to handle the message.
Message<T>	MessageBuilder.build()
static <T> Message<T>	MessageBuilder.createMessage(T payload, MessageHeaders messageHeaders)	A shortcut factory method for creating a message with the given payload and MessageHeaders.
Message<?>	MessageHandlingRunnable.getMessage()	Return the Message that will be handled.
@Nullable Message<?>	ErrorMessage.getOriginalMessage()	Return the original message (if available) at the point in the stack where the ErrorMessage was created.
default @Nullable Message<?>	ChannelInterceptor.postReceive(Message<?> message, MessageChannel channel)	Invoked immediately after a Message has been retrieved but before it is returned to the caller.
default @Nullable Message<?>	ChannelInterceptor.preSend(Message<?> message, MessageChannel channel)	Invoked before the Message is actually sent to the channel.
Message<?>	ImmutableMessageChannelInterceptor.preSend(Message<?> message, MessageChannel channel)

Methods in org.springframework.messaging.support with parameters of type Message

Modifier and Type	Method	Description
default void	ExecutorChannelInterceptor.afterMessageHandled(Message<?> message, MessageChannel channel, MessageHandler handler, @Nullable Exception ex)	Invoked inside the Runnable submitted to the Executor after calling the target MessageHandler regardless of the outcome (i.e.
default void	ChannelInterceptor.afterReceiveCompletion(@Nullable Message<?> message, MessageChannel channel, @Nullable Exception ex)	Invoked after the completion of a receive regardless of any exception that have been raised thus allowing for proper resource cleanup.
default void	ChannelInterceptor.afterSendCompletion(Message<?> message, MessageChannel channel, boolean sent, @Nullable Exception ex)	Invoked after the completion of a send regardless of any exception that have been raised thus allowing for proper resource cleanup.
@Nullable Message<?>	AbstractMessageChannel.ChannelInterceptorChain.applyPostReceive(Message<?> message, MessageChannel channel)
void	AbstractMessageChannel.ChannelInterceptorChain.applyPostSend(Message<?> message, MessageChannel channel, boolean sent)
@Nullable Message<?>	AbstractMessageChannel.ChannelInterceptorChain.applyPreSend(Message<?> message, MessageChannel channel)
default @Nullable Message<?>	ExecutorChannelInterceptor.beforeHandle(Message<?> message, MessageChannel channel, MessageHandler handler)	Invoked inside the Runnable submitted to the Executor just before calling the target MessageHandler to handle the message.
protected MessageHeaderAccessor	MessageHeaderAccessor.createAccessor(Message<?> message)	Build a 'nested' accessor for the given message.
static <T> MessageBuilder<T>	MessageBuilder.fromMessage(Message<T> message)	Create a builder for a new Message instance pre-populated with all the headers copied from the provided message.
static @Nullable MessageHeaderAccessor	MessageHeaderAccessor.getAccessor(Message<?> message)	Return the original MessageHeaderAccessor used to create the headers of the given Message, or null if that's not available or if its type does not match the required type.
static <T extends MessageHeaderAccessor> @Nullable T	MessageHeaderAccessor.getAccessor(Message<?> message, @Nullable Class<T> requiredType)	Return the original MessageHeaderAccessor used to create the headers of the given Message, or null if that's not available or if its type does not match the required type.
static MessageHeaderAccessor	MessageHeaderAccessor.getMutableAccessor(Message<?> message)	Return a mutable MessageHeaderAccessor for the given message attempting to match the type of accessor used to create the message headers, or otherwise wrapping the message with a MessageHeaderAccessor instance.
default @Nullable Message<?>	ChannelInterceptor.postReceive(Message<?> message, MessageChannel channel)	Invoked immediately after a Message has been retrieved but before it is returned to the caller.
default void	ChannelInterceptor.postSend(Message<?> message, MessageChannel channel, boolean sent)	Invoked immediately after the send invocation.
default @Nullable Message<?>	ChannelInterceptor.preSend(Message<?> message, MessageChannel channel)	Invoked before the Message is actually sent to the channel.
Message<?>	ImmutableMessageChannelInterceptor.preSend(Message<?> message, MessageChannel channel)
final boolean	AbstractMessageChannel.send(Message<?> message)
final boolean	AbstractMessageChannel.send(Message<?> message, long timeout)
protected abstract boolean	AbstractMessageChannel.sendInternal(Message<?> message, long timeout)
boolean	ExecutorSubscribableChannel.sendInternal(Message<?> message, long timeout)
void	AbstractMessageChannel.ChannelInterceptorChain.triggerAfterReceiveCompletion(@Nullable Message<?> message, MessageChannel channel, @Nullable Exception ex)
void	AbstractMessageChannel.ChannelInterceptorChain.triggerAfterSendCompletion(Message<?> message, MessageChannel channel, boolean sent, @Nullable Exception ex)

Constructors in org.springframework.messaging.support with parameters of type Message

Modifier	Constructor	Description
	ErrorMessage(Throwable payload, Map<String,Object> headers, Message<?> originalMessage)	Create a new message with the given payload, headers and original message.
	ErrorMessage(Throwable payload, Message<?> originalMessage)	Create a new message with the given payload and original message.
	ErrorMessage(Throwable payload, MessageHeaders headers, Message<?> originalMessage)	Create a new message with the payload, MessageHeaders and original message.
	MessageHeaderAccessor(@Nullable Message<?> message)	A constructor accepting the headers of an existing message to copy.
protected	NativeMessageHeaderAccessor(@Nullable Message<?> message)	Protected constructor that copies headers from another message.

Uses of Message in org.springframework.messaging.tcp

Methods in org.springframework.messaging.tcp with parameters of type Message

Modifier and Type	Method	Description
void	TcpConnectionHandler.handleMessage(Message<P> message)	Handle a message received from the remote host.
CompletableFuture<Void>	TcpConnection.sendAsync(Message<P> message)	Send the given message.

Uses of Message in org.springframework.messaging.tcp.reactor

Methods in org.springframework.messaging.tcp.reactor that return types with arguments of type Message

Modifier and Type	Method	Description
Collection<Message<P>>	AbstractNioBufferReactorNettyCodec.decode(io.netty.buffer.ByteBuf inputBuffer)
Collection<Message<P>>	ReactorNettyCodec.decode(io.netty.buffer.ByteBuf inputBuffer)	Decode the input ByteBuf into one or more Messages.
List<Message<P>>	TcpMessageCodec.decode(ByteBuffer buffer)	Decode the input ByteBuffer into one or more Messages.
protected abstract List<Message<P>>	AbstractNioBufferReactorNettyCodec.decodeInternal(ByteBuffer nioBuffer)

Methods in org.springframework.messaging.tcp.reactor with parameters of type Message

Modifier and Type	Method	Description
void	AbstractNioBufferReactorNettyCodec.encode(Message<P> message, io.netty.buffer.ByteBuf outputBuffer)
void	ReactorNettyCodec.encode(Message<P> message, io.netty.buffer.ByteBuf outputBuffer)	Encode the given Message to the output ByteBuf.
ByteBuffer	TcpMessageCodec.encode(Message<P> message)	Encode the given Message to the output ByteBuffer.
protected abstract ByteBuffer	AbstractNioBufferReactorNettyCodec.encodeInternal(Message<P> message)
CompletableFuture<Void>	ReactorNetty2TcpConnection.sendAsync(Message<P> message)
CompletableFuture<Void>	ReactorNettyTcpConnection.sendAsync(Message<P> message)

Uses of Message in org.springframework.web.socket.messaging

Methods in org.springframework.web.socket.messaging that return Message

Modifier and Type	Method	Description
Message<byte[]>	AbstractSubProtocolEvent.getMessage()	Return the Message associated with the event.
@Nullable Message<byte[]>	StompSubProtocolErrorHandler.handleClientMessageProcessingError(@Nullable Message<byte[]> clientMessage, Throwable ex)
@Nullable Message<P>	SubProtocolErrorHandler.handleClientMessageProcessingError(@Nullable Message<P> clientMessage, Throwable ex)	Handle errors thrown while processing client messages providing an opportunity to prepare the error message or to prevent one from being sent.
@Nullable Message<byte[]>	StompSubProtocolErrorHandler.handleErrorMessageToClient(Message<byte[]> errorMessage)
@Nullable Message<P>	SubProtocolErrorHandler.handleErrorMessageToClient(Message<P> errorMessage)	Handle errors sent from the server side to clients, for example, errors from the "broke relay" because connectivity failed or the external broker sent an error message, etc.
protected Message<byte[]>	StompSubProtocolErrorHandler.handleInternal(StompHeaderAccessor errorHeaderAccessor, byte[] errorPayload, @Nullable Throwable cause, @Nullable StompHeaderAccessor clientHeaderAccessor)

Methods in org.springframework.web.socket.messaging with parameters of type Message

Modifier and Type	Method	Description
@Nullable Message<byte[]>	StompSubProtocolErrorHandler.handleClientMessageProcessingError(@Nullable Message<byte[]> clientMessage, Throwable ex)
@Nullable Message<P>	SubProtocolErrorHandler.handleClientMessageProcessingError(@Nullable Message<P> clientMessage, Throwable ex)	Handle errors thrown while processing client messages providing an opportunity to prepare the error message or to prevent one from being sent.
@Nullable Message<byte[]>	StompSubProtocolErrorHandler.handleErrorMessageToClient(Message<byte[]> errorMessage)
@Nullable Message<P>	SubProtocolErrorHandler.handleErrorMessageToClient(Message<P> errorMessage)	Handle errors sent from the server side to clients, for example, errors from the "broke relay" because connectivity failed or the external broker sent an error message, etc.
void	SubProtocolWebSocketHandler.handleMessage(Message<?> message)	Handle an outbound Spring Message to a WebSocket client.
void	StompSubProtocolHandler.handleMessageToClient(WebSocketSession session, Message<?> message)	Handle STOMP messages going back out to WebSocket clients.
void	SubProtocolHandler.handleMessageToClient(WebSocketSession session, Message<?> message)	Handle the given Message to the client associated with the given WebSocket session.
@Nullable String	StompSubProtocolHandler.resolveSessionId(Message<?> message)
@Nullable String	SubProtocolHandler.resolveSessionId(Message<?> message)	Resolve the session id from the given message or return null.
protected StompHeaderAccessor	StompSubProtocolHandler.toMutableAccessor(StompHeaderAccessor headerAccessor, Message<?> message)

Constructors in org.springframework.web.socket.messaging with parameters of type Message

Modifier	Constructor	Description
protected	AbstractSubProtocolEvent(Object source, Message<byte[]> message)	Create a new AbstractSubProtocolEvent.
protected	AbstractSubProtocolEvent(Object source, Message<byte[]> message, @Nullable Principal user)	Create a new AbstractSubProtocolEvent.
	SessionConnectedEvent(Object source, Message<byte[]> message)	Create a new SessionConnectedEvent.
	SessionConnectedEvent(Object source, Message<byte[]> message, @Nullable Principal user)
	SessionConnectEvent(Object source, Message<byte[]> message)	Create a new SessionConnectEvent.
	SessionConnectEvent(Object source, Message<byte[]> message, @Nullable Principal user)
	SessionDisconnectEvent(Object source, Message<byte[]> message, String sessionId, CloseStatus closeStatus)	Create a new SessionDisconnectEvent.
	SessionDisconnectEvent(Object source, Message<byte[]> message, String sessionId, CloseStatus closeStatus, @Nullable Principal user)	Create a new SessionDisconnectEvent.
	SessionSubscribeEvent(Object source, Message<byte[]> message)
	SessionSubscribeEvent(Object source, Message<byte[]> message, @Nullable Principal user)
	SessionUnsubscribeEvent(Object source, Message<byte[]> message)
	SessionUnsubscribeEvent(Object source, Message<byte[]> message, @Nullable Principal user)