SimpAnnotationMethodMessageHandler

java.lang.Object
- org.springframework.messaging.handler.invocation.AbstractMethodMessageHandler<SimpMessageMappingInfo>
- - org.springframework.messaging.simp.annotation.support.SimpAnnotationMethodMessageHandler

All Implemented Interfaces:

Aware, InitializingBean, ApplicationContextAware, EmbeddedValueResolverAware, Lifecycle, Phased, SmartLifecycle, MessageHandler

Direct Known Subclasses:

WebSocketAnnotationMethodMessageHandler
```
public class SimpAnnotationMethodMessageHandler
extends AbstractMethodMessageHandler<SimpMessageMappingInfo>
implements EmbeddedValueResolverAware, SmartLifecycle
```
A handler for messages delegating to @MessageMapping and @SubscribeMapping annotated methods.
Supports Ant-style path patterns with template variables.

Since:

4.0

Author:

Rossen Stoyanchev, Brian Clozel, Juergen Hoeller

Field Summary

Fields
Modifier and Type	Field and Description
`private SimpMessageSendingOperations`	`brokerTemplate`
`private SubscribableChannel`	`clientInboundChannel`
`private SimpMessageSendingOperations`	`clientMessagingTemplate`
`private static boolean`	`completableFuturePresent`
`private ConversionService`	`conversionService`
`private MessageHeaderInitializer`	`headerInitializer`
`private java.lang.Object`	`lifecycleMonitor`
`private MessageConverter`	`messageConverter`
`private PathMatcher`	`pathMatcher`
`private boolean`	`running`
`private boolean`	`slashPathSeparator`
`private Validator`	`validator`
`private StringValueResolver`	`valueResolver`

Fields inherited from class org.springframework.messaging.handler.invocation.AbstractMethodMessageHandler
logger

Constructor Summary

Constructors
Constructor and Description
`SimpAnnotationMethodMessageHandler(SubscribableChannel clientInboundChannel, MessageChannel clientOutboundChannel, SimpMessageSendingOperations brokerTemplate)` Create an instance of SimpAnnotationMethodMessageHandler with the given message channels and broker messaging template.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`private static java.util.Collection<java.lang.String>`	`appendSlashes(java.util.Collection<java.lang.String> prefixes)`
`protected AbstractExceptionHandlerMethodResolver`	`createExceptionHandlerMethodResolverFor(java.lang.Class<?> beanType)`
`private SimpMessageMappingInfo`	`createMessageMappingCondition(java.lang.String[] destinations)`
`private SimpMessageMappingInfo`	`createSubscribeMappingCondition(java.lang.String[] destinations)`
`ConversionService`	`getConversionService()` Return the configured `ConversionService`.
`protected java.lang.String`	`getDestination(Message<?> message)`
`protected java.util.Set<java.lang.String>`	`getDirectLookupDestinations(SimpMessageMappingInfo mapping)` Return destinations contained in the mapping that are not patterns and are therefore suitable for direct lookups.
`MessageHeaderInitializer`	`getHeaderInitializer()` Return the configured header initializer.
`protected java.lang.String`	`getLookupDestination(java.lang.String destination)` Check whether the given destination (of an incoming message) matches to one of the configured destination prefixes and if so return the remaining portion of the destination after the matched prefix.
`protected java.util.Comparator<SimpMessageMappingInfo>`	`getMappingComparator(Message<?> message)` Return a comparator for sorting matching mappings.
`protected SimpMessageMappingInfo`	`getMappingForMethod(java.lang.reflect.Method method, java.lang.Class<?> handlerType)` Provide the mapping for a handler method.
`protected SimpMessageMappingInfo`	`getMatchingMapping(SimpMessageMappingInfo mapping, Message<?> message)` Check if a mapping matches the current message and return a possibly new mapping with conditions relevant to the current request.
`MessageConverter`	`getMessageConverter()` Return the configured `MessageConverter`.
`PathMatcher`	`getPathMatcher()` Return the PathMatcher implementation to use for matching destinations.
`int`	`getPhase()` Return the phase value of this object.
`Validator`	`getValidator()` Return the configured Validator instance.
`protected void`	`handleMatch(SimpMessageMappingInfo mapping, HandlerMethod handlerMethod, java.lang.String lookupDestination, Message<?> message)`
`protected java.util.List<HandlerMethodArgumentResolver>`	`initArgumentResolvers()` Return the list of argument resolvers to use.
`protected java.util.List<? extends HandlerMethodReturnValueHandler>`	`initReturnValueHandlers()` Return the list of return value handlers to use.
`boolean`	`isAutoStartup()` Returns `true` if this `Lifecycle` component should get started automatically by the container at the time that the containing `ApplicationContext` gets refreshed.
`protected boolean`	`isHandler(java.lang.Class<?> beanType)` Whether the given bean type should be introspected for messaging handling methods.
`boolean`	`isRunning()` Check whether this component is currently running.
`protected java.lang.String[]`	`resolveEmbeddedValuesInDestinations(java.lang.String[] destinations)` Resolve placeholder values in the given array of destinations.
`void`	`setConversionService(ConversionService conversionService)` Configure a `ConversionService` to use when resolving method arguments, for example message header values.
`void`	`setDestinationPrefixes(java.util.Collection<java.lang.String> prefixes)` When this property is configured only messages to destinations matching one of the configured prefixes are eligible for handling.
`void`	`setEmbeddedValueResolver(StringValueResolver resolver)` Set the StringValueResolver to use for resolving embedded definition values.
`void`	`setHeaderInitializer(MessageHeaderInitializer headerInitializer)` Configure a `MessageHeaderInitializer` to pass on to `HandlerMethodReturnValueHandler`s that send messages from controller return values.
`void`	`setMessageConverter(MessageConverter converter)` Configure a `MessageConverter` to use to convert the payload of a message from its serialized form with a specific MIME type to an Object matching the target method parameter.
`void`	`setPathMatcher(PathMatcher pathMatcher)` Set the PathMatcher implementation to use for matching destinations against configured destination patterns.
`void`	`setValidator(Validator validator)` Set the Validator instance used for validating @Payload arguments
`void`	`start()` Start this component.
`void`	`stop()` Stop this component, typically in a synchronous fashion, such that the component is fully stopped upon return of this method.
`void`	`stop(java.lang.Runnable callback)` Indicates that a Lifecycle component must stop if it is currently running.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

