java.lang.Object
- org.springframework.messaging.handler.annotation.reactive.PayloadMethodArgumentResolver

All Implemented Interfaces:
HandlerMethodArgumentResolver
```
public class PayloadMethodArgumentResolver
extends Object
implements HandlerMethodArgumentResolver
```
A resolver to extract and decode the payload of a message using a Decoder, where the payload is expected to be a Publisher of DataBuffer.
Validation is applied if the method argument is annotated with @javax.validation.Valid or Validated. Validation failure results in an MethodArgumentNotValidException.
This resolver should be ordered last if useDefaultResolution is set to true since in that case it supports all types and does not require the presence of Payload.
Since:
5.2
Author:
Rossen Stoyanchev

Field Summary
Fields
Modifier and Type Field Description
protected Log logger

Constructor Summary
Constructors
Constructor Description
PayloadMethodArgumentResolver(List<? extends Decoder<?>> decoders, Validator validator, ReactiveAdapterRegistry registry, boolean useDefaultResolution)

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`ReactiveAdapterRegistry`	`getAdapterRegistry()`	Return the configured `ReactiveAdapterRegistry`.
`List<Decoder<?>>`	`getDecoders()`	Return a read-only list of the configured decoders.
`protected MimeType`	`getMimeType(Message<?> message)`	Return the mime type for the content.
`Validator`	`getValidator()`	Return the configured validator, if any.
`boolean`	`isUseDefaultResolution()`	Whether this resolver is configured to use default resolution, i.e.
`reactor.core.publisher.Mono<Object>`	`resolveArgument(MethodParameter parameter, Message<?> message)`	Decode the content of the given message payload through a compatible `Decoder`.
`boolean`	`supportsParameter(MethodParameter parameter)`	Whether the given method parameter is supported by this resolver.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - logger
```
protected final Log logger
```
- Constructor Detail
  - PayloadMethodArgumentResolver
```
public PayloadMethodArgumentResolver(List<? extends Decoder<?>> decoders,
                                     @Nullable
                                     Validator validator,
                                     @Nullable
                                     ReactiveAdapterRegistry registry,
                                     boolean useDefaultResolution)
```
- Method Detail
  - getDecoders
```
public List<Decoder<?>> getDecoders()
```
    Return a read-only list of the configured decoders.
  - getValidator
```
@Nullable
public Validator getValidator()
```
    Return the configured validator, if any.
  - getAdapterRegistry
```
public ReactiveAdapterRegistry getAdapterRegistry()
```
    Return the configured ReactiveAdapterRegistry.
  - isUseDefaultResolution
```
public boolean isUseDefaultResolution()
```
    Whether this resolver is configured to use default resolution, i.e. works for any argument type regardless of whether @Payload is present or not.
  - supportsParameter
```
public boolean supportsParameter(MethodParameter parameter)
```
    Description copied from interface: HandlerMethodArgumentResolver
    Whether the given method parameter is supported by this resolver.
    Specified by:
    supportsParameter in interface HandlerMethodArgumentResolver
    Parameters:
    parameter - the method parameter to check
    Returns:
    true if this resolver supports the supplied parameter; false otherwise
  - resolveArgument
```
public final reactor.core.publisher.Mono<Object> resolveArgument(MethodParameter parameter,
                                                                 Message<?> message)
```
    Decode the content of the given message payload through a compatible Decoder.
    Validation is applied if the method argument is annotated with @javax.validation.Valid or Validated. Validation failure results in an MethodArgumentNotValidException.
    Specified by:
    resolveArgument in interface HandlerMethodArgumentResolver
    Parameters:
    parameter - the target method argument that we are decoding to
    message - the message from which the content was extracted
    Returns:
    a Mono with the result of argument resolution
    See Also:
    extractContent(MethodParameter, Message), getMimeType(Message)
  - getMimeType
```
@Nullable
protected MimeType getMimeType(Message<?> message)
```
    Return the mime type for the content. By default this method checks the MessageHeaders.CONTENT_TYPE header expecting to find a MimeType value or a String to parse to a MimeType.
    Parameters:
    message - the input message

Class PayloadMethodArgumentResolver

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

logger

Constructor Detail

PayloadMethodArgumentResolver

Method Detail

getDecoders

getValidator

getAdapterRegistry

isUseDefaultResolution

supportsParameter

resolveArgument

getMimeType