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 Message<?>	JmsMessagingTemplate.convertJmsMessage(Message message)
protected Message<?>	JmsMessagingTemplate.doReceive(Destination destination)
protected Message<?>	JmsMessagingTemplate.doReceive(String destinationName)
protected Message<?>	JmsMessagingTemplate.doSendAndReceive(Destination destination, Message<?> requestMessage)
protected Message<?>	JmsMessagingTemplate.doSendAndReceive(String destinationName, Message<?> requestMessage)
Message<?>	JmsMessageOperations.receive(String destinationName)	Receive a message from the given destination.
Message<?>	JmsMessagingTemplate.receive()
Message<?>	JmsMessagingTemplate.receive(String destinationName)
Message<?>	JmsMessageOperations.sendAndReceive(String destinationName, Message<?> requestMessage)	Send a request message and receive the reply from the given destination.
Message<?>	JmsMessagingTemplate.sendAndReceive(String destinationName, Message<?> requestMessage)
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 Message<?>	JmsMessagingTemplate.doSendAndReceive(Destination destination, Message<?> requestMessage)
protected 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)
Message<?>	JmsMessageOperations.sendAndReceive(String destinationName, Message<?> requestMessage)	Send a request message and receive the reply from the given destination.
Message<?>	JmsMessagingTemplate.sendAndReceive(String destinationName, Message<?> requestMessage)
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
Message<?>	MessagingException.getFailedMessage()
Message<?>	PollableChannel.receive()	Receive a message from this channel, blocking indefinitely if necessary.
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<?> undeliveredMessage, String description)
	MessageDeliveryException(Message<?> undeliveredMessage, String description, Throwable cause)
	MessageDeliveryException(Message<?> message, 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, String description)
	MessagingException(Message<?> message, String description, Throwable cause)
	MessagingException(Message<?> message, Throwable cause)