- Field Detail
  - completableFuturePresent
```
private static final boolean completableFuturePresent
```
  - clientInboundChannel
```
private final SubscribableChannel clientInboundChannel
```
  - clientMessagingTemplate
```
private final SimpMessageSendingOperations clientMessagingTemplate
```
  - brokerTemplate
```
private final SimpMessageSendingOperations brokerTemplate
```
  - messageConverter
```
private MessageConverter messageConverter
```
  - conversionService
```
private ConversionService conversionService
```
  - pathMatcher
```
private PathMatcher pathMatcher
```
  - slashPathSeparator
```
private boolean slashPathSeparator
```
  - validator
```
private Validator validator
```
  - valueResolver
```
private StringValueResolver valueResolver
```
  - headerInitializer
```
private MessageHeaderInitializer headerInitializer
```
  - lifecycleMonitor
```
private final java.lang.Object lifecycleMonitor
```
  - running
```
private volatile boolean running
```
- Constructor Detail
  - SimpAnnotationMethodMessageHandler
```
public SimpAnnotationMethodMessageHandler(SubscribableChannel clientInboundChannel,
                                          MessageChannel clientOutboundChannel,
                                          SimpMessageSendingOperations brokerTemplate)
```
    Create an instance of SimpAnnotationMethodMessageHandler with the given message channels and broker messaging template.
    
    Parameters:
    
    clientInboundChannel - the channel for receiving messages from clients (e.g. WebSocket clients)
    
    clientOutboundChannel - the channel for messages to clients (e.g. WebSocket clients)
    
    brokerTemplate - a messaging template to send application messages to the broker
- Method Detail
  - setDestinationPrefixes
```
public void setDestinationPrefixes(java.util.Collection<java.lang.String> prefixes)
```
    When this property is configured only messages to destinations matching one of the configured prefixes are eligible for handling. When there is a match the prefix is removed and only the remaining part of the destination is used for method-mapping purposes.
    By default, no prefixes are configured in which case all messages are eligible for handling.
    Destination prefixes are expected to be slash-separated Strings and therefore a slash is automatically appended where missing to ensure a proper prefix-based match (i.e. matching complete segments).
    Note however that the remaining portion of a destination after the prefix may use a different separator (e.g. commonly "." in messaging) depending on the configured PathMatcher.
    
    Overrides:
    
    setDestinationPrefixes in class AbstractMethodMessageHandler<SimpMessageMappingInfo>
  - appendSlashes
