AbstractMethodMessageHandler (Spring Framework 5.1.3.RELEASE API)

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:

Aware, InitializingBean, ApplicationContextAware, MessageHandler

Direct Known Subclasses:

SimpAnnotationMethodMessageHandler
```
public abstract class AbstractMethodMessageHandler<T>
extends java.lang.Object
implements MessageHandler, ApplicationContextAware, 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 Summary

Fields
Modifier and Type Field and Description

protected Log logger

Fields
Modifier and Type	Field and Description
`protected Log`	`logger`

Constructor Summary

Constructors
Constructor and Description

AbstractMethodMessageHandler()

Constructors
Constructor and Description
`AbstractMethodMessageHandler()`

Method Summary

All Methods Instance Methods Abstract 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 abstract AbstractExceptionHandlerMethodResolver`	`createExceptionHandlerMethodResolverFor(java.lang.Class<?> beanType)`
`protected HandlerMethod`	`createHandlerMethod(java.lang.Object handler, java.lang.reflect.Method method)` Create a HandlerMethod instance from an Object handler that is either a handler instance or a String-based bean name.
`protected void`	`detectHandlerMethods(java.lang.Object handler)` Detect if the given handler has any methods that can handle messages and if so register it with the extracted mapping information.
`ApplicationContext`	`getApplicationContext()`
`java.util.List<HandlerMethodArgumentResolver>`	`getArgumentResolvers()` Return the complete list of argument resolvers.
`java.util.List<HandlerMethodArgumentResolver>`	`getCustomArgumentResolvers()` Return the configured custom argument resolvers, if any.
`java.util.List<HandlerMethodReturnValueHandler>`	`getCustomReturnValueHandlers()` Return the configured custom return value handlers, if any.
`protected abstract java.lang.String`	`getDestination(Message<?> message)`
`java.util.Collection<java.lang.String>`	`getDestinationPrefixes()` Return the configured destination prefixes, if any.
`protected abstract java.util.Set<java.lang.String>`	`getDirectLookupDestinations(T mapping)` Return destinations contained in the mapping that are not patterns and are therefore suitable for direct lookups.
`protected InvocableHandlerMethod`	`getExceptionHandlerMethod(HandlerMethod handlerMethod, java.lang.Exception exception)` Find an `@MessageExceptionHandler` method for the given exception.
`protected Log`	`getHandlerMethodLogger()` Return a logger to set on `InvocableHandlerMethod`.
`java.util.Map<T,HandlerMethod>`	`getHandlerMethods()` Return a map with all handler methods and their mappings.
`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 abstract java.util.Comparator<T>`	`getMappingComparator(Message<?> message)` Return a comparator for sorting matching mappings.
`protected abstract T`	`getMappingForMethod(java.lang.reflect.Method method, java.lang.Class<?> handlerType)` Provide the mapping for a handler method.
`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.
`protected Log`	`getReturnValueHandlerLogger()` Return a logger to set on `HandlerMethodReturnValueHandlerComposite`.
`java.util.List<HandlerMethodReturnValueHandler>`	`getReturnValueHandlers()` Return the complete list of return value handlers.
`protected void`	`handleMatch(T mapping, HandlerMethod handlerMethod, java.lang.String lookupDestination, Message<?> message)`
`void`	`handleMessage(Message<?> message)` Handle the given message.
`protected void`	`handleMessageInternal(Message<?> message, java.lang.String lookupDestination)`
`protected void`	`handleNoMatch(java.util.Set<T> ts, java.lang.String lookupDestination, Message<?> message)`
`protected abstract java.util.List<? extends HandlerMethodArgumentResolver>`	`initArgumentResolvers()` Return the list of argument resolvers to use.
`protected abstract java.util.List<? extends HandlerMethodReturnValueHandler>`	`initReturnValueHandlers()` Return the list of return value handlers to use.
`protected abstract boolean`	`isHandler(java.lang.Class<?> beanType)` Whether the given bean type should be introspected for messaging handling methods.
`protected void`	`processHandlerMethodException(HandlerMethod handlerMethod, java.lang.Exception exception, Message<?> message)`
`protected void`	`registerExceptionHandlerAdvice(MessagingAdviceBean bean, AbstractExceptionHandlerMethodResolver resolver)` Subclasses can invoke this method to populate the MessagingAdviceBean cache (e.g.
`protected void`	`registerHandlerMethod(java.lang.Object handler, java.lang.reflect.Method method, T mapping)` Register a handler method and its unique mapping.
`void`	`setApplicationContext(ApplicationContext applicationContext)` Set the ApplicationContext that this object runs in.
`void`	`setArgumentResolvers(java.util.List<HandlerMethodArgumentResolver> argumentResolvers)` Configure the complete list of supported argument types, effectively overriding the ones configured by default.
`void`	`setCustomArgumentResolvers(java.util.List<HandlerMethodArgumentResolver> customArgumentResolvers)` Sets the list of custom `HandlerMethodArgumentResolver`s that will be used after resolvers for supported argument type.
`void`	`setCustomReturnValueHandlers(java.util.List<HandlerMethodReturnValueHandler> customReturnValueHandlers)` Set the list of custom `HandlerMethodReturnValueHandler`s that will be used after return value handlers for known types.
`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`	`setReturnValueHandlers(java.util.List<HandlerMethodReturnValueHandler> returnValueHandlers)` Configure the complete list of supported return value types, effectively overriding the ones configured by default.
`java.lang.String`	`toString()`

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

- Field Detail
  - logger
```
protected final Log logger
```
- Constructor Detail
  - AbstractMethodMessageHandler
```
public AbstractMethodMessageHandler()
```
- Method Detail
  - setDestinationPrefixes
```
public void setDestinationPrefixes(@Nullable
                                   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.
  - getDestinationPrefixes
```
public java.util.Collection<java.lang.String> getDestinationPrefixes()
```
    Return the configured destination prefixes, if any.
  - setCustomArgumentResolvers
```
public void setCustomArgumentResolvers(@Nullable
                                       java.util.List<HandlerMethodArgumentResolver> customArgumentResolvers)
```
    Sets the list of custom HandlerMethodArgumentResolvers that will be used after resolvers for supported argument type.
  - getCustomArgumentResolvers
```
public java.util.List<HandlerMethodArgumentResolver> getCustomArgumentResolvers()
```
    Return the configured custom argument resolvers, if any.
  - setCustomReturnValueHandlers
```
public void setCustomReturnValueHandlers(@Nullable
                                         java.util.List<HandlerMethodReturnValueHandler> customReturnValueHandlers)
```
    Set the list of custom HandlerMethodReturnValueHandlers that will be used after return value handlers for known types.
  - getCustomReturnValueHandlers
```
public java.util.List<HandlerMethodReturnValueHandler> getCustomReturnValueHandlers()
```
    Return the configured custom return value handlers, if any.
  - setArgumentResolvers
```
public void setArgumentResolvers(@Nullable
                                 java.util.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 java.util.List<HandlerMethodArgumentResolver> getArgumentResolvers()
```
    Return the complete list of argument resolvers.
  - setReturnValueHandlers
```
public void setReturnValueHandlers(@Nullable
                                   java.util.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 java.util.List<HandlerMethodReturnValueHandler> getReturnValueHandlers()
```
    Return the complete list of return value handlers.
  - setApplicationContext
```
public void setApplicationContext(@Nullable
                                  ApplicationContext applicationContext)
```
    Description copied from interface: ApplicationContextAware
    
    Set the ApplicationContext that this object runs in. Normally this call will be used to initialize the object.
    Invoked after population of normal bean properties but before an init callback such as InitializingBean.afterPropertiesSet() or a custom init-method. Invoked after ResourceLoaderAware.setResourceLoader(org.springframework.core.io.ResourceLoader), ApplicationEventPublisherAware.setApplicationEventPublisher(org.springframework.context.ApplicationEventPublisher) and MessageSourceAware, if applicable.
    
    Specified by:
    
    setApplicationContext in interface ApplicationContextAware
    
    Parameters:
    
    applicationContext - the ApplicationContext object to be used by this object
    
    See Also:
    
    BeanInitializationException
  - getApplicationContext
```
@Nullable
public ApplicationContext getApplicationContext()
```
  - 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
  - initArgumentResolvers
```
protected abstract java.util.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 java.util.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(java.lang.Class<?> beanType)
```
    Whether the given bean type should be introspected for messaging handling methods.
  - detectHandlerMethods
```
protected final void detectHandlerMethods(java.lang.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(java.lang.reflect.Method method,
                                                   java.lang.Class<?> handlerType)
```
    Provide the mapping for a handler method.
    
    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
  - registerHandlerMethod
```
protected void registerHandlerMethod(java.lang.Object handler,
                                     java.lang.reflect.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:
    
    java.lang.IllegalStateException - if another method was already registered under the same mapping
  - createHandlerMethod
```
protected HandlerMethod createHandlerMethod(java.lang.Object handler,
                                            java.lang.reflect.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 java.util.Set<java.lang.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 java.util.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 java.lang.String getDestination(Message<?> message)
```
  - getLookupDestination
```
@Nullable
protected java.lang.String getLookupDestination(@Nullable
                                                          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.
    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,
                                     java.lang.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(java.util.Set<T> ts,
                             java.lang.String lookupDestination,
                             Message<?> message)
```
  - getMappingComparator
```
protected abstract java.util.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,
                           java.lang.String lookupDestination,
                           Message<?> message)
```
  - processHandlerMethodException
```
protected void processHandlerMethodException(HandlerMethod handlerMethod,
                                             java.lang.Exception exception,
                                             Message<?> message)
```
  - getExceptionHandlerMethod
```
@Nullable
protected InvocableHandlerMethod getExceptionHandlerMethod(HandlerMethod handlerMethod,
                                                                     java.lang.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(java.lang.Class<?> beanType)
```
  - toString
```
public java.lang.String toString()
```
    Overrides:
    
    toString in class java.lang.Object

Class AbstractMethodMessageHandler<T>

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

logger

Constructor Detail

AbstractMethodMessageHandler

Method Detail

setDestinationPrefixes

getDestinationPrefixes

setCustomArgumentResolvers

getCustomArgumentResolvers

setCustomReturnValueHandlers

getCustomReturnValueHandlers

setArgumentResolvers

getArgumentResolvers

setReturnValueHandlers

getReturnValueHandlers

setApplicationContext

getApplicationContext

afterPropertiesSet

initArgumentResolvers

initReturnValueHandlers

isHandler

detectHandlerMethods

getMappingForMethod

registerHandlerMethod

createHandlerMethod

getDirectLookupDestinations

getReturnValueHandlerLogger

getHandlerMethodLogger

registerExceptionHandlerAdvice

getHandlerMethods

handleMessage

getDestination

getLookupDestination

handleMessageInternal

getMatchingMapping

handleNoMatch

getMappingComparator

handleMatch

processHandlerMethodException

getExceptionHandlerMethod

createExceptionHandlerMethodResolverFor

toString