Modifier and Type	Class and Description
private static class	AbstractMethodMessageHandler.Match<T> Container for matched mapping and HandlerMethod.
private class	AbstractMethodMessageHandler.MatchComparator

Modifier and Type	Field and Description
private ApplicationContext	applicationContext
private ArgumentResolverConfigurer	argumentResolverConfigurer
private String	beanName
private final Map<String, List<T>>	destinationLookup
private final Map<T, HandlerMethod>	handlerMethods
private Predicate<Class<?>>	handlerPredicate
pack-priv List<Object>	handlers
private final InvocableHelper	invocableHelper
protected final Log	logger
private ReturnValueHandlerConfigurer	returnValueHandlerConfigurer
private static final String	SCOPED_TARGET_NAME_PREFIX Bean name prefix for target beans behind scoped proxies.

Access	Constructor and Description
public	AbstractMethodMessageHandler()

Method Summary

Modifier and Type	Method and Description
private void	addMatchesToCollection(Collection<T> mappingsToCheck, Message<?> message, List<AbstractMethodMessageHandler.Match<T>> matches)
public void	afterPropertiesSet() Implements org.springframework.beans.factory.InitializingBean.afterPropertiesSet. 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.
protected abstract AbstractExceptionHandlerMethodResolver	Returns: the resolver to use createExceptionMethodResolverFor(Class<?> the class in which an exception occurred during handling beanType) Create a concrete instance of `AbstractExceptionHandlerMethodResolver` that finds exception handling methods based on some criteria, e.g. based on the presence of `@MessageExceptionHandler`.
private 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.
protected final void	detectHandlerMethods(Object the handler to check, either an instance of a Spring bean name handler) Detect if the given handler has any methods that can handle messages and if so register it with the extracted mapping information.
protected T	Returns: a new mapping or the same extendMapping(T the mapping to be added mapping, HandlerMethod the target handler for the mapping handlerMethod) This method is invoked just before mappings are added.
private String	formatMappings(Class<?> userType, Map<Method, T> methods)
public ApplicationContext	getApplicationContext()
public ArgumentResolverConfigurer	getArgumentResolverConfigurer() Return the configured custom resolvers for handler method arguments.
protected HandlerMethodArgumentResolverComposite	getArgumentResolvers() Return the argument resolvers initialized during `afterPropertiesSet()`.
public String	getBeanName()
protected abstract RouteMatcher.Route	getDestination(Message<?> message) Extract the destination from the given message.
public MultiValueMap<String, T>	getDestinationLookup() Return a read-only multi-value map with a direct lookup of mappings, (e.g. for non-pattern destinations).
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).
private AbstractMethodMessageHandler.Match<T>	getHandlerMethod(Message<?> message)
public Map<T, HandlerMethod>	getHandlerMethods() Return a read-only map with all handler methods and their mappings.
public Predicate<Class<?>>	getHandlerPredicate() Return the `configured` handler predicate.
protected abstract Comparator<T>	Returns: the comparator, never `null` getMappingComparator(Message<?> the current Message message) Return a comparator for sorting matching mappings.
protected abstract T	Returns: the mapping, or `null` if the method is not mapped getMappingForMethod(Method the method to check method, Class<?> the handler type, possibly a subtype of the method's declaring class handlerType) Obtain the mapping for the given method, if any.
protected abstract T	Returns: the match or `null` if there is no match getMatchingMapping(T the mapping to get a match for mapping, Message<?> the message being handled message) Check if a mapping matches the current message and return a possibly new mapping with conditions relevant to the current request.
public ReactiveAdapterRegistry	getReactiveAdapterRegistry() Return the configured registry for adapting reactive types.
public ReturnValueHandlerConfigurer	getReturnValueHandlerConfigurer() Return the configured return value handlers.
protected Mono<Void>	handleMatch(T mapping, HandlerMethod handlerMethod, Message<?> message)
public Mono<Void>	handleMessage(Message<?> the message to be handled message) Implements org.springframework.messaging.ReactiveMessageHandler.handleMessage. Handle the given message.
protected void	handleNoMatch(RouteMatcher.Route the destination destination, Message<?> the message message) Invoked when no matching handler is found.
protected abstract List<? extends HandlerMethodArgumentResolver>	initArgumentResolvers() Return the list of argument resolvers to use.
private void	initHandlerMethods()
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. to support "global" `@MessageExceptionHandler`).
public final void	registerHandlerMethod(Object the bean name of the handler or the handler instance handler, Method the method to register method, T the mapping conditions associated with the handler method mapping) Register a handler method and its unique mapping.
public void	setApplicationContext(ApplicationContext the ApplicationContext object to be used by this object applicationContext) Implements org.springframework.context.ApplicationContextAware.setApplicationContext. Set the ApplicationContext that this object runs in. Normally this call will be used to initialize the object.
public void	setArgumentResolverConfigurer(ArgumentResolverConfigurer configurer) Configure custom resolvers for handler method arguments.
public void	setBeanName(String the name of the bean in the factory. Note that this name is the actual bean name used in the factory, which may differ from the originally specified name: in particular for inner bean names, the actual bean name might have been made unique through appending "#..." suffixes. Use the `BeanFactoryUtils#originalBeanName(String)` method to extract the original bean name (without suffix), if desired. name) Implements org.springframework.beans.factory.BeanNameAware.setBeanName. Set the name of the bean in the bean factory that created this bean.
public void	setHandlerPredicate(Predicate<Class<?>> handlerPredicate) Configure a predicate for selecting which Spring beans to check for the presence of message handler methods.
public void	setHandlers(List<Object> the handlers to check handlers) Manually configure the handlers to check for the presence of message handling methods, which also disables auto-detection via a `handlerPredicate`.
public void	setReactiveAdapterRegistry(ReactiveAdapterRegistry registry) Configure the registry for adapting various reactive types.
public void	setReturnValueHandlerConfigurer(ReturnValueHandlerConfigurer configurer) Configure custom return value handlers for handler methods.