```
private static java.util.Collection<java.lang.String> appendSlashes(java.util.Collection<java.lang.String> prefixes)
```
  - setMessageConverter
```
public void setMessageConverter(MessageConverter converter)
```
    Configure a MessageConverter to use to convert the payload of a message from its serialized form with a specific MIME type to an Object matching the target method parameter. The converter is also used when sending a message to the message broker.
    
    See Also:
    
    CompositeMessageConverter
  - getMessageConverter
```
public MessageConverter getMessageConverter()
```
    Return the configured MessageConverter.
  - setConversionService
```
public void setConversionService(ConversionService conversionService)
```
    Configure a ConversionService to use when resolving method arguments, for example message header values.
    By default, DefaultFormattingConversionService is used.
  - getConversionService
```
public ConversionService getConversionService()
```
    Return the configured ConversionService.
  - setPathMatcher
```
public void setPathMatcher(PathMatcher pathMatcher)
```
    Set the PathMatcher implementation to use for matching destinations against configured destination patterns.
    By default, AntPathMatcher is used.
  - getPathMatcher
```
public PathMatcher getPathMatcher()
```
    Return the PathMatcher implementation to use for matching destinations.
  - getValidator
```
public Validator getValidator()
```
    Return the configured Validator instance.
  - setValidator
```
public void setValidator(Validator validator)
```
    Set the Validator instance used for validating @Payload arguments
    
    See Also:
    
    Validated, PayloadArgumentResolver
  - setEmbeddedValueResolver
```
public void setEmbeddedValueResolver(StringValueResolver resolver)
```
    Description copied from interface: EmbeddedValueResolverAware
    
    Set the StringValueResolver to use for resolving embedded definition values.
    
    Specified by:
    
    setEmbeddedValueResolver in interface EmbeddedValueResolverAware
  - setHeaderInitializer
```
public void setHeaderInitializer(MessageHeaderInitializer headerInitializer)
```
    Configure a MessageHeaderInitializer to pass on to HandlerMethodReturnValueHandlers that send messages from controller return values.
    By default, this property is not set.
  - getHeaderInitializer
```
public MessageHeaderInitializer getHeaderInitializer()
```
    Return the configured header initializer.
  - isAutoStartup
```
public boolean isAutoStartup()
```
    Description copied from interface: SmartLifecycle
    
    Returns true if this Lifecycle component should get started automatically by the container at the time that the containing ApplicationContext gets refreshed.
    A value of false indicates that the component is intended to be started through an explicit Lifecycle.start() call instead, analogous to a plain Lifecycle implementation.
    
    Specified by:
    
    isAutoStartup in interface SmartLifecycle
    
    See Also:
    
    Lifecycle.start(), Phased.getPhase(), LifecycleProcessor.onRefresh(), ConfigurableApplicationContext.refresh()
  - getPhase
```
public int getPhase()
```
    Description copied from interface: Phased
    
    Return the phase value of this object.
    
    Specified by:
    
    getPhase in interface Phased
  - start
```
public final void start()
```
    Description copied from interface: Lifecycle
    
    Start this component.
    Should not throw an exception if the component is already running.
    In the case of a container, this will propagate the start signal to all components that apply.
    
    Specified by:
    
    start in interface Lifecycle
    
    See Also:
    
    SmartLifecycle.isAutoStartup()
  - stop
```
public final void stop()
```
    Description copied from interface: Lifecycle
    
    Stop this component, typically in a synchronous fashion, such that the component is fully stopped upon return of this method. Consider implementing SmartLifecycle and its stop(Runnable) variant when asynchronous stop behavior is necessary.
    Note that this stop notification is not guaranteed to come before destruction: On regular shutdown, Lifecycle beans will first receive a stop notification before the general destruction callbacks are being propagated; however, on hot refresh during a context's lifetime or on aborted refresh attempts, only destroy methods will be called.
    Should not throw an exception if the component isn't started yet.
    In the case of a container, this will propagate the stop signal to all components that apply.
    
    Specified by:
    
    stop in interface Lifecycle
    
    See Also:
    
    SmartLifecycle.stop(Runnable), DisposableBean.destroy()
  - stop
