Class HandlerInspector.MethodHandlerMatcher<M>

java.lang.Object

io.fluxzero.common.handling.HandlerInspector.MethodHandlerMatcher<M>

All Implemented Interfaces:

HandlerMatcher<Object,M>

Enclosing class:

HandlerInspector

public static class HandlerInspector.MethodHandlerMatcher<M>
extends Object
implements HandlerMatcher<Object,M>

A matcher that encapsulates metadata and resolution logic for a single handler method or constructor.

Resolves parameter values using ParameterResolvers and builds a HandlerInvoker for invoking the method on a given target instance.

This matcher supports prioritization, specificity analysis, and filtering based on annotations and parameters.

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
protected class	HandlerInspector.MethodHandlerMatcher.MethodHandlerInvoker
protected static final record	HandlerInspector.MethodHandlerMatcher.Specificity

Constructor Summary

Constructors

Constructor	Description
MethodHandlerMatcher(Executable executable, Class<?> targetClass, List<ParameterResolver<? super M>> parameterResolvers, @NonNull HandlerConfiguration<? super M> config)

Method Summary

Modifier and Type	Method	Description
HandlerMethod<M>	bindHandlerMethod(Object target)	Binds this matcher to a stable target instance, if it can expose a reusable method plan.
HandlerMethodPlanner<M>	bindHandlerMethodPlanner(Object target)	Creates a planner whose invocation plans call handler methods on the supplied target instance.
HandlerMethodPlanner<M>	bindPayloadHandlerMethodPlanner()	Creates a planner for handler methods declared on the payload itself.
boolean	canHandle(M message)	Returns whether the given message can be handled by a handler instance of type T.
protected static Comparator<HandlerInspector.MethodHandlerMatcher<?>>	comparator(HandlerConfiguration<?> config)
protected static int	compare(int leftPriority, HandlerInspector.MethodHandlerMatcher.Specificity leftSpecificity, int leftParameterCount, int leftMethodIndex, Executable leftExecutable, int rightPriority, HandlerInspector.MethodHandlerMatcher.Specificity rightSpecificity, int rightParameterCount, int rightMethodIndex, Executable rightExecutable, Comparator<Executable> samePriorityMethodComparator)
protected int	compareForMessage(HandlerInspector.MethodHandlerMatcher<M> other, M message)
protected Class<?>	computeClassForSpecificity()
protected HandlerInspector.MethodHandlerMatcher.Specificity	computeSpecificity(M message)
Optional<HandlerInvoker>	getInvoker(Object target, M m)	Attempts to resolve a HandlerInvoker for the given target instance and message.
HandlerInvoker	getInvokerOrNull(Object target, M m)	Attempts to resolve a HandlerInvoker for the given target instance and message.
protected int	getPriority(Annotation annotation)
protected boolean	isPassive(Annotation annotation)
Stream<Executable>	matchingMethods(M message)	Returns a stream of methods from the target class that match the given message.
protected int	methodIndex(Method instanceMethod, Class<?> instanceType)
HandlerMethodPlan<M>	prepareHandlerMethod(Object target, M message)	Selects and prepares a handler method on the supplied target for the given message.
protected Optional<Function<Object, HandlerInvoker>>	prepareInvoker(M m)
protected Function<Object, HandlerInvoker>	prepareInvokerOrNull(M m)

Methods inherited from class Object

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

Methods inherited from interface HandlerMatcher

or

Constructor Details

MethodHandlerMatcher

public MethodHandlerMatcher(Executable executable,
 Class<?> targetClass,
 List<ParameterResolver<? super M>> parameterResolvers,
 @NonNull
 @NonNull HandlerConfiguration<? super M> config)

Method Details

comparator

protected static Comparator<HandlerInspector.MethodHandlerMatcher<?>> comparator(HandlerConfiguration<?> config)

canHandle

public boolean canHandle(M message)

Description copied from interface: HandlerMatcher

Returns whether the given message can be handled by a handler instance of type T. This is a lightweight check and may be used for fast filtering or diagnostics.

Specified by:

canHandle in interface HandlerMatcher<Object,M>

Parameters:

message - the message to check

Returns:

true if the matcher may be able to produce an invoker for the given message

matchingMethods

public Stream<Executable> matchingMethods(M message)

Description copied from interface: HandlerMatcher

Returns a stream of methods from the target class that match the given message. Typically used for diagnostics or documentation tools.

Specified by:

matchingMethods in interface HandlerMatcher<Object,M>

