org.springframework.messaging.handler.annotation.reactive

## Class MessageMappingMessageHandler

- java.lang.Object
- - org.springframework.messaging.handler.invocation.reactive.AbstractMethodMessageHandler<CompositeMessageCondition>
  - - org.springframework.messaging.handler.annotation.reactive.MessageMappingMessageHandler

- All Implemented Interfaces:
    Aware, BeanNameAware, InitializingBean, ApplicationContextAware, EmbeddedValueResolverAware, ReactiveMessageHandler
  Direct Known Subclasses:
    RSocketMessageHandler

      public class MessageMappingMessageHandler
      extends AbstractMethodMessageHandler<CompositeMessageCondition>
      implements EmbeddedValueResolverAware

  Extension of `AbstractMethodMessageHandler` for reactive, non-blocking handling of messages via `@MessageMapping` methods. By default, such methods are detected in `@Controller` Spring beans but that can be changed via `AbstractMethodMessageHandler.setHandlerPredicate(Predicate)`.

  Payloads for incoming messages are decoded through the configured `setDecoders(List)` decoders, with the help of `PayloadMethodArgumentResolver`.

  There is no default handling for return values but `AbstractMethodMessageHandler.setReturnValueHandlerConfigurer(org.springframework.messaging.handler.invocation.reactive.ReturnValueHandlerConfigurer)` can be used to configure custom return value handlers. Subclasses may also override `initReturnValueHandlers()` to set up default return value handlers.

  Since:
    5.2
  Author:
    Rossen Stoyanchev
  See Also:
    `AbstractEncoderMethodReturnValueHandler`