```
public final void stop(java.lang.Runnable callback)
```
    Description copied from interface: SmartLifecycle
    
    Indicates that a Lifecycle component must stop if it is currently running.
    The provided callback is used by the LifecycleProcessor to support an ordered, and potentially concurrent, shutdown of all components having a common shutdown order value. The callback must be executed after the SmartLifecycle component does indeed stop.
    The LifecycleProcessor will call only this variant of the stop method; i.e. Lifecycle.stop() will not be called for SmartLifecycle implementations unless explicitly delegated to within the implementation of this method.
    
    Specified by:
    
    stop in interface SmartLifecycle
    
    See Also:
    
    Lifecycle.stop(), Phased.getPhase()
  - isRunning
```
public final boolean isRunning()
```
    Description copied from interface: Lifecycle
    
    Check whether this component is currently running.
    In the case of a container, this will return true only if all components that apply are currently running.
    
    Specified by:
    
    isRunning in interface Lifecycle
    
    Returns:
    
    whether the component is currently running
  - initArgumentResolvers
```
protected java.util.List<HandlerMethodArgumentResolver> initArgumentResolvers()
```
    Description copied from class: AbstractMethodMessageHandler
    
    Return the list of argument resolvers to use. Invoked only if the resolvers have not already been set via AbstractMethodMessageHandler.setArgumentResolvers(java.util.List<org.springframework.messaging.handler.invocation.HandlerMethodArgumentResolver>).
    Subclasses should also take into account custom argument types configured via AbstractMethodMessageHandler.setCustomArgumentResolvers(java.util.List<org.springframework.messaging.handler.invocation.HandlerMethodArgumentResolver>).
    
    Specified by:
    
    initArgumentResolvers in class AbstractMethodMessageHandler<SimpMessageMappingInfo>
  - initReturnValueHandlers
```
protected java.util.List<? extends HandlerMethodReturnValueHandler> initReturnValueHandlers()
```
    Description copied from class: AbstractMethodMessageHandler
    
    Return the list of return value handlers to use. Invoked only if the return value handlers have not already been set via AbstractMethodMessageHandler.setReturnValueHandlers(java.util.List<org.springframework.messaging.handler.invocation.HandlerMethodReturnValueHandler>).
    Subclasses should also take into account custom return value types configured via AbstractMethodMessageHandler.setCustomReturnValueHandlers(java.util.List<org.springframework.messaging.handler.invocation.HandlerMethodReturnValueHandler>).
    
    Specified by:
    
    initReturnValueHandlers in class AbstractMethodMessageHandler<SimpMessageMappingInfo>
  - isHandler
```
protected boolean isHandler(java.lang.Class<?> beanType)
```
    Description copied from class: AbstractMethodMessageHandler
    
    Whether the given bean type should be introspected for messaging handling methods.
    
    Specified by:
    
    isHandler in class AbstractMethodMessageHandler<SimpMessageMappingInfo>
  - getMappingForMethod
```
protected SimpMessageMappingInfo getMappingForMethod(java.lang.reflect.Method method,
                                                     java.lang.Class<?> handlerType)
```
    Description copied from class: AbstractMethodMessageHandler
    
    Provide the mapping for a handler method.
    
    Specified by:
    
    getMappingForMethod in class AbstractMethodMessageHandler<SimpMessageMappingInfo>
    
    Parameters:
    
    method - the method to provide a mapping for
    
    handlerType - the handler type, possibly a sub-type of the method's declaring class
    
    Returns:
    
    the mapping, or null if the method is not mapped
  - createMessageMappingCondition
```
private SimpMessageMappingInfo createMessageMappingCondition(java.lang.String[] destinations)
```
  - createSubscribeMappingCondition
```
private SimpMessageMappingInfo createSubscribeMappingCondition(java.lang.String[] destinations)
```
  - resolveEmbeddedValuesInDestinations
```
protected java.lang.String[] resolveEmbeddedValuesInDestinations(java.lang.String[] destinations)
```
    Resolve placeholder values in the given array of destinations.
    
    Returns:
    
    a new array with updated destinations
    
    Since:
    
    4.2
  - getDirectLookupDestinations
