Package org.springframework.core

# Class ReactiveAdapterRegistry

java.lang.Object
org.springframework.core.ReactiveAdapterRegistry

public class ReactiveAdapterRegistry extends Object
A registry of adapters to adapt Reactive Streams `Publisher` to/from various async/reactive types such as `CompletableFuture`, RxJava `Flowable`, etc. This is designed to complement Spring's Reactor `Mono`/`Flux` support while also being usable without Reactor, for example, just for `org.reactivestreams` bridging.

By default, depending on classpath availability, adapters are registered for Reactor (including `CompletableFuture` and `Flow.Publisher` adapters), RxJava 3, Kotlin Coroutines' `Deferred` (bridged via Reactor) and SmallRye Mutiny 1.x/2.x. If Reactor is not present, a simple `Flow.Publisher` bridge will be registered.

Since:
  5.0
Author:
  Rossen Stoyanchev, Sebastien Deleuze, Juergen Hoeller

## Nested Class Summary

Nested Classes
Modifier and Type
Class
Description
`static class`
`ReactiveAdapterRegistry.SpringCoreBlockHoundIntegration`
`BlockHoundIntegration` for spring-core classes.

## Constructor Summary

Constructors
Constructor
Description
`ReactiveAdapterRegistry()`
Create a registry and auto-register default adapters.

## Method Summary

Modifier and Type
Method
Description
`ReactiveAdapter`
`getAdapter(Class<?> reactiveType)`
Get the adapter for the given reactive type.
`ReactiveAdapter`
`getAdapter(Class<?> reactiveType, Object source)`
Get the adapter for the given reactive type.
`static ReactiveAdapterRegistry`
`getSharedInstance()`
Return a shared default `ReactiveAdapterRegistry` instance, lazily building it once needed.
`boolean`
`hasAdapters()`
Return whether the registry has any adapters.
`void`
`registerReactiveType(ReactiveTypeDescriptor descriptor, Function<Object,Publisher<?>> toAdapter, Function<Publisher<?>,Object> fromAdapter)`
Register a reactive type along with functions to adapt to and from a Reactive Streams `Publisher`.
`void`
`registerReactiveTypeOverride(ReactiveTypeDescriptor descriptor, Function<Object,Publisher<?>> toAdapter, Function<Publisher<?>,Object> fromAdapter)`
Register a reactive type along with functions to adapt to and from a Reactive Streams `Publisher`.

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

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

## Constructor Details

### ReactiveAdapterRegistry

public ReactiveAdapterRegistry()
Create a registry and auto-register default adapters.

See Also:
  - `getSharedInstance()`

## Method Details

### registerReactiveType

public void registerReactiveType(ReactiveTypeDescriptor descriptor, Function<Object,Publisher<?>> toAdapter, Function<Publisher<?>,Object> fromAdapter)
Register a reactive type along with functions to adapt to and from a Reactive Streams `Publisher`. The function arguments assume that their input is neither `null` nor `Optional`.

This variant registers the new adapter after existing adapters. It will be matched for the exact reactive type if no earlier adapter was registered for the specific type, and it will be matched for assignability in a second pass if no earlier adapter had an assignable type before.

See Also:
  - `registerReactiveTypeOverride(org.springframework.core.ReactiveTypeDescriptor, java.util.function.Function<java.lang.Object, org.reactivestreams.Publisher<?>>, java.util.function.Function<org.reactivestreams.Publisher<?>, java.lang.Object>)`
  - `getAdapter(java.lang.Class<?>)`

### registerReactiveTypeOverride

public void registerReactiveTypeOverride(ReactiveTypeDescriptor descriptor, Function<Object,Publisher<?>> toAdapter, Function<Publisher<?>,Object> fromAdapter)
Register a reactive type along with functions to adapt to and from a Reactive Streams `Publisher`. The function arguments assume that their input is neither `null` nor `Optional`.

This variant registers the new adapter first, effectively overriding any previously registered adapters for the same reactive type. This allows for overriding existing adapters, in particular default adapters.

Note that existing adapters for specific types will still match before an assignability match with the new adapter. In order to override all existing matches, a new reactive type adapter needs to be registered for every specific type, not relying on subtype assignability matches.

Since:
  5.3.30
See Also:
  - `registerReactiveType(org.springframework.core.ReactiveTypeDescriptor, java.util.function.Function<java.lang.Object, org.reactivestreams.Publisher<?>>, java.util.function.Function<org.reactivestreams.Publisher<?>, java.lang.Object>)`
  - `getAdapter(java.lang.Class<?>)`

### hasAdapters

public boolean hasAdapters()
Return whether the registry has any adapters.

### getAdapter

@Nullable public ReactiveAdapter getAdapter(Class<?> reactiveType)
Get the adapter for the given reactive type.

Returns:
  the corresponding adapter, or `null` if none available

### getAdapter

@Nullable public ReactiveAdapter getAdapter(@Nullable Class<?> reactiveType, @Nullable Object source)
Get the adapter for the given reactive type. Or if a "source" object is provided, its actual type is used instead.

Parameters:
  `reactiveType` - the reactive type (may be `null` if a concrete source object is given)
  `source` - an instance of the reactive type (i.e. to adapt from; may be `null` if the reactive type is specified)
Returns:
  the corresponding adapter, or `null` if none available

### getSharedInstance

public static ReactiveAdapterRegistry getSharedInstance()
Return a shared default `ReactiveAdapterRegistry` instance, lazily building it once needed.

NOTE: We highly recommend passing a long-lived, pre-configured `ReactiveAdapterRegistry` instance for customization purposes. This accessor is only meant as a fallback for code paths that want to fall back on a default instance if one isn't provided.

Returns:
  the shared `ReactiveAdapterRegistry` instance
Since:
  5.0.2