## 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 and 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<?>` | JmsMessagingTemplate.`receive()`
    `Message<?>` | JmsMessageOperations.`receive(String destinationName)` Receive a message from the given destination.
    `Message<?>` | JmsMessagingTemplate.`receive(String destinationName)`
    `Message<?>` | JmsMessagingTemplate.`sendAndReceive(Message<?> requestMessage)`
    `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)`

    Methods in org.springframework.jms.core with parameters of type Message
    Modifier and Type | Method and 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` | JmsMessagingTemplate.`send(Message<?> message)`
    `void` | JmsMessageOperations.`send(String destinationName, Message<?> message)` Send a message to the given destination.
    `void` | JmsMessagingTemplate.`send(String destinationName, Message<?> message)`
    `Message<?>` | JmsMessagingTemplate.`sendAndReceive(Message<?> requestMessage)`
    `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)`

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

    Methods in org.springframework.jms.listener.adapter that return Message
    Modifier and Type | Method and 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 and 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
    Constructor and Description
    `JmsMessageHeaderAccessor(Message<?> message)`

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

    Methods in org.springframework.messaging that return Message
    Modifier and Type | Method and 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 and Description
    --- | ---
    `reactor.core.publisher.Mono<Void>` | ReactiveMessageHandler.`handleMessage(Message<?> message)` Handle the given message.
    `void` | MessageHandler.`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
    Modifier and Type | Method and Description
    --- | ---
    `Message<?>` | SimpleMessageConverter.`toMessage(Object payload, MessageHeaders headers)`
    `Message<?>` | CompositeMessageConverter.`toMessage(Object payload, MessageHeaders headers)`
    `Message<?>` | AbstractMessageConverter.`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<?>` | CompositeMessageConverter.`toMessage(Object payload, MessageHeaders headers, Object conversionHint)`
    `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.

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

    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
    Modifier and Type | Method and 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 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<?>` | AbstractDestinationResolvingMessagingTemplate.`receive(String destinationName)`
    `Message<?>` | DestinationResolvingMessageReceivingOperations.`receive(String destinationName)` Resolve the given destination name and receive a message from it.
    `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<?>` | AbstractDestinationResolvingMessagingTemplate.`sendAndReceive(String destinationName, 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.

    Methods in org.springframework.messaging.core with parameters of type Message
    Modifier and Type | Method and 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 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` | AbstractDestinationResolvingMessagingTemplate.`send(String destinationName, Message<?> message)`
    `void` | DestinationResolvingMessageSendingOperations.`send(String destinationName, Message<?> message)` Resolve the given destination name to a destination and send a message to it.
    `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<?>` | AbstractDestinationResolvingMessagingTemplate.`sendAndReceive(String destinationName, 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.

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

    Methods in org.springframework.messaging.handler with parameters of type Message
    Modifier and Type | Method and 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.
    `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.
    `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
    Modifier and Type | Method and 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 void` | HeaderMethodArgumentResolver.`handleMissingValue(String headerName, MethodParameter parameter, 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)`
    `reactor.core.publisher.Mono<Object>` | ContinuationHandlerMethodArgumentResolver.`resolveArgument(MethodParameter parameter, Message<?> message)`
    `reactor.core.publisher.Mono<Object>` | PayloadMethodArgumentResolver.`resolveArgument(MethodParameter parameter, Message<?> message)` Decode the content of the given message payload through a compatible `Decoder`.
    `protected Object` | HeaderMethodArgumentResolver.`resolveArgumentInternal(MethodParameter parameter, Message<?> message, String name)`
    `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)`
    `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 and Description
    --- | ---
    `protected Class<?>` | MessageMethodArgumentResolver.`getPayloadType(MethodParameter parameter, Message<?> message)` Resolve the target class to convert the payload to.
    `protected void` | HeaderMethodArgumentResolver.`handleMissingValue(String headerName, MethodParameter parameter, 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` | AbstractNamedValueMethodArgumentResolver.`handleResolvedValue(Object arg, String name, MethodParameter parameter, Message<?> message)` Invoked after a value is resolved.
    `Object` | MessageMethodArgumentResolver.`resolveArgument(MethodParameter parameter, Message<?> message)`
    `Object` | AbstractNamedValueMethodArgumentResolver.`resolveArgument(MethodParameter parameter, Message<?> message)`
    `Object` | HeadersMethodArgumentResolver.`resolveArgument(MethodParameter parameter, Message<?> message)`
    `Object` | PayloadMethodArgumentResolver.`resolveArgument(MethodParameter parameter, Message<?> message)`
    `protected Object` | HeaderMethodArgumentResolver.`resolveArgumentInternal(MethodParameter parameter, Message<?> message, String name)`
    `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 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
    Constructor and 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 and 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` | HandlerMethodReturnValueHandler.`handleReturnValue(Object returnValue, MethodParameter returnType, Message<?> message)` Handle the given return value.
    `void` | HandlerMethodReturnValueHandlerComposite.`handleReturnValue(Object returnValue, MethodParameter returnType, Message<?> message)`
    `void` | AbstractAsyncReturnValueHandler.`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` | HandlerMethodArgumentResolverComposite.`resolveArgument(MethodParameter parameter, Message<?> message)` Iterate over registered `HandlerMethodArgumentResolvers` and invoke the one that supports it.
    `Object` | HandlerMethodArgumentResolver.`resolveArgument(MethodParameter parameter, Message<?> message)` Resolves a method parameter into an argument value from a given message.

    Constructors in org.springframework.messaging.handler.invocation with parameters of type Message
    Constructor and 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 and 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>` | 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<Void>` | AbstractEncoderMethodReturnValueHandler.`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>` | HandlerMethodArgumentResolverComposite.`resolveArgument(MethodParameter parameter, Message<?> message)` Iterate over registered `HandlerMethodArgumentResolvers` and invoke the one that supports it.
    `reactor.core.publisher.Mono<Object>` | HandlerMethodArgumentResolver.`resolveArgument(MethodParameter parameter, Message<?> message)` Resolves a method parameter into an argument value from a given message.
    `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 and Description
    --- | ---
    `int` | RSocketFrameTypeMessageCondition.`compareTo(RSocketFrameTypeMessageCondition other, Message<?> message)`
    `static 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 and 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.
    `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
    Modifier and Type | Method and 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` | SubscriptionMethodReturnValueHandler.`handleReturnValue(Object returnValue, MethodParameter returnType, Message<?> message)`
    `void` | SendToMethodReturnValueHandler.`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
    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
    Modifier and Type | Method and 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)`
    `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)`
    `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)`
    `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 and 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`.
    `protected List<Message<byte[]>>` | StompReactorNettyCodec.`decodeInternal(ByteBuffer nioBuffer)`

    Methods in org.springframework.messaging.simp.stomp with parameters of type Message
    Modifier and Type | Method and Description
    --- | ---
    `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
    Modifier and Type | Method and Description
    --- | ---
    `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
    Modifier and Type | Class and 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 and 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.
    `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<?>` | ImmutableMessageChannelInterceptor.`preSend(Message<?> message, MessageChannel channel)`
    `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.

    Methods in org.springframework.messaging.support with parameters of type Message
    Modifier and Type | Method and 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.
    `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 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<?>` | ImmutableMessageChannelInterceptor.`preSend(Message<?> message, MessageChannel channel)`
    `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.
    `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
    Modifier and Type | Method and Description
    --- | ---
    `void` | TcpConnectionHandler.`handleMessage(Message<P> message)` Handle a message received from the remote host.
    `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
    Modifier and Type | Method and 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`.
    `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 and 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`.
    `protected abstract ByteBuffer` | AbstractNioBufferReactorNettyCodec.`encodeInternal(Message<P> message)`
    `ListenableFuture<Void>` | ReactorNettyTcpConnection.`send(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 and 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 and 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
    Constructor and Description
    `AbstractSubProtocolEvent(Object source, Message<byte[]> message)` Create a new AbstractSubProtocolEvent.
    `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)`