## Uses of Interface
org.springframework.messaging.Message

Packages that use Message
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.

### Uses of Message in org.springframework.messaging

Methods in org.springframework.messaging that return Message
`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
`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
Constructor and 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
`Message<?>` SimpleMessageConverter.`toMessage(Object payload, MessageHeaders headers)`
`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<?>` AbstractMessageConverter.`toMessage(Object payload, MessageHeaders headers)`
`Message<?>` CompositeMessageConverter.`toMessage(Object payload, MessageHeaders headers)`
`Message<?>` AbstractMessageConverter.`toMessage(Object payload, MessageHeaders headers, Object conversionHint)`
`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.
`Message<?>` CompositeMessageConverter.`toMessage(Object payload, MessageHeaders headers, Object conversionHint)`

Methods in org.springframework.messaging.converter with parameters of type Message
`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` ByteArrayMessageConverter.`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` MappingJackson2MessageConverter.`convertFromInternal(Message<?> message, Class<?> targetClass, Object conversionHint)`
`protected Object` StringMessageConverter.`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)`
`Object` SimpleMessageConverter.`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` GenericMessageConverter.`fromMessage(Message<?> message, Class<?> targetClass)`
`Object` AbstractMessageConverter.`fromMessage(Message<?> message, Class<?> targetClass)`
`Object` CompositeMessageConverter.`fromMessage(Message<?> message, Class<?> targetClass)`
`Object` AbstractMessageConverter.`fromMessage(Message<?> message, Class<?> targetClass, Object conversionHint)`
`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.
`Object` CompositeMessageConverter.`fromMessage(Message<?> message, Class<?> targetClass, Object conversionHint)`

Constructors in org.springframework.messaging.converter with parameters of type Message
Constructor and 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
`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 Message<?>` GenericMessagingTemplate.`doReceive(MessageChannel channel)`
`protected Message<?>` GenericMessagingTemplate.`doReceive(MessageChannel channel, long timeout)`
`protected abstract Message<?>` AbstractMessagingTemplate.`doSendAndReceive(D destination, Message<?> requestMessage)`
`protected Message<?>` GenericMessagingTemplate.`doSendAndReceive(MessageChannel channel, Message<?> requestMessage)`
`Message<?>` MessagePostProcessor.`postProcessMessage(Message<?> message)` Process the given message.
`Message<?>` MessageReceivingOperations.`receive()` Receive a message from a default destination.
`Message<?>` AbstractMessageReceivingTemplate.`receive()`
`Message<?>` MessageReceivingOperations.`receive(D destination)` Receive a message from the given destination.
`Message<?>` AbstractMessageReceivingTemplate.`receive(D destination)`
`Message<?>` DestinationResolvingMessageReceivingOperations.`receive(String destinationName)` Resolve the given destination name and receive a message from it.
`Message<?>` AbstractDestinationResolvingMessagingTemplate.`receive(String destinationName)`
`Message<?>` AbstractMessagingTemplate.`sendAndReceive(D destination, Message<?> requestMessage)`
`Message<?>` MessageRequestReplyOperations.`sendAndReceive(D destination, Message<?> requestMessage)` Send a request message and receive the reply from the given destination.
`Message<?>` AbstractMessagingTemplate.`sendAndReceive(Message<?> requestMessage)`
`Message<?>` MessageRequestReplyOperations.`sendAndReceive(Message<?> requestMessage)` Send a request message and receive the reply from a default destination.
`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<?>` AbstractDestinationResolvingMessagingTemplate.`sendAndReceive(String destinationName, Message<?> requestMessage)`