Uses of Message in org.springframework.messaging.converter

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

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

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, Class<?> targetClass)
protected boolean	MarshallingMessageConverter.canConvertFrom(Message<?> message, Class<?> targetClass)
protected Object	AbstractJsonMessageConverter.convertFromInternal(Message<?> message, Class<?> targetClass, Object conversionHint)
protected Object	AbstractMessageConverter.convertFromInternal(Message<?> message, Class<?> targetClass, Object conversionHint)	Convert the message payload from serialized form to an Object.
protected Object	ByteArrayMessageConverter.convertFromInternal(Message<?> message, Class<?> targetClass, Object conversionHint)
protected Object	MappingJackson2MessageConverter.convertFromInternal(Message<?> message, Class<?> targetClass, Object conversionHint)
protected Object	MarshallingMessageConverter.convertFromInternal(Message<?> message, Class<?> targetClass, Object conversionHint)
protected Object	ProtobufMessageConverter.convertFromInternal(Message<?> message, Class<?> targetClass, Object conversionHint)
protected Object	StringMessageConverter.convertFromInternal(Message<?> message, Class<?> targetClass, Object conversionHint)
final Object	AbstractMessageConverter.fromMessage(Message<?> message, Class<?> targetClass)
final Object	AbstractMessageConverter.fromMessage(Message<?> message, Class<?> targetClass, Object conversionHint)
Object	CompositeMessageConverter.fromMessage(Message<?> message, Class<?> targetClass)
Object	CompositeMessageConverter.fromMessage(Message<?> message, Class<?> targetClass, Object conversionHint)
Object	GenericMessageConverter.fromMessage(Message<?> message, Class<?> targetClass)
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.
Object	SimpleMessageConverter.fromMessage(Message<?> message, Class<?> targetClass)
Object	SmartMessageConverter.fromMessage(Message<?> message, Class<?> targetClass, Object conversionHint)	A variant of MessageConverter.fromMessage(Message, Class) which takes an extra conversion context as an argument, allowing to take e.g.

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

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

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, Map<String,Object> headers, 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 Message<?>	AbstractMessageReceivingTemplate.doReceive(D destination)	Actually receive a message from the given destination.
protected final Message<?>	GenericMessagingTemplate.doReceive(MessageChannel channel)
protected final Message<?>	GenericMessagingTemplate.doReceive(MessageChannel channel, long timeout)
protected abstract Message<?>	AbstractMessagingTemplate.doSendAndReceive(D destination, Message<?> requestMessage)
protected final Message<?>	GenericMessagingTemplate.doSendAndReceive(MessageChannel channel, Message<?> requestMessage)
Message<?>	MessagePostProcessor.postProcessMessage(Message<?> message)	Process the given message.
Message<?>	AbstractDestinationResolvingMessagingTemplate.receive(String destinationName)
Message<?>	AbstractMessageReceivingTemplate.receive()
Message<?>	AbstractMessageReceivingTemplate.receive(D destination)
Message<?>	DestinationResolvingMessageReceivingOperations.receive(String destinationName)	Resolve the given destination name and receive a message from it.
Message<?>	MessageReceivingOperations.receive()	Receive a message from a default destination.
Message<?>	MessageReceivingOperations.receive(D destination)	Receive a message from the given destination.
Message<?>	AbstractDestinationResolvingMessagingTemplate.sendAndReceive(String destinationName, Message<?> requestMessage)
Message<?>	AbstractMessagingTemplate.sendAndReceive(D destination, Message<?> requestMessage)
Message<?>	AbstractMessagingTemplate.sendAndReceive(Message<?> requestMessage)
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.
Message<?>	MessageRequestReplyOperations.sendAndReceive(D destination, Message<?> requestMessage)	Send a request message and receive the reply from the given destination.
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> 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 Message<?>	AbstractMessagingTemplate.doSendAndReceive(D destination, Message<?> requestMessage)
protected final 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.
Message<?>	AbstractDestinationResolvingMessagingTemplate.sendAndReceive(String destinationName, Message<?> requestMessage)
Message<?>	AbstractMessagingTemplate.sendAndReceive(D destination, Message<?> requestMessage)
Message<?>	AbstractMessagingTemplate.sendAndReceive(Message<?> requestMessage)
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.
Message<?>	MessageRequestReplyOperations.sendAndReceive(D destination, Message<?> requestMessage)	Send a request message and receive the reply from the given destination.
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.
CompositeMessageCondition	CompositeMessageCondition.getMatchingCondition(Message<?> message)
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).
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 RouteMatcher.Route	MessageMappingMessageHandler.getDestination(Message<?> message)
protected Comparator<CompositeMessageCondition>	MessageMappingMessageHandler.getMappingComparator(Message<?> message)
protected CompositeMessageCondition	MessageMappingMessageHandler.getMatchingMapping(CompositeMessageCondition mapping, Message<?> message)
protected 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 Object	AbstractNamedValueMethodArgumentResolver.resolveArgumentInternal(MethodParameter parameter, Message<?> message, String name)	Resolves the given parameter type and value name into an argument value.
protected Object	DestinationVariableMethodArgumentResolver.resolveArgumentInternal(MethodParameter parameter, Message<?> message, String name)
protected Object	HeaderMethodArgumentResolver.resolveArgumentInternal(MethodParameter parameter, Message<?> message, String name)
Object	AbstractNamedValueMethodArgumentResolver.resolveArgumentValue(MethodParameter parameter, Message<?> message)
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(Object arg, String name, MethodParameter parameter, Message<?> message)	Invoked after a value is resolved.
Object	AbstractNamedValueMethodArgumentResolver.resolveArgument(MethodParameter parameter, Message<?> message)
Object	HeadersMethodArgumentResolver.resolveArgument(MethodParameter parameter, Message<?> message)
Object	MessageMethodArgumentResolver.resolveArgument(MethodParameter parameter, Message<?> message)
Object	PayloadMethodArgumentResolver.resolveArgument(MethodParameter parameter, Message<?> message)
protected abstract Object	AbstractNamedValueMethodArgumentResolver.resolveArgumentInternal(MethodParameter parameter, Message<?> message, String name)	Resolves the given parameter type and value name into an argument value.
protected Object	DestinationVariableMethodArgumentResolver.resolveArgumentInternal(MethodParameter parameter, Message<?> message, String name)
protected 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 String	AbstractMethodMessageHandler.getDestination(Message<?> message)
protected abstract Comparator<T>	AbstractMethodMessageHandler.getMappingComparator(Message<?> message)	Return a comparator for sorting matching mappings.
protected abstract 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 Object[]	InvocableHandlerMethod.getMethodArgumentValues(Message<?> message, 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(Object returnValue, MethodParameter returnType, Message<?> message)
void	HandlerMethodReturnValueHandler.handleReturnValue(Object returnValue, MethodParameter returnType, Message<?> message)	Handle the given return value.
void	HandlerMethodReturnValueHandlerComposite.handleReturnValue(Object returnValue, MethodParameter returnType, Message<?> message)
Object	InvocableHandlerMethod.invoke(Message<?> message, 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)
Object	HandlerMethodArgumentResolver.resolveArgument(MethodParameter parameter, Message<?> message)	Resolves a method parameter into an argument value from a given message.
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, 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 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 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(RouteMatcher.Route destination, Message<?> message)	Invoked when no matching handler is found.
reactor.core.publisher.Mono<Void>	AbstractEncoderMethodReturnValueHandler.handleReturnValue(Object returnValue, MethodParameter returnType, Message<?> message)
reactor.core.publisher.Mono<Void>	HandlerMethodReturnValueHandler.handleReturnValue(Object returnValue, MethodParameter returnType, Message<?> message)	Handle the given return value.
reactor.core.publisher.Mono<Void>	HandlerMethodReturnValueHandlerComposite.handleReturnValue(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.
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 io.rsocket.frame.FrameType	RSocketFrameTypeMessageCondition.getFrameType(Message<?> message)	Find the RSocket frame type in the message headers.
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(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.
SimpMessageMappingInfo	SimpMessageMappingInfo.getMatchingCondition(Message<?> message)
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 String	SimpAnnotationMethodMessageHandler.getDestination(Message<?> message)
protected Comparator<SimpMessageMappingInfo>	SimpAnnotationMethodMessageHandler.getMappingComparator(Message<?> message)
protected SimpMessageMappingInfo	SimpAnnotationMethodMessageHandler.getMatchingMapping(SimpMessageMappingInfo mapping, Message<?> message)
protected String[]	SendToMethodReturnValueHandler.getTargetDestinations(Annotation annotation, Message<?> message, String defaultPrefix)
protected String	SendToMethodReturnValueHandler.getUserName(Message<?> message, MessageHeaders headers)
protected void	SimpAnnotationMethodMessageHandler.handleMatch(SimpMessageMappingInfo mapping, HandlerMethod handlerMethod, String lookupDestination, Message<?> message)
void	SendToMethodReturnValueHandler.handleReturnValue(Object returnValue, MethodParameter returnType, Message<?> message)
void	SubscriptionMethodReturnValueHandler.handleReturnValue(Object returnValue, MethodParameter returnType, Message<?> message)
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 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(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, 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)
UserDestinationResult	DefaultUserDestinationResolver.resolveDestination(Message<?> message)
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
Message<?>	AbstractMessageChannel.ChannelInterceptorChain.applyPostReceive(Message<?> message, MessageChannel channel)
Message<?>	AbstractMessageChannel.ChannelInterceptorChain.applyPreSend(Message<?> message, MessageChannel channel)
default 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.
Message<?>	ErrorMessage.getOriginalMessage()	Return the original message (if available) at the point in the stack where the ErrorMessage was created.
default Message<?>	ChannelInterceptor.postReceive(Message<?> message, MessageChannel channel)	Invoked immediately after a Message has been retrieved but before it is returned to the caller.
default 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, 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(Message<?> message, MessageChannel channel, 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, Exception ex)	Invoked after the completion of a send regardless of any exception that have been raised thus allowing for proper resource cleanup.
Message<?>	AbstractMessageChannel.ChannelInterceptorChain.applyPostReceive(Message<?> message, MessageChannel channel)
void	AbstractMessageChannel.ChannelInterceptorChain.applyPostSend(Message<?> message, MessageChannel channel, boolean sent)
Message<?>	AbstractMessageChannel.ChannelInterceptorChain.applyPreSend(Message<?> message, MessageChannel channel)
default 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 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> T	MessageHeaderAccessor.getAccessor(Message<?> message, 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 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 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(Message<?> message, MessageChannel channel, Exception ex)
void	AbstractMessageChannel.ChannelInterceptorChain.triggerAfterSendCompletion(Message<?> message, MessageChannel channel, boolean sent, 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(Message<?> message)	A constructor accepting the headers of an existing message to copy.
protected	NativeMessageHeaderAccessor(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.
default ListenableFuture<Void>	TcpConnection.send(Message<P> message)	Deprecated. as of 6.0, in favor of TcpConnection.sendAsync(Message)
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.
Message<byte[]>	StompSubProtocolErrorHandler.handleClientMessageProcessingError(Message<byte[]> clientMessage, Throwable ex)
Message<P>	SubProtocolErrorHandler.handleClientMessageProcessingError(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.
Message<byte[]>	StompSubProtocolErrorHandler.handleErrorMessageToClient(Message<byte[]> errorMessage)
Message<P>	SubProtocolErrorHandler.handleErrorMessageToClient(Message<P> errorMessage)	Handle errors sent from the server side to clients, e.g.
protected Message<byte[]>	StompSubProtocolErrorHandler.handleInternal(StompHeaderAccessor errorHeaderAccessor, byte[] errorPayload, Throwable cause, StompHeaderAccessor clientHeaderAccessor)

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

Modifier and Type	Method	Description
Message<byte[]>	StompSubProtocolErrorHandler.handleClientMessageProcessingError(Message<byte[]> clientMessage, Throwable ex)
Message<P>	SubProtocolErrorHandler.handleClientMessageProcessingError(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.
Message<byte[]>	StompSubProtocolErrorHandler.handleErrorMessageToClient(Message<byte[]> errorMessage)
Message<P>	SubProtocolErrorHandler.handleErrorMessageToClient(Message<P> errorMessage)	Handle errors sent from the server side to clients, e.g.
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.
String	StompSubProtocolHandler.resolveSessionId(Message<?> message)
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, Principal user)	Create a new AbstractSubProtocolEvent.
	SessionConnectedEvent(Object source, Message<byte[]> message)	Create a new SessionConnectedEvent.
	SessionConnectedEvent(Object source, Message<byte[]> message, Principal user)
	SessionConnectEvent(Object source, Message<byte[]> message)	Create a new SessionConnectEvent.
	SessionConnectEvent(Object source, Message<byte[]> message, 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, Principal user)	Create a new SessionDisconnectEvent.
	SessionSubscribeEvent(Object source, Message<byte[]> message)
	SessionSubscribeEvent(Object source, Message<byte[]> message, Principal user)
	SessionUnsubscribeEvent(Object source, Message<byte[]> message)
	SessionUnsubscribeEvent(Object source, Message<byte[]> message, Principal user)