- - ### Field Summary

    - ### Fields inherited from class org.springframework.messaging.handler.invocation.reactive.AbstractMethodMessageHandler

      `logger`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `MessageMappingMessageHandler()`

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `afterPropertiesSet()` Invoked by the containing `BeanFactory` after it has set all bean properties and satisfied `BeanFactoryAware`, `ApplicationContextAware` etc.
    `protected AbstractExceptionHandlerMethodResolver` | `createExceptionMethodResolverFor(Class<?> beanType)` Create a concrete instance of `AbstractExceptionHandlerMethodResolver` that finds exception handling methods based on some criteria, e.g.
    `protected CompositeMessageCondition` | `getCondition(AnnotatedElement element)` Determine the mapping condition for the given annotated element.
    `ConversionService` | `getConversionService()` Return the configured ConversionService.
    `List<? extends Decoder<?>>` | `getDecoders()` Return the configured decoders.
    `protected RouteMatcher.Route` | `getDestination(Message<?> message)` Extract the destination from the given message.
    `protected Set<String>` | `getDirectLookupMappings(CompositeMessageCondition mapping)` Return String-based destinations for the given mapping, if any, that can be used to find matches with a direct lookup (i.e.
    `protected Comparator<CompositeMessageCondition>` | `getMappingComparator(Message<?> message)` Return a comparator for sorting matching mappings.
    `protected CompositeMessageCondition` | `getMappingForMethod(Method method, Class<?> handlerType)` Obtain the mapping for the given method, if any.
    `protected CompositeMessageCondition` | `getMatchingMapping(CompositeMessageCondition mapping, Message<?> message)` Check if a mapping matches the current message and return a possibly new mapping with conditions relevant to the current request.
    `RouteMatcher` | `getRouteMatcher()` Return the `RouteMatcher` used to map messages to handlers.
    `Validator` | `getValidator()` Return the configured Validator instance.
    `protected reactor.core.publisher.Mono<Void>` | `handleMatch(CompositeMessageCondition mapping, HandlerMethod handlerMethod, Message<?> message)`
    `protected List<? extends HandlerMethodArgumentResolver>` | `initArgumentResolvers()` Return the list of argument resolvers to use.
    `protected List<? extends HandlerMethodReturnValueHandler>` | `initReturnValueHandlers()` Return the list of return value handlers to use.
    `protected RouteMatcher` | `obtainRouteMatcher()` Obtain the `RouteMatcher` for actual use.
    `protected String[]` | `processDestinations(String[] destinations)` Resolve placeholders in the given destinations.
    `void` | `registerMessagingAdvice(MessagingAdviceBean bean)` Use this method to register a `MessagingAdviceBean` that may contain globally applicable `@MessageExceptionHandler` methods.
    `void` | `setConversionService(ConversionService conversionService)` Configure a `ConversionService` to use for type conversion of String based values, e.g.
    `void` | `setDecoders(List<? extends Decoder<?>> decoders)` Configure the decoders to use for incoming payloads.
    `void` | `setEmbeddedValueResolver(StringValueResolver resolver)` Set the StringValueResolver to use for resolving embedded definition values.
    `void` | `setRouteMatcher(RouteMatcher routeMatcher)` Set the `RouteMatcher` to use for mapping messages to handlers based on the route patterns they're configured with.
    `void` | `setValidator(Validator validator)` Set the Validator instance used for validating `@Payload` arguments.

    - ### Methods inherited from class org.springframework.messaging.handler.invocation.reactive.AbstractMethodMessageHandler

      `detectHandlerMethods, extendMapping, getApplicationContext, getArgumentResolverConfigurer, getArgumentResolvers, getBeanName, getDestinationLookup, getHandlerMethods, getHandlerPredicate, getReactiveAdapterRegistry, getReturnValueHandlerConfigurer, handleMessage, handleNoMatch, registerExceptionHandlerAdvice, registerHandlerMethod, setApplicationContext, setArgumentResolverConfigurer, setBeanName, setHandlerPredicate, setHandlers, setReactiveAdapterRegistry, setReturnValueHandlerConfigurer`

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Constructor Detail

    - #### MessageMappingMessageHandler

          public MessageMappingMessageHandler()

  - ### Method Detail

    - #### setDecoders

          public void setDecoders(List<? extends Decoder<?>> decoders)

      Configure the decoders to use for incoming payloads.

    - #### getDecoders

          public List<? extends Decoder<?>> getDecoders()

      Return the configured decoders.

    - #### setValidator

          public void setValidator(@Nullable
                                   Validator validator)

      Set the Validator instance used for validating `@Payload` arguments.
      See Also:
        `Validated`, `PayloadMethodArgumentResolver`

    - #### getValidator

          @Nullable
          public Validator getValidator()

      Return the configured Validator instance.

    - #### setRouteMatcher

          public void setRouteMatcher(@Nullable
                                      RouteMatcher routeMatcher)

      Set the `RouteMatcher` to use for mapping messages to handlers based on the route patterns they're configured with.

      By default, `SimpleRouteMatcher` is used, backed by `AntPathMatcher` with "." as separator. For greater efficiency consider using the `PathPatternRouteMatcher` from `spring-web` instead.

    - #### getRouteMatcher

          @Nullable
          public RouteMatcher getRouteMatcher()

      Return the `RouteMatcher` used to map messages to handlers. May be `null` before the component is initialized.

    - #### obtainRouteMatcher

          protected RouteMatcher obtainRouteMatcher()

      Obtain the `RouteMatcher` for actual use.
      Returns:
        the RouteMatcher (never `null`)
      Throws:
        `IllegalStateException` - in case of no RouteMatcher set
      Since:
        5.0

    - #### setConversionService

          public void setConversionService(ConversionService conversionService)

      Configure a `ConversionService` to use for type conversion of String based values, e.g. in destination variables or headers.

      By default `DefaultFormattingConversionService` is used.

      Parameters:
        `conversionService` - the conversion service to use

    - #### getConversionService

          public ConversionService getConversionService()

      Return the configured ConversionService.

    - #### 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`

    - #### registerMessagingAdvice

          public void registerMessagingAdvice(MessagingAdviceBean bean)

      Use this method to register a `MessagingAdviceBean` that may contain globally applicable `@MessageExceptionHandler` methods.

      Note: spring-messaging does not depend on spring-web and therefore it is not possible to explicitly support the registration of a `@ControllerAdvice` bean. You can use the following adapter code to register `@ControllerAdvice` beans here:

           ControllerAdviceBean.findAnnotatedBeans(context).forEach(bean ->
                   messageHandler.registerMessagingAdvice(new ControllerAdviceWrapper(bean));

           public class ControllerAdviceWrapper implements MessagingAdviceBean {
               private final ControllerAdviceBean delegate;
               // delegate all methods
           }

      Parameters:
        `bean` - the bean to check for `@MessageExceptionHandler` methods
      Since:
        5.3.5

    - #### afterPropertiesSet

          public void afterPropertiesSet()

      Description copied from interface: `InitializingBean`
      Invoked by the containing `BeanFactory` after it has set all bean properties and satisfied `BeanFactoryAware`, `ApplicationContextAware` etc.

      This method allows the bean instance to perform validation of its overall configuration and final initialization when all bean properties have been set.

      Specified by:
        `afterPropertiesSet` in interface `InitializingBean`
      Overrides:
        `afterPropertiesSet` in class `AbstractMethodMessageHandler<CompositeMessageCondition>`

    - #### initArgumentResolvers

          protected List<? extends HandlerMethodArgumentResolver> initArgumentResolvers()

      Description copied from class: `AbstractMethodMessageHandler`
      Return the list of argument resolvers to use.

      Subclasses should also take into account custom argument types configured via `AbstractMethodMessageHandler.setArgumentResolverConfigurer(org.springframework.messaging.handler.invocation.reactive.ArgumentResolverConfigurer)`.

      Specified by:
        `initArgumentResolvers` in class `AbstractMethodMessageHandler<CompositeMessageCondition>`

    - #### initReturnValueHandlers

          protected List<? extends HandlerMethodReturnValueHandler> initReturnValueHandlers()

      Description copied from class: `AbstractMethodMessageHandler`
      Return the list of return value handlers to use.

      Subclasses should also take into account custom return value types configured via `AbstractMethodMessageHandler.setReturnValueHandlerConfigurer(org.springframework.messaging.handler.invocation.reactive.ReturnValueHandlerConfigurer)`.

      Specified by:
        `initReturnValueHandlers` in class `AbstractMethodMessageHandler<CompositeMessageCondition>`

    - #### getMappingForMethod

          protected CompositeMessageCondition getMappingForMethod(Method method,
                                                                  Class<?> handlerType)

      Description copied from class: `AbstractMethodMessageHandler`
      Obtain the mapping for the given method, if any.
      Specified by:
        `getMappingForMethod` in class `AbstractMethodMessageHandler<CompositeMessageCondition>`
      Parameters:
        `method` - the method to check
        `handlerType` - the handler type, possibly a subtype of the method's declaring class
      Returns:
        the mapping, or `null` if the method is not mapped

    - #### getCondition

          @Nullable
          protected CompositeMessageCondition getCondition(AnnotatedElement element)

      Determine the mapping condition for the given annotated element.
      Parameters:
        `element` - the element to check
      Returns:
        the condition, or `null`

    - #### processDestinations

          protected String[] processDestinations(String[] destinations)

      Resolve placeholders in the given destinations.
      Parameters:
        `destinations` - the destinations
      Returns:
        new array with the processed destinations or the same array

    - #### getDirectLookupMappings

          protected Set<String> getDirectLookupMappings(CompositeMessageCondition mapping)

      Description copied from class: `AbstractMethodMessageHandler`
      Return String-based destinations for the given mapping, if any, that can be used to find matches with a direct lookup (i.e. non-patterns).

      Note: This is completely optional. The mapping metadata for a subclass may support neither direct lookups, nor String based destinations.

      Specified by:
        `getDirectLookupMappings` in class `AbstractMethodMessageHandler<CompositeMessageCondition>`

    - #### getDestination

          protected RouteMatcher.Route getDestination(Message<?> message)

      Description copied from class: `AbstractMethodMessageHandler`
      Extract the destination from the given message.
      Specified by:
        `getDestination` in class `AbstractMethodMessageHandler<CompositeMessageCondition>`
      See Also:
        `AbstractMethodMessageHandler.getDirectLookupMappings(Object)`

    - #### getMatchingMapping

          protected CompositeMessageCondition getMatchingMapping(CompositeMessageCondition 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<CompositeMessageCondition>`
      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 Comparator<CompositeMessageCondition> 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<CompositeMessageCondition>`
      Parameters:
        `message` - the current Message
      Returns:
        the comparator, never `null`

    - #### createExceptionMethodResolverFor

          protected AbstractExceptionHandlerMethodResolver createExceptionMethodResolverFor(Class<?> beanType)

      Description copied from class: `AbstractMethodMessageHandler`
      Create a concrete instance of `AbstractExceptionHandlerMethodResolver` that finds exception handling methods based on some criteria, e.g. based on the presence of `@MessageExceptionHandler`.
      Specified by:
        `createExceptionMethodResolverFor` in class `AbstractMethodMessageHandler<CompositeMessageCondition>`
      Parameters:
        `beanType` - the class in which an exception occurred during handling
      Returns:
        the resolver to use

    - #### handleMatch

          protected reactor.core.publisher.Mono<Void> handleMatch(CompositeMessageCondition mapping,
                                                                  HandlerMethod handlerMethod,
                                                                  Message<?> message)

      Overrides:
        `handleMatch` in class `AbstractMethodMessageHandler<CompositeMessageCondition>`