Inherited from java.lang.Object:: clone equals finalize getClass hashCode notify notifyAll toString wait wait wait

Field Detail

applicationContext	back to summary
private ApplicationContext applicationContext Annotations @Nullable

argumentResolverConfigurer	back to summary
private ArgumentResolverConfigurer argumentResolverConfigurer

beanName	back to summary
private String beanName Annotations @Nullable

destinationLookup	back to summary
private final Map<String, List<T>> destinationLookup

handlerMethods	back to summary
private final Map<T, HandlerMethod> handlerMethods

handlerPredicate	back to summary
private Predicate<Class<?>> handlerPredicate Annotations @Nullable

handlers	back to summary
pack-priv List<Object> handlers Annotations @Nullable

invocableHelper	back to summary
private final InvocableHelper invocableHelper

logger	back to summary
protected final Log logger

returnValueHandlerConfigurer	back to summary
private ReturnValueHandlerConfigurer returnValueHandlerConfigurer

SCOPED_TARGET_NAME_PREFIX back to summary

SCOPED_TARGET_NAME_PREFIX	back to summary
private static final String SCOPED_TARGET_NAME_PREFIX Bean name prefix for target beans behind scoped proxies. Used to exclude those targets from handler method detection, in favor of the corresponding proxies. We're not checking the autowire-candidate status here, which is how the proxy target filtering problem is being handled at the autowiring level, since autowire-candidate may have been turned to `false` for other reasons, while still expecting the bean to be eligible for handler methods. Originally defined in `org.springframework.aop.scope.ScopedProxyUtils` but duplicated here to avoid a hard dependency on the spring-aop module.

private static final String SCOPED_TARGET_NAME_PREFIX

Bean name prefix for target beans behind scoped proxies. Used to exclude those targets from handler method detection, in favor of the corresponding proxies.

We're not checking the autowire-candidate status here, which is how the proxy target filtering problem is being handled at the autowiring level, since autowire-candidate may have been turned to false for other reasons, while still expecting the bean to be eligible for handler methods.

Originally defined in org.springframework.aop.scope.ScopedProxyUtils but duplicated here to avoid a hard dependency on the spring-aop module.

Constructor Detail

AbstractMethodMessageHandler	back to summary
public AbstractMethodMessageHandler()

Method Detail

