Package org.springframework.messaging.handler.invocation

Class AbstractMethodMessageHandler<T>

java.lang.Object
org.springframework.messaging.handler.invocation.AbstractMethodMessageHandler<T>
Type Parameters:
T - the type of the Object that contains information mapping a HandlerMethod to incoming messages
All Implemented Interfaces:
org.springframework.beans.factory.Aware, org.springframework.beans.factory.InitializingBean, org.springframework.context.ApplicationContextAware, MessageHandler
Direct Known Subclasses:
SimpAnnotationMethodMessageHandler
public abstract class AbstractMethodMessageHandler<T> extends Object implements MessageHandler, org.springframework.context.ApplicationContextAware, org.springframework.beans.factory.InitializingBean
Abstract base class for HandlerMethod-based message handling. Provides most of the logic required to discover handler methods at startup, find a matching handler method at runtime for a given message and invoke it.

Also supports discovering and invoking exception handling methods to process exceptions raised during message handling.

Since:
4.0
Author:
Rossen Stoyanchev, Juergen Hoeller

  • Field Details

    • logger

      protected final Log logger

  • Constructor Details

    • AbstractMethodMessageHandler

      public AbstractMethodMessageHandler()

  • Method Details

    • setDestinationPrefixes

      public void setDestinationPrefixes(@Nullable Collection<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.

    • getDestinationPrefixes

      public Collection<String> getDestinationPrefixes()
      Return the configured destination prefixes, if any.

    • setCustomArgumentResolvers

      public void setCustomArgumentResolvers(@Nullable List<HandlerMethodArgumentResolver> customArgumentResolvers)
      Sets the list of custom HandlerMethodArgumentResolvers that will be used after resolvers for supported argument type.

    • getCustomArgumentResolvers

      public List<HandlerMethodArgumentResolver> getCustomArgumentResolvers()
      Return the configured custom argument resolvers, if any.

    • setCustomReturnValueHandlers

      public void setCustomReturnValueHandlers(@Nullable List<HandlerMethodReturnValueHandler> customReturnValueHandlers)
      Set the list of custom HandlerMethodReturnValueHandlers that will be used after return value handlers for known types.

    • getCustomReturnValueHandlers

      public List<HandlerMethodReturnValueHandler> getCustomReturnValueHandlers()
      Return the configured custom return value handlers, if any.

    • setArgumentResolvers

      public void setArgumentResolvers(@Nullable List<HandlerMethodArgumentResolver> argumentResolvers)
      Configure the complete list of supported argument types, effectively overriding the ones configured by default. This is an advanced option; for most use cases it should be sufficient to use setCustomArgumentResolvers(java.util.List<org.springframework.messaging.handler.invocation.HandlerMethodArgumentResolver>).

    • getArgumentResolvers

      public List<HandlerMethodArgumentResolver> getArgumentResolvers()
      Return the complete list of argument resolvers.

    • setReturnValueHandlers

      public void setReturnValueHandlers(@Nullable List<HandlerMethodReturnValueHandler> returnValueHandlers)
      Configure the complete list of supported return value types, effectively overriding the ones configured by default. This is an advanced option; for most use cases it should be sufficient to use setCustomReturnValueHandlers(java.util.List<org.springframework.messaging.handler.invocation.HandlerMethodReturnValueHandler>).

    • getReturnValueHandlers

      public List<HandlerMethodReturnValueHandler> getReturnValueHandlers()
      Return the complete list of return value handlers.

    • setApplicationContext

      public void setApplicationContext(@Nullable org.springframework.context.ApplicationContext applicationContext)
      Specified by:
      setApplicationContext in interface org.springframework.context.ApplicationContextAware

    • getApplicationContext

      @Nullable public org.springframework.context.ApplicationContext getApplicationContext()

    • afterPropertiesSet

      public void afterPropertiesSet()
      Specified by:
      afterPropertiesSet in interface org.springframework.beans.factory.InitializingBean

    • initArgumentResolvers

      protected abstract List<? extends HandlerMethodArgumentResolver> initArgumentResolvers()
      Return the list of argument resolvers to use. Invoked only if the resolvers have not already been set via setArgumentResolvers(java.util.List<org.springframework.messaging.handler.invocation.HandlerMethodArgumentResolver>).

      Subclasses should also take into account custom argument types configured via setCustomArgumentResolvers(java.util.List<org.springframework.messaging.handler.invocation.HandlerMethodArgumentResolver>).

    • initReturnValueHandlers

      protected abstract List<? extends HandlerMethodReturnValueHandler> initReturnValueHandlers()
      Return the list of return value handlers to use. Invoked only if the return value handlers have not already been set via setReturnValueHandlers(java.util.List<org.springframework.messaging.handler.invocation.HandlerMethodReturnValueHandler>).

      Subclasses should also take into account custom return value types configured via setCustomReturnValueHandlers(java.util.List<org.springframework.messaging.handler.invocation.HandlerMethodReturnValueHandler>).

    • isHandler

      protected abstract boolean isHandler(Class<?> beanType)
      Whether the given bean type should be introspected for messaging handling methods.

    • detectHandlerMethods

      protected final void detectHandlerMethods(Object handler)
      Detect if the given handler has any methods that can handle messages and if so register it with the extracted mapping information.
      Parameters:
      handler - the handler to check, either an instance of a Spring bean name

    • getMappingForMethod

      @Nullable protected abstract T getMappingForMethod(Method method, Class<?> handlerType)
      Provide the mapping for a handler method.
      Parameters:
      method - the method to provide a mapping for
      handlerType - the handler type, possibly a subtype of the method's declaring class
      Returns:
      the mapping, or null if the method is not mapped

    • registerHandlerMethod

      protected void registerHandlerMethod(Object handler, Method method, T mapping)
      Register a handler method and its unique mapping.
      Parameters:
      handler - the bean name of the handler or the handler instance
      method - the method to register
      mapping - the mapping conditions associated with the handler method
      Throws:
      IllegalStateException - if another method was already registered under the same mapping

    • createHandlerMethod

      protected HandlerMethod createHandlerMethod(Object handler, Method method)
      Create a HandlerMethod instance from an Object handler that is either a handler instance or a String-based bean name.

    • getDirectLookupDestinations

      protected abstract Set<String> getDirectLookupDestinations(T mapping)
      Return destinations contained in the mapping that are not patterns and are therefore suitable for direct lookups.

    • getReturnValueHandlerLogger

      @Nullable protected Log getReturnValueHandlerLogger()
      Return a logger to set on HandlerMethodReturnValueHandlerComposite.
      Since:
      5.1

    • getHandlerMethodLogger

      @Nullable protected Log getHandlerMethodLogger()
      Return a logger to set on InvocableHandlerMethod.
      Since:
      5.1

    • registerExceptionHandlerAdvice

      protected void registerExceptionHandlerAdvice(MessagingAdviceBean bean, AbstractExceptionHandlerMethodResolver resolver)
      Subclasses can invoke this method to populate the MessagingAdviceBean cache (e.g. to support "global" @MessageExceptionHandler).
      Since:
      4.2

    • getHandlerMethods

      public Map<T,HandlerMethod> getHandlerMethods()
      Return a map with all handler methods and their mappings.

    • handleMessage

      public void handleMessage(Message<?> message) throws MessagingException
      Description copied from interface: MessageHandler
      Handle the given message.
      Specified by:
      handleMessage in interface MessageHandler
      Parameters:
      message - the message to be handled
      Throws:
      MessagingException - if the handler failed to process the message

    • getDestination

      @Nullable protected abstract String getDestination(Message<?> message)

    • getLookupDestination

      @Nullable protected String getLookupDestination(@Nullable 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.

      If there are no matching prefixes, return null.

      If there are no destination prefixes, return the destination as is.

    • handleMessageInternal

      protected void handleMessageInternal(Message<?> message, String lookupDestination)

    • getMatchingMapping

      @Nullable protected abstract T 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.
      Parameters:
      mapping - the mapping to get a match for
      message - the message being handled
      Returns:
      the match or null if there is no match

    • handleNoMatch

      protected void handleNoMatch(Set<T> ts, String lookupDestination, Message<?> message)

    • getMappingComparator

      protected abstract Comparator<T> getMappingComparator(Message<?> message)
      Return a comparator for sorting matching mappings. The returned comparator should sort 'better' matches higher.
      Parameters:
      message - the current Message
      Returns:
      the comparator, never null

    • handleMatch

      protected void handleMatch(T mapping, HandlerMethod handlerMethod, String lookupDestination, Message<?> message)

    • processHandlerMethodException

      protected void processHandlerMethodException(HandlerMethod handlerMethod, Exception exception, Message<?> message)

    • getExceptionHandlerMethod

      @Nullable protected InvocableHandlerMethod getExceptionHandlerMethod(HandlerMethod handlerMethod, Exception exception)
      Find an @MessageExceptionHandler method for the given exception. The default implementation searches methods in the class hierarchy of the HandlerMethod first and if not found, it continues searching for additional @MessageExceptionHandler methods among the configured MessagingAdviceBean, if any.
      Parameters:
      handlerMethod - the method where the exception was raised
      exception - the raised exception
      Returns:
      a method to handle the exception, or null
      Since:
      4.2

    • createExceptionHandlerMethodResolverFor

      protected abstract AbstractExceptionHandlerMethodResolver createExceptionHandlerMethodResolverFor(Class<?> beanType)

    • toString

      public String toString()
      Overrides:
      toString in class Object