Parameters:

message - the message to match against

Returns:

a stream of matching Executable handler methods

prepareInvoker

protected Optional<Function<Object, HandlerInvoker>> prepareInvoker(M m)

prepareInvokerOrNull

protected Function<Object, HandlerInvoker> prepareInvokerOrNull(M m)

getInvoker

public Optional<HandlerInvoker> getInvoker(Object target,
 M m)

Description copied from interface: HandlerMatcher

Attempts to resolve a HandlerInvoker for the given target instance and message.

Specified by:

getInvoker in interface HandlerMatcher<Object,M>

Parameters:

target - the handler object

m - the message to be handled

Returns:

an optional invoker if the message is supported by the target; empty otherwise

getInvokerOrNull

public HandlerInvoker getInvokerOrNull(Object target,
 M m)

Description copied from interface: HandlerMatcher

Attempts to resolve a HandlerInvoker for the given target instance and message.

This is a lower-allocation counterpart to HandlerMatcher.getInvoker(Object, Object) for internal hot paths.

Specified by:

getInvokerOrNull in interface HandlerMatcher<Object,M>

Parameters:

target - the handler object

m - the message to be handled

Returns:

an invoker if the message is supported by the target; null otherwise

bindHandlerMethod

public HandlerMethod<M> bindHandlerMethod(Object target)

Description copied from interface: HandlerMatcher

Binds this matcher to a stable target instance, if it can expose a reusable method plan.

Most matcher implementations may return null. Returning a method is only appropriate when the method metadata and target are stable for all matching messages.

Specified by:

bindHandlerMethod in interface HandlerMatcher<Object,M>

Parameters:

target - the handler object

Returns:

a reusable handler method, or null when the matcher requires per-message invokers

prepareHandlerMethod

public HandlerMethodPlan<M> prepareHandlerMethod(Object target,
 M message)

Description copied from interface: HandlerMatcher

Selects and prepares a handler method on the supplied target for the given message.

The default uses HandlerMatcher.bindHandlerMethodPlanner(Object) when available. Returning null does not reject the message; it tells the caller to use regular per-message matching instead.

Specified by:

prepareHandlerMethod in interface HandlerMatcher<Object,M>

Parameters:

target - the object that contains the handler method

message - the representative message

Returns:

the reusable invocation plan, or null when no method matches or safe preparation is unsupported

bindHandlerMethodPlanner

public HandlerMethodPlanner<M> bindHandlerMethodPlanner(Object target)

Description copied from interface: HandlerMatcher

Creates a planner whose invocation plans call handler methods on the supplied target instance.

The planner may be cached and used concurrently. The default returns null, so matchers are not required to support prepared invocation.

Specified by:

bindHandlerMethodPlanner in interface HandlerMatcher<Object,M>

Parameters:

target - the object that contains the handler methods

Returns:

a thread-safe planner bound to the target, or null when preparation is unsupported

bindPayloadHandlerMethodPlanner

public HandlerMethodPlanner<M> bindPayloadHandlerMethodPlanner()

Description copied from interface: HandlerMatcher

Creates a planner for handler methods declared on the payload itself.

The returned planner may be reused for many payload objects. Its plans must therefore obtain the target from HandlerInput.getPayload() for every invocation and must never retain the representative payload used to select the method.

Specified by:

bindPayloadHandlerMethodPlanner in interface HandlerMatcher<Object,M>

Returns:

a thread-safe payload-target planner, or null when this matcher cannot safely prepare one

computeClassForSpecificity

protected Class<?> computeClassForSpecificity()

computeSpecificity

protected HandlerInspector.MethodHandlerMatcher.Specificity computeSpecificity(M message)

compareForMessage

protected int compareForMessage(HandlerInspector.MethodHandlerMatcher<M> other,
 M message)

methodIndex

protected int methodIndex(Method instanceMethod,
 Class<?> instanceType)

getPriority

protected int getPriority(Annotation annotation)

isPassive

protected boolean isPassive(Annotation annotation)

compare

protected static int compare(int leftPriority,
 HandlerInspector.MethodHandlerMatcher.Specificity leftSpecificity,
 int leftParameterCount,
 int leftMethodIndex,
 Executable leftExecutable,
 int rightPriority,
 HandlerInspector.MethodHandlerMatcher.Specificity rightSpecificity,
 int rightParameterCount,
 int rightMethodIndex,
 Executable rightExecutable,
 Comparator<Executable> samePriorityMethodComparator)