addMatchesToCollection	back to summary
private void addMatchesToCollection(Collection<T> mappingsToCheck, Message<?> message, List<AbstractMethodMessageHandler.Match<T>> matches)

afterPropertiesSet back to summary

afterPropertiesSet	back to summary
public void afterPropertiesSet() Implements org.springframework.beans.factory.InitializingBean.afterPropertiesSet. Doc from org.springframework.beans.factory.InitializingBean.afterPropertiesSet. 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. Annotations @Override

public void afterPropertiesSet()

Implements org.springframework.beans.factory.InitializingBean.afterPropertiesSet.

Doc from org.springframework.beans.factory.InitializingBean.afterPropertiesSet.

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.

Annotations

@Override

createExceptionMethodResolverFor back to summary

createExceptionMethodResolverFor	back to summary
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:Class<?> the class in which an exception occurred during handling Returns:AbstractExceptionHandlerMethodResolver the resolver to use

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:Class<?>: the class in which an exception occurred during handling

Returns:AbstractExceptionHandlerMethodResolver

the resolver to use

createHandlerMethod	back to summary
private 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.

detectHandlerMethods back to summary

detectHandlerMethods	back to summary
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 subclasses, but this should be done on startup only as documented in `registerHandlerMethod`. Parameters handler:Object the handler to check, either an instance of a Spring bean name

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 subclasses, but this should be done on startup only as documented in registerHandlerMethod.

Parameters

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

extendMapping back to summary

extendMapping	back to summary
protected T extendMapping(T mapping, HandlerMethod handlerMethod) This method is invoked just before mappings are added. It allows subclasses to update the mapping with the `HandlerMethod` in mind. This can be useful when the method signature is used to refine the mapping, e.g. based on the cardinality of input and output. By default this method returns the mapping that is passed in. Parameters mapping:T the mapping to be added handlerMethod:HandlerMethod the target handler for the mapping Returns:T a new mapping or the same Since 5.2.2

protected T extendMapping(T mapping, HandlerMethod handlerMethod)

This method is invoked just before mappings are added. It allows subclasses to update the mapping with the HandlerMethod in mind. This can be useful when the method signature is used to refine the mapping, e.g. based on the cardinality of input and output.

By default this method returns the mapping that is passed in.

Parameters

mapping:T: the mapping to be added
handlerMethod:HandlerMethod: the target handler for the mapping

Returns:T

a new mapping or the same

Since

5.2.2

formatMappings	back to summary
private String formatMappings(Class<?> userType, Map<Method, T> methods)

getApplicationContext	back to summary
public ApplicationContext getApplicationContext() Annotations @Nullable

getArgumentResolverConfigurer	back to summary
public ArgumentResolverConfigurer getArgumentResolverConfigurer() Return the configured custom resolvers for handler method arguments.

getArgumentResolvers back to summary

getArgumentResolvers	back to summary
protected HandlerMethodArgumentResolverComposite getArgumentResolvers() Return the argument resolvers initialized during `afterPropertiesSet()`. Primarily for internal use in subclasses. Since 5.2.2

protected HandlerMethodArgumentResolverComposite getArgumentResolvers()

Return the argument resolvers initialized during afterPropertiesSet(). Primarily for internal use in subclasses.

Since: 5.2.2

getBeanName	back to summary
public String getBeanName()

getDestination back to summary

getDestination	back to summary
protected abstract RouteMatcher.Route getDestination(Message<?> message) Extract the destination from the given message. Annotations @Nullable See Also `getDirectLookupMappings(Object)`

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

Extract the destination from the given message.

Annotations

@Nullable

See Also

getDirectLookupMappings(Object)

getDestinationLookup	back to summary
public MultiValueMap<String, T> getDestinationLookup() Return a read-only multi-value map with a direct lookup of mappings, (e.g. for non-pattern destinations).

getDirectLookupMappings	back to summary
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 subclass may support neither direct lookups, nor String based destinations.

getHandlerMethod	back to summary
private AbstractMethodMessageHandler.Match<T> getHandlerMethod(Message<?> message) Annotations @Nullable

getHandlerMethods	back to summary
public Map<T, HandlerMethod> getHandlerMethods() Return a read-only map with all handler methods and their mappings.

getHandlerPredicate back to summary

