org.springframework.web.reactive.result.method.annotation

## Class RequestMappingHandlerAdapter

- java.lang.Object
- - org.springframework.web.reactive.result.method.annotation.RequestMappingHandlerAdapter

- All Implemented Interfaces:
    Aware, InitializingBean, ApplicationContextAware, HandlerAdapter

      public class RequestMappingHandlerAdapter
      extends Object
      implements HandlerAdapter, ApplicationContextAware, InitializingBean

  Supports the invocation of `@RequestMapping` handler methods.
  Since:
    5.0
  Author:
    Rossen Stoyanchev

- - ### Constructor Summary

    Constructors
    Constructor and Description
    `RequestMappingHandlerAdapter()`

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `afterPropertiesSet()` Invoked by the containing `BeanFactory` after it has set all bean properties and satisfied `BeanFactoryAware`, `ApplicationContextAware` etc.
    `ArgumentResolverConfigurer` | `getArgumentResolverConfigurer()` Return the configured resolvers for controller method arguments.
    `List<HttpMessageReader<?>>` | `getMessageReaders()` Return the configurer for HTTP message readers.
    `ReactiveAdapterRegistry` | `getReactiveAdapterRegistry()` Return the configured registry for adapting reactive types.
    `WebBindingInitializer` | `getWebBindingInitializer()` Return the configured WebBindingInitializer, or `null` if none.
    `reactor.core.publisher.Mono<HandlerResult>` | `handle(ServerWebExchange exchange, Object handler)` Handle the request with the given handler.
    `void` | `setApplicationContext(ApplicationContext applicationContext)` A `ConfigurableApplicationContext` is expected for resolving expressions in method argument default values as well as for detecting `@ControllerAdvice` beans.
    `void` | `setArgumentResolverConfigurer(ArgumentResolverConfigurer configurer)` Configure resolvers for controller method arguments.
    `void` | `setMessageReaders(List<HttpMessageReader<?>> messageReaders)` Configure HTTP message readers to de-serialize the request body with.
    `void` | `setReactiveAdapterRegistry(ReactiveAdapterRegistry registry)` Configure the registry for adapting various reactive types.
    `void` | `setWebBindingInitializer(WebBindingInitializer webBindingInitializer)` Provide a WebBindingInitializer with "global" initialization to apply to every DataBinder instance.
    `boolean` | `supports(Object handler)` Whether this `HandlerAdapter` supports the given `handler`.

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

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

- - ### Constructor Detail

    - #### RequestMappingHandlerAdapter

          public RequestMappingHandlerAdapter()

  - ### Method Detail

    - #### setMessageReaders

          public void setMessageReaders(List<HttpMessageReader<?>> messageReaders)

      Configure HTTP message readers to de-serialize the request body with.

      By default this is set to `ServerCodecConfigurer`'s readers with defaults.

    - #### getMessageReaders

          public List<HttpMessageReader<?>> getMessageReaders()

      Return the configurer for HTTP message readers.

    - #### setWebBindingInitializer

          public void setWebBindingInitializer(@Nullable
                                               WebBindingInitializer webBindingInitializer)

      Provide a WebBindingInitializer with "global" initialization to apply to every DataBinder instance.

    - #### getWebBindingInitializer

          @Nullable
          public WebBindingInitializer getWebBindingInitializer()

      Return the configured WebBindingInitializer, or `null` if none.

    - #### setArgumentResolverConfigurer

          public void setArgumentResolverConfigurer(@Nullable
                                                    ArgumentResolverConfigurer configurer)

      Configure resolvers for controller method arguments.

    - #### getArgumentResolverConfigurer

          @Nullable
          public ArgumentResolverConfigurer getArgumentResolverConfigurer()

      Return the configured resolvers for controller method arguments.

    - #### setReactiveAdapterRegistry

          public void setReactiveAdapterRegistry(@Nullable
                                                 ReactiveAdapterRegistry registry)

      Configure the registry for adapting various reactive types.

      By default this is an instance of `ReactiveAdapterRegistry` with default settings.

    - #### getReactiveAdapterRegistry

          @Nullable
          public ReactiveAdapterRegistry getReactiveAdapterRegistry()

      Return the configured registry for adapting reactive types.

    - #### setApplicationContext

          public void setApplicationContext(ApplicationContext applicationContext)

      A `ConfigurableApplicationContext` is expected for resolving expressions in method argument default values as well as for detecting `@ControllerAdvice` beans.
      Specified by:
        `setApplicationContext` in interface `ApplicationContextAware`
      Parameters:
        `applicationContext` - the ApplicationContext object to be used by this object
      See Also:
        `BeanInitializationException`

    - #### afterPropertiesSet

          public void afterPropertiesSet()
                                  throws Exception

      Description copied from interface: `InitializingBean`
      Invoked by the containing `BeanFactory` after it has set all bean properties and satisfied `BeanFactoryAware`, `ApplicationContextAware` etc.

      This method allows the bean instance to perform validation of its overall configuration and final initialization when all bean properties have been set.

      Specified by:
        `afterPropertiesSet` in interface `InitializingBean`
      Throws:
        `Exception` - in the event of misconfiguration (such as failure to set an essential property) or if initialization fails for any other reason

    - #### supports

          public boolean supports(Object handler)

      Description copied from interface: `HandlerAdapter`
      Whether this `HandlerAdapter` supports the given `handler`.
      Specified by:
        `supports` in interface `HandlerAdapter`
      Parameters:
        `handler` - the handler object to check
      Returns:
        whether the handler is supported

    - #### handle

          public reactor.core.publisher.Mono<HandlerResult> handle(ServerWebExchange exchange,
                                                                   Object handler)

      Description copied from interface: `HandlerAdapter`
      Handle the request with the given handler.

      Implementations are encouraged to handle exceptions resulting from the invocation of a handler in order and if necessary to return an alternate result that represents an error response.

      Furthermore since an async `HandlerResult` may produce an error later during result handling implementations are also encouraged to `set an exception handler` on the `HandlerResult` so that may also be applied later after result handling.

      Specified by:
        `handle` in interface `HandlerAdapter`
      Parameters:
        `exchange` - current server exchange
        `handler` - the selected handler which must have been previously checked via `HandlerAdapter.supports(Object)`
      Returns:
        `Mono` that emits a single `HandlerResult` or none if the request has been fully handled and doesn't require further handling.