```
protected java.util.Set<java.lang.String> getDirectLookupDestinations(SimpMessageMappingInfo mapping)
```
    Description copied from class: AbstractMethodMessageHandler
    
    Return destinations contained in the mapping that are not patterns and are therefore suitable for direct lookups.
    
    Specified by:
    
    getDirectLookupDestinations in class AbstractMethodMessageHandler<SimpMessageMappingInfo>
  - getDestination
```
protected java.lang.String getDestination(Message<?> message)
```
    Specified by:
    
    getDestination in class AbstractMethodMessageHandler<SimpMessageMappingInfo>
  - getLookupDestination
```
protected java.lang.String getLookupDestination(java.lang.String destination)
```
    Description copied from class: AbstractMethodMessageHandler
    
    Check whether the given destination (of an incoming message) matches to one of the configured destination prefixes and if so return the remaining portion of the destination after the matched prefix.
    If there are no matching prefixes, return null.
    If there are no destination prefixes, return the destination as is.
    
    Overrides:
    
    getLookupDestination in class AbstractMethodMessageHandler<SimpMessageMappingInfo>
  - getMatchingMapping
```
protected SimpMessageMappingInfo getMatchingMapping(SimpMessageMappingInfo mapping,
                                                    Message<?> message)
```
    Description copied from class: AbstractMethodMessageHandler
    
    Check if a mapping matches the current message and return a possibly new mapping with conditions relevant to the current request.
    
    Specified by:
    
    getMatchingMapping in class AbstractMethodMessageHandler<SimpMessageMappingInfo>
    
    Parameters:
    
    mapping - the mapping to get a match for
    
    message - the message being handled
    
    Returns:
    
    the match or null if there is no match
  - getMappingComparator
```
protected java.util.Comparator<SimpMessageMappingInfo> getMappingComparator(Message<?> message)
```
    Description copied from class: AbstractMethodMessageHandler
    
    Return a comparator for sorting matching mappings. The returned comparator should sort 'better' matches higher.
    
    Specified by:
    
    getMappingComparator in class AbstractMethodMessageHandler<SimpMessageMappingInfo>
    
    Parameters:
    
    message - the current Message
    
    Returns:
    
    the comparator, never null
  - handleMatch
```
protected void handleMatch(SimpMessageMappingInfo mapping,
                           HandlerMethod handlerMethod,
                           java.lang.String lookupDestination,
                           Message<?> message)
```
    Overrides:
    
    handleMatch in class AbstractMethodMessageHandler<SimpMessageMappingInfo>
  - createExceptionHandlerMethodResolverFor
```
protected AbstractExceptionHandlerMethodResolver createExceptionHandlerMethodResolverFor(java.lang.Class<?> beanType)
```
    Specified by:
    
    createExceptionHandlerMethodResolverFor in class AbstractMethodMessageHandler<SimpMessageMappingInfo>

Class SimpAnnotationMethodMessageHandler

Field Summary

Fields inherited from class org.springframework.messaging.handler.invocation.AbstractMethodMessageHandler

Constructor Summary

Method Summary

Methods inherited from class org.springframework.messaging.handler.invocation.AbstractMethodMessageHandler

Methods inherited from class java.lang.Object

Field Detail

completableFuturePresent

clientInboundChannel

clientMessagingTemplate

brokerTemplate

messageConverter

conversionService

pathMatcher

slashPathSeparator

validator

valueResolver

headerInitializer

lifecycleMonitor

running

Constructor Detail

SimpAnnotationMethodMessageHandler

Method Detail

setDestinationPrefixes

appendSlashes

setMessageConverter

getMessageConverter

setConversionService

getConversionService

setPathMatcher

getPathMatcher

getValidator

setValidator

setEmbeddedValueResolver

setHeaderInitializer

getHeaderInitializer

isAutoStartup

getPhase

start

stop

stop

isRunning

initArgumentResolvers

initReturnValueHandlers

isHandler

getMappingForMethod

createMessageMappingCondition

createSubscribeMappingCondition

resolveEmbeddedValuesInDestinations

getDirectLookupDestinations

getDestination

getLookupDestination

getMatchingMapping

getMappingComparator

handleMatch

createExceptionHandlerMethodResolverFor