getHandlerPredicate	back to summary
public Predicate<Class<?>> getHandlerPredicate() Return the `configured` handler predicate. Annotations @Nullable

public Predicate<Class<?>> getHandlerPredicate()

Return the configured handler predicate.

Annotations

@Nullable

getMappingComparator back to summary

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

protected abstract Comparator<T> getMappingComparator(Message<?> message)

Return a comparator for sorting matching mappings. The returned comparator should sort 'better' matches higher.

Parameters

message:Message<?>: the current Message

Returns:Comparator<T>

the comparator, never null

getMappingForMethod back to summary

getMappingForMethod	back to summary
protected abstract T getMappingForMethod(Method method, Class<?> handlerType) Obtain the mapping for the given method, if any. Parameters method:Method the method to check handlerType:Class<?> the handler type, possibly a subtype of the method's declaring class Returns:T the mapping, or `null` if the method is not mapped Annotations @Nullable

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

Obtain the mapping for the given method, if any.

Parameters

method:Method: the method to check
handlerType:Class<?>: the handler type, possibly a subtype of the method's declaring class

Returns:T

the mapping, or null if the method is not mapped

Annotations

@Nullable

getMatchingMapping back to summary

getMatchingMapping	back to summary
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:T the mapping to get a match for message:Message<?> the message being handled Returns:T the match or `null` if there is no match Annotations @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:T: the mapping to get a match for
message:Message<?>: the message being handled

Returns:T

the match or null if there is no match

Annotations

@Nullable

getReactiveAdapterRegistry	back to summary
public ReactiveAdapterRegistry getReactiveAdapterRegistry() Return the configured registry for adapting reactive types.

getReturnValueHandlerConfigurer	back to summary
public ReturnValueHandlerConfigurer getReturnValueHandlerConfigurer() Return the configured return value handlers.

handleMatch	back to summary
protected Mono<Void> handleMatch(T mapping, HandlerMethod handlerMethod, Message<?> message)

handleMessage back to summary

handleMessage	back to summary
public Mono<Void> handleMessage(Message<?> message) throws MessagingException Implements org.springframework.messaging.ReactiveMessageHandler.handleMessage. Doc from org.springframework.messaging.ReactiveMessageHandler.handleMessage. Handle the given message. Parameters message:Message<?> the message to be handled Returns:Mono<Void> a completion `Mono` for the result of the message handling Annotations @Override

public Mono<Void> handleMessage(Message<?> message) throws MessagingException

Implements org.springframework.messaging.ReactiveMessageHandler.handleMessage.

Doc from org.springframework.messaging.ReactiveMessageHandler.handleMessage.

Handle the given message.

Parameters

message:Message<?>: the message to be handled

Returns:Mono<Void>

a completion Mono for the result of the message handling

Annotations

@Override

handleNoMatch	back to summary
protected void handleNoMatch(RouteMatcher.Route destination, Message<?> message) Invoked when no matching handler is found. Parameters destination:RouteMatcher.Route the destination message:Message<?> the message

handleNoMatch

back to summary

protected void handleNoMatch(RouteMatcher.Route destination, Message<?> message)

Invoked when no matching handler is found.

Parameters

destination:RouteMatcher.Route: the destination
message:Message<?>: the message

initArgumentResolvers back to summary

initArgumentResolvers	back to summary
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`.

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.

initHandlerMethods	back to summary
private void initHandlerMethods()

initReturnValueHandlers back to summary

initReturnValueHandlers	back to summary
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`.

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.

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

registerHandlerMethod	back to summary
public final void registerHandlerMethod(Object handler, Method method, T mapping) Register a handler method and its unique mapping. Note As of 5.3 this method is public (rather than protected) and can be used both at startup and at runtime. Parameters handler:Object the bean name of the handler or the handler instance method:Method the method to register mapping:T the mapping conditions associated with the handler method Exceptions IllegalStateException: if another method was already registered under the same mapping

registerHandlerMethod

back to summary

public final void registerHandlerMethod(Object handler, Method method, T mapping)

Note

As of 5.3 this method is public (rather than protected) and can be used both at startup and at runtime.

Parameters

handler:Object: the bean name of the handler or the handler instance
method:Method: the method to register
mapping:T: the mapping conditions associated with the handler method

