Package org.springframework.messaging.handler.annotation.support

Class AbstractNamedValueMethodArgumentResolver

java.lang.Object
org.springframework.messaging.handler.annotation.support.AbstractNamedValueMethodArgumentResolver
All Implemented Interfaces:
HandlerMethodArgumentResolver
Direct Known Subclasses:
DestinationVariableMethodArgumentResolver, HeaderMethodArgumentResolver
public abstract class AbstractNamedValueMethodArgumentResolver extends Object implements HandlerMethodArgumentResolver
Abstract base class to resolve method arguments from a named value, e.g. message headers or destination variables. Named values could have one or more of a name, a required flag, and a default value.

Subclasses only need to define specific steps such as how to obtain named value details from a method parameter, how to resolve to argument values, or how to handle missing values.

A default value string can contain ${...} placeholders and Spring Expression Language #{...} expressions which will be resolved if a ConfigurableBeanFactory is supplied to the class constructor.

A ConversionService is used to convert a resolved String argument value to the expected target method parameter type.

Since:
4.0
Author:
Rossen Stoyanchev, Juergen Hoeller

  • Constructor Details

    • AbstractNamedValueMethodArgumentResolver

      protected AbstractNamedValueMethodArgumentResolver(org.springframework.core.convert.ConversionService conversionService, @Nullable org.springframework.beans.factory.config.ConfigurableBeanFactory beanFactory)
      Constructor with a ConversionService and a BeanFactory.
      Parameters:
      conversionService - conversion service for converting String values to the target method parameter type
      beanFactory - a bean factory for resolving ${...} placeholders and #{...} SpEL expressions in default values

  • Method Details

    • resolveArgument

      public Object resolveArgument(org.springframework.core.MethodParameter parameter, Message<?> message) throws Exception
      Description copied from interface: HandlerMethodArgumentResolver
      Resolves a method parameter into an argument value from a given message.
      Specified by:
      resolveArgument in interface HandlerMethodArgumentResolver
      Parameters:
      parameter - the method parameter to resolve. This parameter must have previously been passed to HandlerMethodArgumentResolver.supportsParameter(org.springframework.core.MethodParameter) which must have returned true.
      message - the currently processed message
      Returns:
      the resolved argument value, or null
      Throws:
      Exception - in case of errors with the preparation of argument values

    • createNamedValueInfo

      protected abstract AbstractNamedValueMethodArgumentResolver.NamedValueInfo createNamedValueInfo(org.springframework.core.MethodParameter parameter)
      Create the AbstractNamedValueMethodArgumentResolver.NamedValueInfo object for the given method parameter. Implementations typically retrieve the method annotation by means of MethodParameter.getParameterAnnotation(Class).
      Parameters:
      parameter - the method parameter
      Returns:
      the named value information

    • resolveArgumentInternal

      @Nullable protected abstract Object resolveArgumentInternal(org.springframework.core.MethodParameter parameter, Message<?> message, String name) throws Exception
      Resolves the given parameter type and value name into an argument value.
      Parameters:
      parameter - the method parameter to resolve to an argument value
      message - the current request
      name - the name of the value being resolved
      Returns:
      the resolved argument. May be null
      Throws:
      Exception - in case of errors

    • handleMissingValue

      protected abstract void handleMissingValue(String name, org.springframework.core.MethodParameter parameter, Message<?> message)
      Invoked when a value is required, but resolveArgumentInternal(org.springframework.core.MethodParameter, org.springframework.messaging.Message<?>, java.lang.String) returned null and there is no default value. Subclasses can throw an appropriate exception for this case.
      Parameters:
      name - the name for the value
      parameter - the target method parameter
      message - the message being processed

    • handleResolvedValue

      protected void handleResolvedValue(@Nullable Object arg, String name, org.springframework.core.MethodParameter parameter, Message<?> message)
      Invoked after a value is resolved.
      Parameters:
      arg - the resolved argument value
      name - the argument name
      parameter - the argument parameter type
      message - the message