org.springframework.web.reactive.result.method

## Class HandlerMethodArgumentResolverSupport

- java.lang.Object
- - org.springframework.web.reactive.result.method.HandlerMethodArgumentResolverSupport

All Implemented Interfaces:
  HandlerMethodArgumentResolver

Direct Known Subclasses:
  AbstractMessageReaderArgumentResolver, AbstractNamedValueArgumentResolver, ErrorsMethodArgumentResolver, MatrixVariableMapMethodArgumentResolver, ModelAttributeMethodArgumentResolver, ModelMethodArgumentResolver, PathVariableMapMethodArgumentResolver, PrincipalMethodArgumentResolver, RequestHeaderMapMethodArgumentResolver, RequestParamMapMethodArgumentResolver, ServerWebExchangeMethodArgumentResolver, WebSessionMethodArgumentResolver

    public abstract class HandlerMethodArgumentResolverSupport
    extends Object
    implements HandlerMethodArgumentResolver

Base class for `HandlerMethodArgumentResolver` implementations with access to a `ReactiveAdapterRegistry` and methods to check for method parameter support.

Since:
  5.0
Author:
  Rossen Stoyanchev, Juergen Hoeller

### Field Summary

Fields
`protected Log` `logger`

### Constructor Summary

Constructors
`protected` `HandlerMethodArgumentResolverSupport(org.springframework.core.ReactiveAdapterRegistry adapterRegistry)`

### Method Summary

All Methods Instance Methods Concrete Methods

`protected <A extends Annotation>
boolean`

`checkAnnotatedParamNoReactiveWrapper(org.springframework.core.MethodParameter parameter, Class<A> annotationType, BiPredicate<A,Class<?>> typePredicate)`
Evaluate the `Predicate` on the method parameter type if it has the given annotation, nesting within `Optional` if necessary, but raise an `IllegalStateException` if the same matches the generic type within a reactive type wrapper.

`protected boolean` `checkParameterType(org.springframework.core.MethodParameter parameter, Predicate<Class<?>> predicate)` Evaluate the `Predicate` on the method parameter type or on the generic type within a reactive type wrapper.
`protected boolean` `checkParameterTypeNoReactiveWrapper(org.springframework.core.MethodParameter parameter, Predicate<Class<?>> predicate)` Evaluate the `Predicate` on the method parameter type but raise an `IllegalStateException` if the same matches the generic type within a reactive type wrapper.
`org.springframework.core.ReactiveAdapterRegistry` `getAdapterRegistry()` Return the configured `ReactiveAdapterRegistry`.

### Methods inherited from class java.lang.Object

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

### Methods inherited from interface org.springframework.web.reactive.result.method.HandlerMethodArgumentResolver

`resolveArgument, supportsParameter`

### Field Detail

#### logger

    protected final Log logger

### Constructor Detail

#### HandlerMethodArgumentResolverSupport

    protected HandlerMethodArgumentResolverSupport(org.springframework.core.ReactiveAdapterRegistry adapterRegistry)

### Method Detail

#### getAdapterRegistry

    public org.springframework.core.ReactiveAdapterRegistry getAdapterRegistry()

Return the configured `ReactiveAdapterRegistry`.

#### checkParameterType

    protected boolean checkParameterType(org.springframework.core.MethodParameter parameter,
                                         Predicate<Class<?>> predicate)

Evaluate the `Predicate` on the method parameter type or on the generic type within a reactive type wrapper.

#### checkParameterTypeNoReactiveWrapper

    protected boolean checkParameterTypeNoReactiveWrapper(org.springframework.core.MethodParameter parameter,
                                                          Predicate<Class<?>> predicate)

Evaluate the `Predicate` on the method parameter type but raise an `IllegalStateException` if the same matches the generic type within a reactive type wrapper.

#### checkAnnotatedParamNoReactiveWrapper

    protected <A extends Annotation> boolean checkAnnotatedParamNoReactiveWrapper(org.springframework.core.MethodParameter parameter,
                                                                                  Class<A> annotationType,
                                                                                  BiPredicate<A,Class<?>> typePredicate)

Evaluate the `Predicate` on the method parameter type if it has the given annotation, nesting within `Optional` if necessary, but raise an `IllegalStateException` if the same matches the generic type within a reactive type wrapper.