Exceptions

IllegalStateException:: if another method was already registered under the same mapping

setApplicationContext back to summary

setApplicationContext	back to summary
public void setApplicationContext(ApplicationContext applicationContext) Implements org.springframework.context.ApplicationContextAware.setApplicationContext. Doc from org.springframework.context.ApplicationContextAware.setApplicationContext. 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 `org.springframework.beans.factory.InitializingBean#afterPropertiesSet()` or a custom init-method. Invoked after `ResourceLoaderAware#setResourceLoader`, `ApplicationEventPublisherAware#setApplicationEventPublisher` and `MessageSourceAware`, if applicable. Parameters applicationContext:ApplicationContext the ApplicationContext object to be used by this object Annotations @Override

public void setApplicationContext(ApplicationContext applicationContext)

Implements org.springframework.context.ApplicationContextAware.setApplicationContext.

Doc from org.springframework.context.ApplicationContextAware.setApplicationContext.

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 org.springframework.beans.factory.InitializingBean#afterPropertiesSet() or a custom init-method. Invoked after ResourceLoaderAware#setResourceLoader, ApplicationEventPublisherAware#setApplicationEventPublisher and MessageSourceAware, if applicable.

Parameters

applicationContext:ApplicationContext: the ApplicationContext object to be used by this object

Annotations

@Override

setArgumentResolverConfigurer	back to summary
public void setArgumentResolverConfigurer(ArgumentResolverConfigurer configurer) Configure custom resolvers for handler method arguments.

setBeanName back to summary

setBeanName	back to summary
public void setBeanName(String name) Implements org.springframework.beans.factory.BeanNameAware.setBeanName. Doc from org.springframework.beans.factory.BeanNameAware.setBeanName. Set the name of the bean in the bean factory that created this bean. Invoked after population of normal bean properties but before an init callback such as `InitializingBean#afterPropertiesSet()` or a custom init-method. Parameters name:String the name of the bean in the factory. Note that this name is the actual bean name used in the factory, which may differ from the originally specified name: in particular for inner bean names, the actual bean name might have been made unique through appending "#..." suffixes. Use the `BeanFactoryUtils#originalBeanName(String)` method to extract the original bean name (without suffix), if desired. Annotations @Override

public void setBeanName(String name)

Implements org.springframework.beans.factory.BeanNameAware.setBeanName.

Doc from org.springframework.beans.factory.BeanNameAware.setBeanName.

Set the name of the bean in the bean factory that created this bean.

Invoked after population of normal bean properties but before an init callback such as InitializingBean#afterPropertiesSet() or a custom init-method.

Parameters

name:String: the name of the bean in the factory. Note that this name is the actual bean name used in the factory, which may differ from the originally specified name: in particular for inner bean names, the actual bean name might have been made unique through appending "#..." suffixes. Use the BeanFactoryUtils#originalBeanName(String) method to extract the original bean name (without suffix), if desired.

Annotations

@Override

setHandlerPredicate back to summary

setHandlerPredicate	back to summary
public void setHandlerPredicate(Predicate<Class<?>> handlerPredicate) Configure a predicate for selecting which Spring beans to check for the presence of message handler methods. This is not set by default. However, subclasses may initialize it to some default strategy (e.g. `@Controller` classes). See Also `setHandlers(List)`

public void setHandlerPredicate(Predicate<Class<?>> handlerPredicate)

Configure a predicate for selecting which Spring beans to check for the presence of message handler methods.

This is not set by default. However, subclasses may initialize it to some default strategy (e.g. @Controller classes).

See Also: setHandlers(List)

setHandlers back to summary

public void setHandlers(List<Object> handlers)

Manually configure the handlers to check for the presence of message handling methods, which also disables auto-detection via a handlerPredicate. If you do not want to disable auto-detection, then call this method first, and then set the handler predicate.

Parameters

handlers:List<Object>: the handlers to check

setReactiveAdapterRegistry back to summary

public void setReactiveAdapterRegistry(ReactiveAdapterRegistry registry)

Configure the registry for adapting various reactive types.

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

setReturnValueHandlerConfigurer	back to summary
public void setReturnValueHandlerConfigurer(ReturnValueHandlerConfigurer configurer) Configure custom return value handlers for handler methods.

