| Package | Description | 
|---|---|
| org.springframework.jms.core | 
 Core package of the JMS support. 
 | 
| 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.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.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.user | 
 Support for handling messages to "user" destinations (i.e. 
 | 
| org.springframework.web.socket.messaging | 
 WebSocket integration for Spring's messaging module. 
 | 
| Modifier and Type | Method and Description | 
|---|---|
protected MessagingException | 
JmsMessagingTemplate.convertJmsException(JmsException ex)  | 
| Modifier and Type | Method and Description | 
|---|---|
void | 
JmsMessagingTemplate.convertAndSend(Object payload)  | 
void | 
JmsMessagingTemplate.convertAndSend(Object payload,
              MessagePostProcessor postProcessor)  | 
void | 
JmsMessagingTemplate.convertAndSend(String destinationName,
              Object payload)  | 
void | 
JmsMessageOperations.convertAndSend(String destinationName,
              Object payload)
Convert the given Object to serialized form, possibly using a
  
MessageConverter,
 wrap it as a message and send it to the given destination. | 
void | 
JmsMessagingTemplate.convertAndSend(String destinationName,
              Object payload,
              Map<String,Object> headers)  | 
void | 
JmsMessageOperations.convertAndSend(String destinationName,
              Object payload,
              Map<String,Object> headers)
Convert the given Object to serialized form, possibly using a
  
MessageConverter,
 wrap it as a message with the given headers and send it to
 the given destination. | 
void | 
JmsMessagingTemplate.convertAndSend(String destinationName,
              Object payload,
              Map<String,Object> headers,
              MessagePostProcessor postProcessor)  | 
void | 
JmsMessageOperations.convertAndSend(String destinationName,
              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, apply the given post processor,
 and send the resulting message to the given destination. | 
void | 
JmsMessagingTemplate.convertAndSend(String destinationName,
              Object payload,
              MessagePostProcessor postProcessor)  | 
void | 
JmsMessageOperations.convertAndSend(String destinationName,
              Object payload,
              MessagePostProcessor postProcessor)
Convert the given Object to serialized form, possibly using a
  
MessageConverter,
 wrap it as a message, apply the given post processor, and send
 the resulting message to the given destination. | 
<T> T | 
JmsMessagingTemplate.convertSendAndReceive(String destinationName,
                     Object request,
                     Class<T> targetClass)  | 
<T> T | 
JmsMessageOperations.convertSendAndReceive(String destinationName,
                     Object request,
                     Class<T> targetClass)
Convert the given request Object to serialized form, possibly using a
  
MessageConverter, send
 it as a Message to the given destination, receive the reply and convert
 its body of the specified target class. | 
<T> T | 
JmsMessagingTemplate.convertSendAndReceive(String destinationName,
                     Object request,
                     Class<T> targetClass,
                     MessagePostProcessor requestPostProcessor)  | 
<T> T | 
JmsMessageOperations.convertSendAndReceive(String destinationName,
                     Object request,
                     Class<T> targetClass,
                     MessagePostProcessor requestPostProcessor)
Convert the given request Object to serialized form, possibly using a
  
MessageConverter,
 apply the given post processor and send the resulting Message to the
 given destination, receive the reply and convert its body of the given
 target class. | 
<T> T | 
JmsMessagingTemplate.convertSendAndReceive(String destinationName,
                     Object request,
                     Map<String,Object> headers,
                     Class<T> targetClass)  | 
<T> T | 
JmsMessageOperations.convertSendAndReceive(String destinationName,
                     Object request,
                     Map<String,Object> headers,
                     Class<T> targetClass)
Convert the given request Object to serialized form, possibly using a
  
MessageConverter, send
 it as a Message with the given headers, to the specified destination,
 receive the reply and convert its body of the specified target class. | 
<T> T | 
JmsMessageOperations.convertSendAndReceive(String destinationName,
                     Object request,
                     Map<String,Object> headers,
                     Class<T> targetClass,
                     MessagePostProcessor requestPostProcessor)
Convert the given request Object to serialized form, possibly using a
  
MessageConverter,
 wrap it as a message with the given headers, apply the given post processor
 and send the resulting Message to the specified destination, receive
 the reply and convert its body of the given target class. | 
Message<?> | 
JmsMessagingTemplate.receive(String destinationName)  | 
Message<?> | 
JmsMessageOperations.receive(String destinationName)
Receive a message from the given destination. 
 | 
<T> T | 
JmsMessagingTemplate.receiveAndConvert(String destinationName,
                 Class<T> targetClass)  | 
<T> T | 
JmsMessageOperations.receiveAndConvert(String destinationName,
                 Class<T> targetClass)
Receive a message from the given destination and convert its payload to the
 specified target class. 
 | 
void | 
JmsMessagingTemplate.send(String destinationName,
    Message<?> message)  | 
void | 
JmsMessageOperations.send(String destinationName,
    Message<?> message)
Send a message to the given destination. 
 | 
Message<?> | 
JmsMessagingTemplate.sendAndReceive(String destinationName,
              Message<?> requestMessage)  | 
Message<?> | 
JmsMessageOperations.sendAndReceive(String destinationName,
              Message<?> requestMessage)
Send a request message and receive the reply from the given destination. 
 | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
MessageDeliveryException
Exception that indicates an error occurred during message delivery. 
 | 
class  | 
MessageHandlingException
Exception that indicates an error occurred during message handling. 
 | 
| Modifier and Type | Method and Description | 
|---|---|
void | 
MessageHandler.handleMessage(Message<?> message)
Handle the given message. 
 | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
MessageConversionException
An exception raised by  
MessageConverter implementations. | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
DestinationResolutionException
Thrown by a  
DestinationResolver when it cannot resolve a destination. | 
| Modifier and Type | Method and Description | 
|---|---|
void | 
MessageSendingOperations.convertAndSend(D destination,
              Object payload)
Convert the given Object to serialized form, possibly using a
  
MessageConverter,
 wrap it as a message and send it to the given destination. | 
void | 
AbstractMessageSendingTemplate.convertAndSend(D destination,
              Object payload)  | 
void | 
MessageSendingOperations.convertAndSend(D destination,
              Object payload,
              Map<String,Object> headers)
Convert the given Object to serialized form, possibly using a
  
MessageConverter,
 wrap it as a message with the given headers and send it to
 the given destination. | 
void | 
AbstractMessageSendingTemplate.convertAndSend(D destination,
              Object payload,
              Map<String,Object> headers)  | 
void | 
MessageSendingOperations.convertAndSend(D destination,
              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, apply the given post processor,
 and send the resulting message to the given destination. | 
void | 
AbstractMessageSendingTemplate.convertAndSend(D destination,
              Object payload,
              Map<String,Object> headers,
              MessagePostProcessor postProcessor)  | 
void | 
MessageSendingOperations.convertAndSend(D destination,
              Object payload,
              MessagePostProcessor postProcessor)
Convert the given Object to serialized form, possibly using a
  
MessageConverter,
 wrap it as a message, apply the given post processor, and send
 the resulting message to the given destination. | 
void | 
AbstractMessageSendingTemplate.convertAndSend(D destination,
              Object payload,
              MessagePostProcessor postProcessor)  | 
void | 
MessageSendingOperations.convertAndSend(Object payload)
Convert the given Object to serialized form, possibly using a
  
MessageConverter,
 wrap it as a message and send it to a default destination. | 
void | 
AbstractMessageSendingTemplate.convertAndSend(Object payload)  | 
void | 
MessageSendingOperations.convertAndSend(Object payload,
              MessagePostProcessor postProcessor)
Convert the given Object to serialized form, possibly using a
  
MessageConverter,
 wrap it as a message, apply the given post processor, and send
 the resulting message to a default destination. | 
void | 
AbstractMessageSendingTemplate.convertAndSend(Object payload,
              MessagePostProcessor postProcessor)  | 
<T> void | 
DestinationResolvingMessageSendingOperations.convertAndSend(String destinationName,
              T payload)
Resolve the given destination name to a destination, convert the payload Object
 to serialized form, possibly using a
  
MessageConverter,
 wrap it as a message and send it to the resolved destination. | 
<T> void | 
DestinationResolvingMessageSendingOperations.convertAndSend(String destinationName,
              T payload,
              Map<String,Object> headers)
Resolve the given destination name to a destination, convert the payload
 Object to serialized form, possibly using a
  
MessageConverter,
 wrap it as a message with the given headers and send it to the resolved
 destination. | 
<T> void | 
DestinationResolvingMessageSendingOperations.convertAndSend(String destinationName,
              T payload,
              Map<String,Object> headers,
              MessagePostProcessor postProcessor)
Resolve the given destination name to a destination, convert the payload
 Object to serialized form, possibly using a
  
MessageConverter,
 wrap it as a message with the given headers, apply the given post processor,
 and send the resulting message to the resolved destination. | 
<T> void | 
DestinationResolvingMessageSendingOperations.convertAndSend(String destinationName,
              T payload,
              MessagePostProcessor postProcessor)
Resolve the given destination name to a destination, convert the payload
 Object to serialized form, possibly using a
  
MessageConverter,
 wrap it as a message, apply the given post processor, and send the resulting
 message to the resolved destination. | 
<T> T | 
MessageRequestReplyOperations.convertSendAndReceive(D destination,
                     Object request,
                     Class<T> targetClass)
Convert the given request Object to serialized form, possibly using a
  
MessageConverter, send
 it as a Message to the given destination, receive the reply and convert
 its body of the specified target class. | 
<T> T | 
MessageRequestReplyOperations.convertSendAndReceive(D destination,
                     Object request,
                     Class<T> targetClass,
                     MessagePostProcessor requestPostProcessor)
Convert the given request Object to serialized form, possibly using a
  
MessageConverter,
 apply the given post processor and send the resulting Message to the
 given destination, receive the reply and convert its body of the given
 target class. | 
<T> T | 
MessageRequestReplyOperations.convertSendAndReceive(D destination,
                     Object request,
                     Map<String,Object> headers,
                     Class<T> targetClass)
Convert the given request Object to serialized form, possibly using a
  
MessageConverter, send
 it as a Message with the given headers, to the specified destination,
 receive the reply and convert its body of the specified target class. | 
<T> T | 
MessageRequestReplyOperations.convertSendAndReceive(D destination,
                     Object request,
                     Map<String,Object> headers,
                     Class<T> targetClass,
                     MessagePostProcessor requestPostProcessor)
Convert the given request Object to serialized form, possibly using a
  
MessageConverter,
 wrap it as a message with the given headers, apply the given post processor
 and send the resulting Message to the specified destination, receive
 the reply and convert its body of the given target class. | 
<T> T | 
MessageRequestReplyOperations.convertSendAndReceive(Object request,
                     Class<T> targetClass)
Convert the given request Object to serialized form, possibly using a
  
MessageConverter, send
 it as a Message to a default destination, receive the reply and convert
 its body of the specified target class. | 
<T> T | 
MessageRequestReplyOperations.convertSendAndReceive(Object request,
                     Class<T> targetClass,
                     MessagePostProcessor requestPostProcessor)
Convert the given request Object to serialized form, possibly using a
  
MessageConverter,
 apply the given post processor and send the resulting Message to a
 default destination, receive the reply and convert its body of the given
 target class. | 
<T> T | 
DestinationResolvingMessageRequestReplyOperations.convertSendAndReceive(String destinationName,
                     Object request,
                     Class<T> targetClass)
Resolve the given destination name, convert the payload request Object
 to serialized form, possibly using a
  
MessageConverter,
 wrap it as a message and send it to the resolved destination, receive a reply
 and convert its body to the specified target class. | 
<T> T | 
DestinationResolvingMessageRequestReplyOperations.convertSendAndReceive(String destinationName,
                     Object request,
                     Class<T> targetClass,
                     MessagePostProcessor requestPostProcessor)
Resolve the given destination name, convert the payload request Object
 to serialized form, possibly using a
  
MessageConverter,
 wrap it as a message, apply the given post process, and send the resulting
 message to the resolved destination, then receive a reply and convert its
 body to the specified target class. | 
<T> T | 
DestinationResolvingMessageRequestReplyOperations.convertSendAndReceive(String destinationName,
                     Object request,
                     Map<String,Object> headers,
                     Class<T> targetClass)
Resolve the given destination name, convert the payload request Object
 to serialized form, possibly using a
  
MessageConverter,
 wrap it as a message with the given headers and send it to the resolved destination,
 receive a reply and convert its body to the specified target class. | 
<T> T | 
DestinationResolvingMessageRequestReplyOperations.convertSendAndReceive(String destinationName,
                     Object request,
                     Map<String,Object> headers,
                     Class<T> targetClass,
                     MessagePostProcessor requestPostProcessor)
Resolve the given destination name, convert the payload request Object
 to serialized form, possibly using a
  
MessageConverter,
 wrap it as a message with the given headers, apply the given post process,
 and send the resulting message to the resolved destination, then receive
 a reply and convert its body to the specified target class. | 
Message<?> | 
MessageReceivingOperations.receive()
Receive a message from a default destination. 
 | 
Message<?> | 
MessageReceivingOperations.receive(D destination)
Receive a message from the given destination. 
 | 
Message<?> | 
DestinationResolvingMessageReceivingOperations.receive(String destinationName)
Resolve the given destination name and receive a message from it. 
 | 
<T> T | 
MessageReceivingOperations.receiveAndConvert(Class<T> targetClass)
Receive a message from a default destination and convert its payload to the
 specified target class. 
 | 
<T> T | 
MessageReceivingOperations.receiveAndConvert(D destination,
                 Class<T> targetClass)
Receive a message from the given destination and convert its payload to the
 specified target class. 
 | 
<T> T | 
DestinationResolvingMessageReceivingOperations.receiveAndConvert(String destinationName,
                 Class<T> targetClass)
Resolve the given destination name, receive a message from it,
 convert the payload to the specified target type. 
 | 
void | 
MessageSendingOperations.send(D destination,
    Message<?> message)
Send a message to the given destination. 
 | 
void | 
MessageSendingOperations.send(Message<?> message)
Send a message to a default destination. 
 | 
void | 
DestinationResolvingMessageSendingOperations.send(String destinationName,
    Message<?> message)
Resolve the given destination name to a destination and send a message to it. 
 | 
Message<?> | 
MessageRequestReplyOperations.sendAndReceive(D destination,
              Message<?> requestMessage)
Send a request message and receive the reply from the given destination. 
 | 
Message<?> | 
MessageRequestReplyOperations.sendAndReceive(Message<?> requestMessage)
Send a request message and receive the reply from a default destination. 
 | 
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. 
 | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
MethodArgumentNotValidException
Exception to be thrown when a method argument fails validation perhaps as a
 result of  
@Valid style validation, or perhaps because it is required. | 
class  | 
MethodArgumentTypeMismatchException
Exception that indicates that a method argument has not the expected type. 
 | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
MethodArgumentResolutionException
Common exception resulting from the invocation of
  
HandlerMethodArgumentResolver. | 
| Modifier and Type | Method and Description | 
|---|---|
void | 
AbstractMethodMessageHandler.handleMessage(Message<?> message)  | 
| Modifier and Type | Method and Description | 
|---|---|
reactor.core.publisher.Mono<Void> | 
AbstractMethodMessageHandler.handleMessage(Message<?> message)  | 
| Modifier and Type | Method and Description | 
|---|---|
void | 
SimpMessageSendingOperations.convertAndSendToUser(String user,
                    String destination,
                    Object payload)
Send a message to the given user. 
 | 
void | 
SimpMessagingTemplate.convertAndSendToUser(String user,
                    String destination,
                    Object payload)  | 
void | 
SimpMessageSendingOperations.convertAndSendToUser(String user,
                    String destination,
                    Object payload,
                    Map<String,Object> headers)
Send a message to the given user. 
 | 
void | 
SimpMessagingTemplate.convertAndSendToUser(String user,
                    String destination,
                    Object payload,
                    Map<String,Object> headers)  | 
void | 
SimpMessageSendingOperations.convertAndSendToUser(String user,
                    String destination,
                    Object payload,
                    Map<String,Object> headers,
                    MessagePostProcessor postProcessor)
Send a message to the given user. 
 | 
void | 
SimpMessagingTemplate.convertAndSendToUser(String user,
                    String destination,
                    Object payload,
                    Map<String,Object> headers,
                    MessagePostProcessor postProcessor)  | 
void | 
SimpMessageSendingOperations.convertAndSendToUser(String user,
                    String destination,
                    Object payload,
                    MessagePostProcessor postProcessor)
Send a message to the given user. 
 | 
void | 
SimpMessagingTemplate.convertAndSendToUser(String user,
                    String destination,
                    Object payload,
                    MessagePostProcessor postProcessor)  | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
MissingSessionUserException
MessagingException thrown when a session is missing. | 
| Modifier and Type | Method and Description | 
|---|---|
void | 
UserRegistryMessageHandler.handleMessage(Message<?> message)  | 
void | 
UserDestinationMessageHandler.handleMessage(Message<?> message)  | 
| Modifier and Type | Method and Description | 
|---|---|
void | 
SubProtocolWebSocketHandler.handleMessage(Message<?> message)
Handle an outbound Spring Message to a WebSocket client. 
 |