Class SpringBeanParameterResolver

java.lang.Object
io.fluxzero.sdk.configuration.spring.SpringBeanParameterResolver
All Implemented Interfaces:
ParameterResolver<Object>
public class SpringBeanParameterResolver extends Object implements ParameterResolver<Object>
Resolves handler method parameters annotated with Autowired from the Spring application context.

This resolver allows dependency injection of Spring-managed beans directly into handler methods. It supports both type-based and Qualifier-based resolution, and will prioritize beans marked as @Primary.

If no bean can be resolved unambiguously (e.g., multiple candidates and no qualifier or primary), the parameter is not injected and a warning is logged.

Example: 

@HandleCommand
public void handle(MyCommand command, @Autowired MyService myService) {
    myService.performAction();
}

  • Constructor Details

    • SpringBeanParameterResolver

      public SpringBeanParameterResolver()

  • Method Details

    • resolve

      public UnaryOperator<Object> resolve(Parameter p, Annotation methodAnnotation)
      Description copied from interface: ParameterResolver
      Resolves a Parameter of a handler method into a value function based on the given message.

      If the parameter cannot be resolved by this resolver and ParameterResolver.matches(Parameter, Annotation, M) is not implemented, this method must return null.

      Specified by:
      resolve in interface ParameterResolver<Object>
      Parameters:
      p - the parameter to resolve
      methodAnnotation - the annotation present on the handler method (e.g., @HandleEvent)
      Returns:
      a function that takes a message and returns a value to be injected into the method parameter, or null if the parameter cannot be resolved and ParameterResolver.matches(Parameter, Annotation, M) is not implemented.

    • matches

      public boolean matches(Parameter parameter, Annotation methodAnnotation, Object value)
      Description copied from interface: ParameterResolver
      Indicates whether the resolved value is compatible with the declared parameter type.

      This method helps determine whether the parameter can be injected for a given message. It first invokes ParameterResolver.resolve(Parameter, Annotation) and then verifies that the returned value (if any) is assignable to the parameter type.

      Specified by:
      matches in interface ParameterResolver<Object>
      Parameters:
      parameter - the parameter being checked
      methodAnnotation - the annotation on the handler method
      value - the message instance to use for resolution
      Returns:
      true if the parameter can be resolved and assigned to, false otherwise

    • computeParameterResolver

      protected UnaryOperator<Object> computeParameterResolver(Parameter p)

    • mayApply

      public boolean mayApply(Executable method, Class<?> targetClass)
      Description copied from interface: ParameterResolver
      Returns true if this resolver might apply to the given method. Implementations should perform only inexpensive checks and never throw.
      Specified by:
      mayApply in interface ParameterResolver<Object>
      Parameters:
      method - the handler method or constructor
      targetClass - the declaring or target class
      Returns:
      true if this resolver could apply, false otherwise