org.springframework.messaging.handler.invocation.reactive back to summary

private Class AbstractMethodMessageHandler.Match<T>

Class Inheritance

extends Object

java.lang.Object
org.springframework.messaging.handler.invocation.reactive.AbstractMethodMessageHandler.Match

Container for matched mapping and HandlerMethod. Used for best match comparison and for access to mapping information.

Field Summary

Modifier and Type	Field and Description
private final HandlerMethod	handlerMethod
private final T	mapping

Constructor Summary

Access	Constructor and Description
pack-priv	Match(T mapping, HandlerMethod handlerMethod)

Method Summary

Modifier and Type	Method and Description
public String	toString() Overrides java.lang.Object.toString. Returns a string representation of the object.

Inherited from java.lang.Object:: clone equals finalize getClass hashCode notify notifyAll wait wait wait

Field Detail

handlerMethod	back to summary
private final HandlerMethod handlerMethod

mapping	back to summary
private final T mapping

Constructor Detail

Match	back to summary
pack-priv Match(T mapping, HandlerMethod handlerMethod)

Method Detail

toString

back to summary

public String toString()

Overrides java.lang.Object.toString.

Doc from java.lang.Object.toString.

Returns a string representation of the object.

Returns:String

a string representation of the object.

Annotations

@Override

org.springframework.messaging.handler.invocation.reactive back to summary

private Class AbstractMethodMessageHandler.MatchComparator

Class Inheritance

extends Object
implements Comparator<AbstractMethodMessageHandler.Match<T>>

java.lang.Object
org.springframework.messaging.handler.invocation.reactive.AbstractMethodMessageHandler.MatchComparator

All Implemented Interfaces

java.util.Comparator

Field Summary

Modifier and Type	Field and Description
private final Comparator<T>	comparator

Constructor Summary

Access	Constructor and Description
pack-priv	MatchComparator(Comparator<T> comparator)

Method Summary

Modifier and Type	Method and Description
public int	compare(AbstractMethodMessageHandler.Match<T> the first object to be compared. match1, AbstractMethodMessageHandler.Match<T> the second object to be compared. match2) Implements java.util.Comparator.compare. Compares its two arguments for order.

Inherited from java.lang.Object:: clone equals finalize getClass hashCode notify notifyAll toString wait wait wait

Field Detail

comparator	back to summary
private final Comparator<T> comparator

Constructor Detail

MatchComparator	back to summary
pack-priv MatchComparator(Comparator<T> comparator)

Method Detail

compare back to summary

public int compare(AbstractMethodMessageHandler.Match<T> match1, AbstractMethodMessageHandler.Match<T> match2)

Implements java.util.Comparator.compare.

Doc from java.util.Comparator.compare.

Compares its two arguments for order. Returns a negative integer, zero, or a positive integer as the first argument is less than, equal to, or greater than the second.

The implementor must ensure that signum(compare(x, y)) == -signum(compare(y, x)) for all x and y. (This implies that compare(x, y) must throw an exception if and only if compare(y, x) throws an exception.)

The implementor must also ensure that the relation is transitive: ((compare(x, y)>0) && (compare(y, z)>0)) implies compare(x, z)>0.

Finally, the implementor must ensure that compare(x, y)==0 implies that signum(compare(x, z))==signum(compare(y, z)) for all z.

Parameters

match1:AbstractMethodMessageHandler.Match<T>: the first object to be compared.
match2:AbstractMethodMessageHandler.Match<T>: the second object to be compared.

Returns:int

a negative integer, zero, or a positive integer as the first argument is less than, equal to, or greater than the second.

Annotations

@Override

public abstract Class AbstractMethodMessageHandler<T>

Nested and Inner Type Summary

Field Summary

Constructor Summary

Method Summary

Field Detail

Constructor Detail

Method Detail

private Class AbstractMethodMessageHandler.Match<T>

Field Summary

Constructor Summary

Method Summary

Field Detail

Constructor Detail

Method Detail

private Class AbstractMethodMessageHandler.MatchComparator

Field Summary

Constructor Summary

Method Summary

Field Detail

Constructor Detail

Method Detail