org.springframework.messaging.handler.invocation.reactive

Class AbstractMethodMessageHandler<T>

java.lang.Object

org.springframework.messaging.handler.invocation.reactive.AbstractMethodMessageHandler<T>

Type Parameters:

T - the type of the Object that contains information mapping information

All Implemented Interfaces:

org.springframework.beans.factory.Aware, org.springframework.beans.factory.BeanNameAware, org.springframework.beans.factory.InitializingBean, org.springframework.context.ApplicationContextAware, ReactiveMessageHandler

Direct Known Subclasses:

MessageMappingMessageHandler

public abstract class AbstractMethodMessageHandler<T>
extends Object
implements ReactiveMessageHandler, org.springframework.context.ApplicationContextAware, org.springframework.beans.factory.InitializingBean, org.springframework.beans.factory.BeanNameAware

Abstract base class for reactive 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:

5.2

Author:

Rossen Stoyanchev

Field Summary

Fields

Modifier and Type	Field and Description
protected Log	logger

Constructor Summary

Constructors

Constructor and Description
AbstractMethodMessageHandler()

Method Summary

Modifier and Type	Method and Description
void	afterPropertiesSet()
protected abstract AbstractExceptionHandlerMethodResolver	createExceptionMethodResolverFor(Class<?> beanType) Create a concrete instance of AbstractExceptionHandlerMethodResolver that finds exception handling methods based on some criteria, e.g.
protected 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.
org.springframework.context.ApplicationContext	getApplicationContext()
ArgumentResolverConfigurer	getArgumentResolverConfigurer() Return the configured custom resolvers for handler method arguments.
String	getBeanName()
protected abstract String	getDestination(Message<?> message) Extract a String-based destination, if any, that can be used to perform a direct look up into the registered mappings.
org.springframework.util.MultiValueMap<String,T>	getDestinationLookup() Return a read-only multi-value map with a direct lookup of mappings, (e.g.
protected abstract Set<String>	getDirectLookupMappings(T mapping) Return String-based destinations for the given mapping, if any, that can be used to find matches with a direct lookup (i.e.
Map<T,HandlerMethod>	getHandlerMethods() Return a read-only map with all handler methods and their mappings.
protected abstract Comparator<T>	getMappingComparator(Message<?> message) Return a comparator for sorting matching mappings.
protected abstract T	getMappingForMethod(Method method, Class<?> handlerType) Obtain the mapping for the given method, if any.
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.
org.springframework.core.ReactiveAdapterRegistry	getReactiveAdapterRegistry() Return the configured registry for adapting reactive types.
ReturnValueHandlerConfigurer	getReturnValueHandlerConfigurer() Return the configured return value handlers.
protected reactor.core.publisher.Mono<Void>	handleMatch(T mapping, HandlerMethod handlerMethod, Message<?> message)
reactor.core.publisher.Mono<Void>	handleMessage(Message<?> message) Handle the given message.
protected void	handleNoMatch(String destination, Message<?> message) Invoked when no matching handler is found.
protected abstract List<? extends HandlerMethodArgumentResolver>	initArgumentResolvers() Return the list of argument resolvers to use.
protected abstract Predicate<Class<?>>	initHandlerPredicate() Return the predicate to use to check whether a given Spring bean should be introspected for message handling methods.
protected abstract List<? extends HandlerMethodReturnValueHandler>	initReturnValueHandlers() Return the list of return value handlers to use.
protected void	registerExceptionHandlerAdvice(MessagingAdviceBean bean, AbstractExceptionHandlerMethodResolver resolver) Subclasses can invoke this method to populate the MessagingAdviceBean cache (e.g.
protected void	registerHandlerMethod(Object handler, Method method, T mapping) Register a handler method and its unique mapping.
void	setApplicationContext(org.springframework.context.ApplicationContext applicationContext)
void	setArgumentResolverConfigurer(ArgumentResolverConfigurer configurer) Configure custom resolvers for handler method arguments.
void	setBeanName(String name)
void	setReactiveAdapterRegistry(org.springframework.core.ReactiveAdapterRegistry registry) Configure the registry for adapting various reactive types.
void	setReturnValueHandlerConfigurer(ReturnValueHandlerConfigurer configurer) Configure custom return value handlers for handler metohds.

Methods inherited from class java.lang.Object

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

Field Detail

logger

protected final Log logger

Constructor Detail

AbstractMethodMessageHandler

public AbstractMethodMessageHandler()

Method Detail

setArgumentResolverConfigurer

public void setArgumentResolverConfigurer(ArgumentResolverConfigurer configurer)

Configure custom resolvers for handler method arguments.

getArgumentResolverConfigurer

public ArgumentResolverConfigurer getArgumentResolverConfigurer()

Return the configured custom resolvers for handler method arguments.

setReturnValueHandlerConfigurer

public void setReturnValueHandlerConfigurer(ReturnValueHandlerConfigurer configurer)

Configure custom return value handlers for handler metohds.

getReturnValueHandlerConfigurer

public ReturnValueHandlerConfigurer getReturnValueHandlerConfigurer()

Return the configured return value handlers.

setReactiveAdapterRegistry

public void setReactiveAdapterRegistry(org.springframework.core.ReactiveAdapterRegistry registry)

Configure the registry for adapting various reactive types.

By default this is an instance of ReactiveAdapterRegistry with default settings.

getReactiveAdapterRegistry

public org.springframework.core.ReactiveAdapterRegistry getReactiveAdapterRegistry()

Return the configured registry for adapting reactive types.

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()

setBeanName

public void setBeanName(String name)

Specified by:

setBeanName in interface org.springframework.beans.factory.BeanNameAware

getBeanName

public String getBeanName()

registerExceptionHandlerAdvice

protected void registerExceptionHandlerAdvice(MessagingAdviceBean bean,
                                              AbstractExceptionHandlerMethodResolver resolver)

Subclasses can invoke this method to populate the MessagingAdviceBean cache (e.g. to support "global" @MessageExceptionHandler).

getHandlerMethods

public Map<T,HandlerMethod> getHandlerMethods()

Return a read-only map with all handler methods and their mappings.

getDestinationLookup

public org.springframework.util.MultiValueMap<String,T> getDestinationLookup()

Return a read-only multi-value map with a direct lookup of mappings, (e.g. for non-pattern destinations).

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.

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

initReturnValueHandlers

protected abstract List<? extends HandlerMethodReturnValueHandler> initReturnValueHandlers()

Return the list of return value handlers to use.

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

initHandlerPredicate

@Nullable
protected abstract Predicate<Class<?>> initHandlerPredicate()

Return the predicate to use to check whether a given Spring bean should be introspected for message handling methods. If null is returned, auto-detection is effectively disabled.

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.

Note: This method is protected and can be invoked by sub-classes, but this should be done on startup only as documented in registerHandlerMethod(java.lang.Object, java.lang.reflect.Method, T).

Parameters:

handler - the handler to check, either an instance of a Spring bean name

getMappingForMethod

@Nullable
protected abstract T getMappingForMethod(Method method,
                                                   Class<?> handlerType)

Obtain the mapping for the given method, if any.

Parameters:

method - the method to check

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 final void registerHandlerMethod(Object handler,
                                           Method method,
                                           T mapping)

Register a handler method and its unique mapping.

Note: This method is protected and can be invoked by sub-classes. Keep in mind however that the registration is not protected for concurrent use, and is expected to be done on startup.

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

getDirectLookupMappings

protected abstract Set<String> getDirectLookupMappings(T mapping)

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 sub-class may support neither direct lookups, nor String based destinations.

handleMessage

public reactor.core.publisher.Mono<Void> handleMessage(Message<?> message)
                                                throws MessagingException

Description copied from interface: ReactiveMessageHandler

Handle the given message.

Specified by:

handleMessage in interface ReactiveMessageHandler

Parameters:

message - the message to be handled

Returns:

a completion Mono for the result of the message handling.

Throws:

MessagingException

handleMatch

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

getDestination

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

Extract a String-based destination, if any, that can be used to perform a direct look up into the registered mappings.

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

See Also:

getDirectLookupMappings(Object)

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

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

handleNoMatch

protected void handleNoMatch(@Nullable
                             String destination,
                             Message<?> message)

Invoked when no matching handler is found.

Parameters:

destination - the destination

message - the message

createExceptionMethodResolverFor

protected abstract AbstractExceptionHandlerMethodResolver createExceptionMethodResolverFor(Class<?> beanType)

Create a concrete instance of AbstractExceptionHandlerMethodResolver that finds exception handling methods based on some criteria, e.g. based on the presence of @MessageExceptionHandler.

Parameters:

beanType - the class in which an exception occurred during handling

Returns:

the resolver to use