Methods in org.springframework.messaging.core with parameters of type Message
`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 void` GenericMessagingTemplate.`doSend(MessageChannel channel, Message<?> message)`
`protected void` GenericMessagingTemplate.`doSend(MessageChannel channel, Message<?> message, long timeout)`
`protected abstract Message<?>` AbstractMessagingTemplate.`doSendAndReceive(D destination, Message<?> requestMessage)`
`protected Message<?>` GenericMessagingTemplate.`doSendAndReceive(MessageChannel channel, Message<?> requestMessage)`
`Message<?>` MessagePostProcessor.`postProcessMessage(Message<?> message)` Process the given message.
`void` MessageSendingOperations.`send(D destination, Message<?> message)` Send a message to the given destination.
`void` AbstractMessageSendingTemplate.`send(D destination, Message<?> message)`
`void` MessageSendingOperations.`send(Message<?> message)` Send a message to a default destination.
`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` AbstractDestinationResolvingMessagingTemplate.`send(String destinationName, Message<?> message)`
`Message<?>` AbstractMessagingTemplate.`sendAndReceive(D destination, Message<?> requestMessage)`
`Message<?>` MessageRequestReplyOperations.`sendAndReceive(D destination, Message<?> requestMessage)` Send a request message and receive the reply from the given destination.
`Message<?>` AbstractMessagingTemplate.`sendAndReceive(Message<?> requestMessage)`
`Message<?>` MessageRequestReplyOperations.`sendAndReceive(Message<?> requestMessage)` Send a request message and receive the reply from a default destination.
`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<?>` AbstractDestinationResolvingMessagingTemplate.`sendAndReceive(String destinationName, Message<?> requestMessage)`

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

Methods in org.springframework.messaging.handler with parameters of type Message
`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.
`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.
`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)`.
`CompositeMessageCondition` CompositeMessageCondition.`getMatchingCondition(Message<?> message)`

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

Methods in org.springframework.messaging.handler.annotation.reactive with parameters of type Message
`protected org.springframework.util.RouteMatcher.Route` MessageMappingMessageHandler.`getDestination(Message<?> message)`
`protected Comparator<CompositeMessageCondition>` MessageMappingMessageHandler.`getMappingComparator(Message<?> message)`
`protected CompositeMessageCondition` MessageMappingMessageHandler.`getMatchingMapping(CompositeMessageCondition mapping, Message<?> message)`
`protected org.springframework.util.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, org.springframework.core.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` HeaderMethodArgumentResolver.`handleMissingValue(String headerName, org.springframework.core.MethodParameter parameter, Message<?> message)`
`protected void` DestinationVariableMethodArgumentResolver.`handleMissingValue(String name, org.springframework.core.MethodParameter parameter, Message<?> message)`
`reactor.core.publisher.Mono<Object>` PayloadMethodArgumentResolver.`resolveArgument(org.springframework.core.MethodParameter parameter, Message<?> message)` Decode the content of the given message payload through a compatible `Decoder`.
`reactor.core.publisher.Mono<Object>` ContinuationHandlerMethodArgumentResolver.`resolveArgument(org.springframework.core.MethodParameter parameter, Message<?> message)`
`protected abstract Object` AbstractNamedValueMethodArgumentResolver.`resolveArgumentInternal(org.springframework.core.MethodParameter parameter, Message<?> message, String name)` Resolves the given parameter type and value name into an argument value.
`protected Object` HeaderMethodArgumentResolver.`resolveArgumentInternal(org.springframework.core.MethodParameter parameter, Message<?> message, String name)`
`protected Object` DestinationVariableMethodArgumentResolver.`resolveArgumentInternal(org.springframework.core.MethodParameter parameter, Message<?> message, String name)`
`Object` AbstractNamedValueMethodArgumentResolver.`resolveArgumentValue(org.springframework.core.MethodParameter parameter, Message<?> message)`
`Object` HeadersMethodArgumentResolver.`resolveArgumentValue(org.springframework.core.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
`protected Class<?>` MessageMethodArgumentResolver.`getPayloadType(org.springframework.core.MethodParameter parameter, Message<?> message)` Resolve the target class to convert the payload to.

`protected abstract void`

AbstractNamedValueMethodArgumentResolver.`handleMissingValue(String name, org.springframework.core.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` HeaderMethodArgumentResolver.`handleMissingValue(String headerName, org.springframework.core.MethodParameter parameter, Message<?> message)`
`protected void` DestinationVariableMethodArgumentResolver.`handleMissingValue(String name, org.springframework.core.MethodParameter parameter, Message<?> message)`
`protected void` AbstractNamedValueMethodArgumentResolver.`handleResolvedValue(Object arg, String name, org.springframework.core.MethodParameter parameter, Message<?> message)` Invoked after a value is resolved.
`Object` MessageMethodArgumentResolver.`resolveArgument(org.springframework.core.MethodParameter parameter, Message<?> message)`
`Object` AbstractNamedValueMethodArgumentResolver.`resolveArgument(org.springframework.core.MethodParameter parameter, Message<?> message)`
`Object` PayloadMethodArgumentResolver.`resolveArgument(org.springframework.core.MethodParameter parameter, Message<?> message)`
`Object` HeadersMethodArgumentResolver.`resolveArgument(org.springframework.core.MethodParameter parameter, Message<?> message)`
`protected abstract Object` AbstractNamedValueMethodArgumentResolver.`resolveArgumentInternal(org.springframework.core.MethodParameter parameter, Message<?> message, String name)` Resolves the given parameter type and value name into an argument value.
`protected Object` HeaderMethodArgumentResolver.`resolveArgumentInternal(org.springframework.core.MethodParameter parameter, Message<?> message, String name)`
`protected Object` DestinationVariableMethodArgumentResolver.`resolveArgumentInternal(org.springframework.core.MethodParameter parameter, Message<?> message, String name)`
`protected Class<?>` PayloadMethodArgumentResolver.`resolveTargetClass(org.springframework.core.MethodParameter parameter, Message<?> message)` Resolve the target class to convert the payload to.
`protected void` PayloadMethodArgumentResolver.`validate(Message<?> message, org.springframework.core.MethodParameter parameter, Object target)` Validate the payload if applicable.

Constructors in org.springframework.messaging.handler.annotation.support with parameters of type Message
Constructor and Description
`MethodArgumentNotValidException(Message<?> message, org.springframework.core.MethodParameter parameter)` Create a new instance with the invalid `MethodParameter`.
`MethodArgumentNotValidException(Message<?> message, org.springframework.core.MethodParameter parameter, org.springframework.validation.BindingResult bindingResult)` Create a new instance with the invalid `MethodParameter` and a `BindingResult`.
`MethodArgumentTypeMismatchException(Message<?> message, org.springframework.core.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
`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` HandlerMethodReturnValueHandlerComposite.`handleReturnValue(Object returnValue, org.springframework.core.MethodParameter returnType, Message<?> message)`
`void` AbstractAsyncReturnValueHandler.`handleReturnValue(Object returnValue, org.springframework.core.MethodParameter returnType, Message<?> message)`
`void` HandlerMethodReturnValueHandler.`handleReturnValue(Object returnValue, org.springframework.core.MethodParameter returnType, Message<?> message)` Handle the given return value.
`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(org.springframework.core.MethodParameter parameter, Message<?> message)` Resolves a method parameter into an argument value from a given message.
`Object` HandlerMethodArgumentResolverComposite.`resolveArgument(org.springframework.core.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
Constructor and Description
`MethodArgumentResolutionException(Message<?> message, org.springframework.core.MethodParameter parameter)` Create a new instance providing the invalid `MethodParameter`.
`MethodArgumentResolutionException(Message<?> message, org.springframework.core.MethodParameter parameter, String description)` Create a new instance providing the invalid `MethodParameter` and a prepared description.
`MethodArgumentResolutionException(Message<?> message, org.springframework.core.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
`protected abstract org.springframework.util.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<org.springframework.core.io.buffer.DataBuffer> encodedContent, org.springframework.core.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(org.springframework.core.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(org.springframework.util.RouteMatcher.Route destination, Message<?> message)` Invoked when no matching handler is found.
`reactor.core.publisher.Mono<Void>` HandlerMethodReturnValueHandlerComposite.`handleReturnValue(Object returnValue, org.springframework.core.MethodParameter returnType, Message<?> message)`
`reactor.core.publisher.Mono<Void>` HandlerMethodReturnValueHandler.`handleReturnValue(Object returnValue, org.springframework.core.MethodParameter returnType, Message<?> message)` Handle the given return value.
`reactor.core.publisher.Mono<Void>` AbstractEncoderMethodReturnValueHandler.`handleReturnValue(Object returnValue, org.springframework.core.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(org.springframework.core.MethodParameter parameter, Message<?> message)` Resolves a method parameter into an argument value from a given message.
`reactor.core.publisher.Mono<Object>` HandlerMethodArgumentResolverComposite.`resolveArgument(org.springframework.core.MethodParameter parameter, Message<?> message)` Iterate over registered `HandlerMethodArgumentResolvers` and invoke the one that supports it.
`default reactor.core.publisher.Mono<Object>` SyncHandlerMethodArgumentResolver.`resolveArgument(org.springframework.core.MethodParameter parameter, Message<?> message)` Resolves a method parameter into an argument value from a given message.
`Object` SyncHandlerMethodArgumentResolver.`resolveArgumentValue(org.springframework.core.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
`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<org.springframework.core.io.buffer.DataBuffer> encodedContent, org.springframework.core.MethodParameter returnType, Message<?> message)`
`protected reactor.core.publisher.Mono<Void>` RSocketPayloadReturnValueHandler.`handleNoContent(org.springframework.core.MethodParameter returnType, Message<?> message)`
`protected void` RSocketMessageHandler.`handleNoMatch(org.springframework.util.RouteMatcher.Route destination, Message<?> message)`
`reactor.core.publisher.Mono<Object>` RSocketRequesterMethodArgumentResolver.`resolveArgument(org.springframework.core.MethodParameter parameter, Message<?> message)`

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

Methods in org.springframework.messaging.simp with parameters of type Message
`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.
`SimpMessageTypeMessageCondition` SimpMessageTypeMessageCondition.`getMatchingCondition(Message<?> message)`
`SimpMessageMappingInfo` SimpMessageMappingInfo.`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 from the payload and headers of the given Message.

Constructors in org.springframework.messaging.simp with parameters of type Message
Constructor and Description
`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
`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` SubscriptionMethodReturnValueHandler.`handleReturnValue(Object returnValue, org.springframework.core.MethodParameter returnType, Message<?> message)`
`void` SendToMethodReturnValueHandler.`handleReturnValue(Object returnValue, org.springframework.core.MethodParameter returnType, Message<?> message)`
`Object` PrincipalMethodArgumentResolver.`resolveArgument(org.springframework.core.MethodParameter parameter, Message<?> message)`

Constructors in org.springframework.messaging.simp.annotation.support with parameters of type Message
Constructor and 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
`protected abstract void` AbstractSubscriptionRegistry.`addSubscriptionInternal(String sessionId, String subscriptionId, String destination, Message<?> message)`
`protected void` DefaultSubscriptionRegistry.`addSubscriptionInternal(String sessionId, String subsId, String destination, Message<?> message)`
`org.springframework.util.MultiValueMap<String,String>` AbstractSubscriptionRegistry.`findSubscriptions(Message<?> message)`
`org.springframework.util.MultiValueMap<String,String>` SubscriptionRegistry.`findSubscriptions(Message<?> message)` Find all subscriptions that should receive the given message.
`protected abstract org.springframework.util.MultiValueMap<String,String>` AbstractSubscriptionRegistry.`findSubscriptionsInternal(String destination, Message<?> message)`
`protected org.springframework.util.MultiValueMap<String,String>` DefaultSubscriptionRegistry.`findSubscriptionsInternal(String destination, Message<?> message)`
`void` AbstractBrokerMessageHandler.`handleMessage(Message<?> message)`
`protected void` SimpleBrokerMessageHandler.`handleMessageInternal(Message<?> message)`
`protected abstract void` AbstractBrokerMessageHandler.`handleMessageInternal(Message<?> message)`
`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 subsId, Message<?> message)`
`protected void` SimpleBrokerMessageHandler.`sendMessageToSubscribers(String destination, Message<?> message)`
`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
`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[]>>` 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, org.springframework.util.MultiValueMap<String,String> partialMessageHeaders)` Decodes one or more STOMP frames from the given `buffer` and returns a list of `Messages`.
`protected List<Message<byte[]>>` StompReactorNettyCodec.`decodeInternal(ByteBuffer nioBuffer)`

Methods in org.springframework.messaging.simp.stomp with parameters of type Message
`protected MessageHeaderAccessor` StompHeaderAccessor.`createAccessor(Message<?> message)`
`byte[]` StompEncoder.`encode(Message<byte[]> message)` Encodes the given STOMP `message` into a `byte[]`.
`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
`void` UserDestinationMessageHandler.`handleMessage(Message<?> message)`
`void` UserRegistryMessageHandler.`handleMessage(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.
`UserDestinationResult` DefaultUserDestinationResolver.`resolveDestination(Message<?> message)`

### Uses of Message in org.springframework.messaging.support

Classes in org.springframework.messaging.support that implement Message
`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
`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.
`Message<?>` ChannelInterceptorAdapter.`postReceive(Message<?> message, MessageChannel channel)` Deprecated.
`default Message<?>` ChannelInterceptor.`postReceive(Message<?> message, MessageChannel channel)` Invoked immediately after a Message has been retrieved but before it is returned to the caller.
`Message<?>` ChannelInterceptorAdapter.`preSend(Message<?> message, MessageChannel channel)` Deprecated.
`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
`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.
`void` ChannelInterceptorAdapter.`afterReceiveCompletion(Message<?> message, MessageChannel channel, Exception ex)` Deprecated.
`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.
`void` ChannelInterceptorAdapter.`afterSendCompletion(Message<?> message, MessageChannel channel, boolean sent, Exception ex)` Deprecated.
`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 of 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.
`Message<?>` ChannelInterceptorAdapter.`postReceive(Message<?> message, MessageChannel channel)` Deprecated.
`default Message<?>` ChannelInterceptor.`postReceive(Message<?> message, MessageChannel channel)` Invoked immediately after a Message has been retrieved but before it is returned to the caller.
`void` ChannelInterceptorAdapter.`postSend(Message<?> message, MessageChannel channel, boolean sent)` Deprecated.
`default void` ChannelInterceptor.`postSend(Message<?> message, MessageChannel channel, boolean sent)` Invoked immediately after the send invocation.
`Message<?>` ChannelInterceptorAdapter.`preSend(Message<?> message, MessageChannel channel)` Deprecated.
`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)`
`boolean` AbstractMessageChannel.`send(Message<?> message)`
`boolean` AbstractMessageChannel.`send(Message<?> message, long timeout)`
`boolean` ExecutorSubscribableChannel.`sendInternal(Message<?> message, long timeout)`
`protected abstract boolean` AbstractMessageChannel.`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
Constructor and 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.
`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
`void` TcpConnectionHandler.`handleMessage(Message<P> message)` Handle a message received from the remote host.
`org.springframework.util.concurrent.ListenableFuture<Void>` TcpConnection.`send(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
`Collection<Message<P>>` ReactorNettyCodec.`decode(io.netty.buffer.ByteBuf inputBuffer)` Decode the input `ByteBuf` into one or more `Messages`.
`Collection<Message<P>>` AbstractNioBufferReactorNettyCodec.`decode(io.netty.buffer.ByteBuf inputBuffer)`
`protected abstract List<Message<P>>` AbstractNioBufferReactorNettyCodec.`decodeInternal(ByteBuffer nioBuffer)`

Methods in org.springframework.messaging.tcp.reactor with parameters of type Message
`void` ReactorNettyCodec.`encode(Message<P> message, io.netty.buffer.ByteBuf outputBuffer)` Encode the given `Message` to the output `ByteBuf`.
`void` AbstractNioBufferReactorNettyCodec.`encode(Message<P> message, io.netty.buffer.ByteBuf outputBuffer)`
`protected abstract ByteBuffer` AbstractNioBufferReactorNettyCodec.`encodeInternal(Message<P> message)`
`org.springframework.util.concurrent.ListenableFuture<Void>` ReactorNettyTcpConnection.`send(Message<P> message)`