Mono (Reactor Core 3.0.7.RELEASE)

java.lang.Object
- reactor.core.publisher.Mono<T>

Type Parameters:

T - the type of the single value of this class

All Implemented Interfaces:

Publisher<T>

Direct Known Subclasses:

MonoProcessor, MonoSource
```
public abstract class Mono<T>
extends Object
implements Publisher<T>
```
A Reactive Streams Publisher with basic rx operators that completes successfully by emitting an element, or with an error.

The rx operators will offer aliases for input Mono type to preserve the "at most one" property of the resulting Mono. For instance flatMap returns a Mono, while there is a flatMapMany(java.util.function.Function<? super T, ? extends org.reactivestreams.Publisher<? extends R>>) alias with possibly more than 1 emission.
Mono<Void> should be used for Publisher that just completes without any value.
It is intended to be used in implementations and return types, input parameters should keep using raw Publisher as much as possible.
Note that using state in the java.util.function / lambdas used within Mono operators should be avoided, as these may be shared between several Subscribers.

Author:

Sebastien Deleuze, Stephane Maldini, David Karnok

See Also:

Flux

Constructor Summary

Constructors
Constructor and Description

Mono()

Constructors
Constructor and Description
`Mono()`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`<T2> Mono<Tuple2<T,T2>>`	`and(Function<T,Mono<? extends T2>> rightGenerator)` Wait for the result from this mono, use it to create a second mono via the provided `rightGenerator` function and combine both results into a `Tuple2`.
`<T2,O> Mono<O>`	`and(Function<T,Mono<? extends T2>> rightGenerator, BiFunction<T,T2,O> combinator)` Wait for the result from this mono, use it to create a second mono via the provided `rightGenerator` function and combine both results into an arbitrary `O` object, as defined by the provided `combinator` function.
`<T2> Mono<Tuple2<T,T2>>`	`and(Mono<? extends T2> other)` Combine the result from this mono and another into a `Tuple2`.
`<T2,O> Mono<O>`	`and(Mono<? extends T2> other, BiFunction<? super T,? super T2,? extends O> combinator)` Combine the result from this mono and another into an arbitrary `O` object, as defined by the provided `combinator` function.
`<P> P`	`as(Function<? super Mono<T>,P> transformer)` Transform this `Mono` into a target type.
`Mono<T>`	`awaitOnSubscribe()` Intercepts the onSubscribe call and makes sure calls to Subscription methods only happen after the child Subscriber has returned from its onSubscribe method.
`T`	`block()` Block until a next signal is received, will return null if onComplete, T if onNext, throw a Exceptions.DownstreamException if checked error or origin RuntimeException if unchecked.
`T`	`block(Duration timeout)` Block until a next signal is received, will return null if onComplete, T if onNext, throw a Exceptions.DownstreamException if checked error or origin RuntimeException if unchecked.
`T`	`blockMillis(long timeout)` Deprecated. use the `Duration` based variants instead, will be removed in 3.1.0
`Mono<T>`	`cache()` Turn this `Mono` into a hot source and cache last emitted signals for further `Subscriber`.
`Mono<T>`	`cancelOn(Scheduler scheduler)` Prepare this `Mono` so that subscribers will cancel from it on a specified `Scheduler`.
`<E> Mono<E>`	`cast(Class<E> clazz)` Cast the current `Mono` produced type into a target produced type.
`Mono<T>`	`checkpoint()` Activate assembly tracing for this particular `Mono`, in case of an error upstream of the checkpoint.
`Mono<T>`	`checkpoint(String description)` Activate assembly tracing for this particular `Mono` and give it a description that will be reflected in the assembly traceback, in case of an error upstream of the checkpoint.
`<V> Mono<V>`	`compose(Function<? super Mono<T>,? extends Publisher<V>> transformer)` Defer the given transformation to this `Mono` in order to generate a target `Mono` type.
`Flux<T>`	`concatWith(Publisher<? extends T> other)` Concatenate emissions of this `Mono` with the provided `Publisher` (no interleave).
`static <T> Mono<T>`	`create(Consumer<MonoSink<T>> callback)` Creates a deferred emitter that can be used with callback-based APIs to signal at most one value, a complete or an error signal.
`Mono<T>`	`defaultIfEmpty(T defaultV)` Provide a default unique value if this mono is completed without any data
`static <T> Mono<T>`	`defer(Supplier<? extends Mono<? extends T>> supplier)` Create a `Mono` provider that will `supply` a target `Mono` to subscribe to for each `Subscriber` downstream.
`static Mono<Long>`	`delay(Duration duration)` Create a Mono which delays an onNext signal of `duration` of given unit and complete on the global timer.
`static Mono<Long>`	`delay(Duration duration, Scheduler timer)` Create a Mono which delays an onNext signal by a given `duration` and completes.
`Mono<T>`	`delayElement(Duration delay)` Delay this `Flux` element (`Subscriber.onNext(T)` signal) by a given duration.
`Mono<T>`	`delayElement(Duration delay, Scheduler timer)` Delay this `Flux` element (`Subscriber.onNext(T)` signal) by a given `Duration`.
`Mono<T>`	`delayElementMillis(long delay)` Deprecated. use the `Duration` based variants instead, will be removed in 3.1.0
`Mono<T>`	`delayElementMillis(long delay, TimedScheduler timer)` Deprecated. use the `Duration` based variants instead, will be removed in 3.1.0
`static Mono<Long>`	`delayMillis(long duration)` Deprecated. use the `Duration` based variants instead, will be removed in 3.1.0
`static Mono<Long>`	`delayMillis(long duration, TimedScheduler timer)` Deprecated. use the `Duration` based variants instead, will be removed in 3.1.0
`Mono<T>`	`delaySubscription(Duration delay)` Delay the `subscription` to this `Mono` source until the given period elapses.
`Mono<T>`	`delaySubscription(Duration delay, Scheduler timer)` Delay the `subscription` to this `Mono` source until the given `Duration` elapses.
`<U> Mono<T>`	`delaySubscription(Publisher<U> subscriptionDelay)` Delay the subscription to this `Mono` until another `Publisher` signals a value or completes.
`Mono<T>`	`delaySubscriptionMillis(long delay)` Deprecated. use the `Duration` based variants instead, will be removed in 3.1.0
`Mono<T>`	`delaySubscriptionMillis(long delay, TimedScheduler timer)` Deprecated. use the `Duration` based variants instead, will be removed in 3.1.0
`<X> Mono<X>`	`dematerialize()` A "phantom-operator" working only if this `Mono` is a emits onNext, onError or onComplete `Signal`.
`Mono<T>`	`doAfterTerminate(BiConsumer<? super T,Throwable> afterTerminate)` Triggered after the `Mono` terminates, either by completing downstream successfully or with an error.
`Mono<T>`	`doFinally(Consumer<SignalType> onFinally)` Triggering afterthe `Mono` terminates for any reason, including cancellation.
`Mono<T>`	`doOnCancel(Runnable onCancel)` Triggered when the `Mono` is cancelled.
`Mono<T>`	`doOnEach(Consumer<? super Signal<T>> signalConsumer)` Triggers side-effects when the `Mono` emits an item, fails with an error or completes successfully.
`<E extends Throwable> Mono<T>`	`doOnError(Class<E> exceptionType, Consumer<? super E> onError)` Triggered when the `Mono` completes with an error matching the given exception type.
`Mono<T>`	`doOnError(Consumer<? super Throwable> onError)` Triggered when the `Mono` completes with an error.
`Mono<T>`	`doOnError(Predicate<? super Throwable> predicate, Consumer<? super Throwable> onError)` Triggered when the `Mono` completes with an error matching the given exception.
`Mono<T>`	`doOnNext(Consumer<? super T> onNext)` Triggered when the `Mono` emits a data successfully.
`Mono<T>`	`doOnRequest(LongConsumer consumer)` Attach a `LongConsumer` to this `Mono` that will observe any request to this `Mono`.
`Mono<T>`	`doOnSubscribe(Consumer<? super Subscription> onSubscribe)` Triggered when the `Mono` is subscribed.
`Mono<T>`	`doOnSuccess(Consumer<? super T> onSuccess)` Triggered when the `Mono` completes successfully.
`Mono<T>`	`doOnTerminate(BiConsumer<? super T,Throwable> onTerminate)` Triggered when the `Mono` terminates, either by completing successfully or with an error.
`Mono<Tuple2<Long,T>>`	`elapsed()` Map this `Mono` sequence into `Tuple2` of T1 `Long` timemillis and T2 `T` associated data.
`Mono<Tuple2<Long,T>>`	`elapsed(Scheduler scheduler)` Map this `Mono` sequence into `Tuple2` of T1 `Long` timemillis and T2 `T` associated data.
`Mono<Tuple2<Long,T>>`	`elapsed(TimedScheduler scheduler)` Deprecated. use `elapsed(Scheduler)`
`static <T> Mono<T>`	`empty()` Create a `Mono` that completes without emitting any item.
`static <T> Mono<Void>`	`empty(Publisher<T> source)` Create a new `Mono` that ignores onNext (dropping them) and only react on Completion signal.
`static <T> Mono<T>`	`error(Throwable error)` Create a `Mono` that completes with the specified error immediately after onSubscribe.
`Mono<T>`	`filter(Predicate<? super T> tester)` Test the result if any of this `Mono` and replay it if predicate returns true.
`Mono<T>`	`filterWhen(Function<? super T,? extends Publisher<Boolean>> asyncPredicate)` If this `Mono` is valued, test the value asynchronously using a generated `Publisher<Boolean>` test.
`static <T> Mono<T>`	`first(Iterable<? extends Mono<? extends T>> monos)` Pick the first result coming from any of the given monos and populate a new Mono.
`static <T> Mono<T>`	`first(Mono<? extends T>... monos)` Pick the first result coming from any of the given monos and populate a new Mono.
`<R> Flux<R>`	`flatMap(Function<? super T,? extends Publisher<? extends R>> mapper)` Deprecated. will change signature and behavior in 3.1 to reflect current `then(Function)`. flatMap will be renamed `flatMapMany(Function)`, so use that instead.
`<R> Flux<R>`	`flatMap(Function<? super T,? extends Publisher<? extends R>> mapperOnNext, Function<Throwable,? extends Publisher<? extends R>> mapperOnError, Supplier<? extends Publisher<? extends R>> mapperOnComplete)` Deprecated. will change signature and behavior in 3.1 to reflect current `then(Function)`. flatMap will be renamed `flatMapMany(Function, Function, Supplier)`, so use that instead.
`<R> Flux<R>`	`flatMapIterable(Function<? super T,? extends Iterable<? extends R>> mapper)` Transform the item emitted by this `Mono` into `Iterable`, , then forward its elements into the returned `Flux`.
`<R> Flux<R>`	`flatMapMany(Function<? super T,? extends Publisher<? extends R>> mapper)` Transform the item emitted by this `Mono` into a Publisher, then forward its emissions into the returned `Flux`.
`<R> Flux<R>`	`flatMapMany(Function<? super T,? extends Publisher<? extends R>> mapperOnNext, Function<? super Throwable,? extends Publisher<? extends R>> mapperOnError, Supplier<? extends Publisher<? extends R>> mapperOnComplete)` Transform the signals emitted by this `Mono` into a Publisher, then forward its emissions into the returned `Flux`.
`Flux<T>`	`flux()` Convert this `Mono` to a `Flux`
`static <T> Mono<T>`	`from(Publisher<? extends T> source)` Expose the specified `Publisher` with the `Mono` API, and ensure it will emit 0 or 1 item.
`static <T> Mono<T>`	`fromCallable(Callable<? extends T> supplier)` Create a `Mono` producing the value for the `Mono` using the given supplier.
`static <T> Mono<T>`	`fromCompletionStage(CompletionStage<? extends T> completionStage)` Create a `Mono` producing the value for the `Mono` using the given `CompletionStage`.
`static <I> Mono<I>`	`fromDirect(Publisher<? extends I> source)` Unchecked cardinality conversion of `Publisher` as `Mono`, supporting `Fuseable` sources.
`static <T> Mono<T>`	`fromFuture(CompletableFuture<? extends T> future)` Create a `Mono` producing the value for the `Mono` using the given `CompletableFuture`.
`static Mono<Void>`	`fromRunnable(Runnable runnable)` Create a `Mono` only producing a completion signal after using the given runnable.
`static <T> Mono<T>`	`fromSupplier(Supplier<? extends T> supplier)` Create a `Mono` producing the value for the `Mono` using the given supplier.
`<R> Mono<R>`	`handle(BiConsumer<? super T,SynchronousSink<R>> handler)` Handle the items emitted by this `Mono` by calling a biconsumer with the output sink for each onNext.
`Mono<Boolean>`	`hasElement()` Emit a single boolean true if this `Mono` has an element.
`Mono<T>`	`hide()` Hides the identity of this `Mono` instance.
`Mono<T>`	`ignoreElement()` Ignores onNext signal (dropping it) and only reacts on termination.
`static <T> Mono<T>`	`ignoreElements(Publisher<T> source)` Create a new `Mono` that ignores onNext (dropping them) and only react on Completion signal.
`static <T> Mono<T>`	`just(T data)` Create a new `Mono` that emits the specified item.
`static <T> Mono<T>`	`justOrEmpty(Optional<? extends T> data)` Create a new `Mono` that emits the specified item if `Optional.isPresent()` otherwise only emits onComplete.
`static <T> Mono<T>`	`justOrEmpty(T data)` Create a new `Mono` that emits the specified item if non null otherwise only emits onComplete.
`Mono<T>`	`log()` Observe all Reactive Streams signals and use `Logger` support to handle trace implementation.
`Mono<T>`	`log(String category)` Observe all Reactive Streams signals and use `Logger` support to handle trace implementation.
`Mono<T>`	`log(String category, Level level, boolean showOperatorLine, SignalType... options)` Observe Reactive Streams signals matching the passed filter `options` and use `Logger` support to handle trace implementation.
`Mono<T>`	`log(String category, Level level, SignalType... options)` Observe Reactive Streams signals matching the passed flags `options` and use `Logger` support to handle trace implementation.
`<R> Mono<R>`	`map(Function<? super T,? extends R> mapper)` Transform the item emitted by this `Mono` by applying a function to item emitted.
`<E extends Throwable> Mono<T>`	`mapError(Class<E> type, Function<? super E,? extends Throwable> mapper)` Deprecated. use `onErrorMap(java.util.function.Function<? super java.lang.Throwable, ? extends java.lang.Throwable>)` instead. Will be removed in 3.1.0.
`Mono<T>`	`mapError(Function<Throwable,? extends Throwable> mapper)` Deprecated. use `onErrorMap(java.util.function.Function<? super java.lang.Throwable, ? extends java.lang.Throwable>)` instead. Will be removed in 3.1.0.
`Mono<T>`	`mapError(Predicate<? super Throwable> predicate, Function<? super Throwable,? extends Throwable> mapper)` Deprecated. use `onErrorMap(java.util.function.Function<? super java.lang.Throwable, ? extends java.lang.Throwable>)` instead. Will be removed in 3.1.0.
`Mono<Signal<T>>`	`materialize()` Transform the incoming onNext, onError and onComplete signals into `Signal`.
`Flux<T>`	`mergeWith(Publisher<? extends T> other)` Merge emissions of this `Mono` with the provided `Publisher`.
`static <T> Mono<T>`	`never()` Return a `Mono` that will never signal any data, error or completion signal.
`<U> Mono<U>`	`ofType(Class<U> clazz)` Evaluate the accepted value against the given `Class` type.
`protected static <T> Mono<T>`	`onAssembly(Mono<T> source)` Invoke `Hooks` pointcut given a `Mono` and returning an eventually new `Mono`
`<E extends Throwable> Mono<T>`	`onErrorMap(Class<E> type, Function<? super E,? extends Throwable> mapper)` Transform the error emitted by this `Mono` by applying a function if the error matches the given type, otherwise let the error flow.
`Mono<T>`	`onErrorMap(Function<? super Throwable,? extends Throwable> mapper)` Transform the error emitted by this `Mono` by applying a function.
`Mono<T>`	`onErrorMap(Predicate<? super Throwable> predicate, Function<? super Throwable,? extends Throwable> mapper)` Transform the error emitted by this `Mono` by applying a function if the error matches the given predicate, otherwise let the error flow.
`<E extends Throwable> Mono<T>`	`onErrorResume(Class<E> type, Function<? super E,? extends Mono<? extends T>> fallback)` Subscribe to a returned fallback publisher when an error matching the given type occurs.
`Mono<T>`	`onErrorResume(Function<? super Throwable,? extends Mono<? extends T>> fallback)` Subscribe to a returned fallback publisher when any error occurs.
`Mono<T>`	`onErrorResume(Predicate<? super Throwable> predicate, Function<? super Throwable,? extends Mono<? extends T>> fallback)` $ * Subscribe to a returned fallback publisher when an error matching the given predicate occurs.
`<E extends Throwable> Mono<T>`	`onErrorReturn(Class<E> type, T fallbackValue)` Simply emit a captured fallback value when an error of the specified type is observed on this `Mono`.
`<E extends Throwable> Mono<T>`	`onErrorReturn(Predicate<? super Throwable> predicate, T fallbackValue)` Simply emit a captured fallback value when an error matching the given predicate is observed on this `Mono`.
`Mono<T>`	`onErrorReturn(T fallback)` Simply emit a captured fallback value when any error is observed on this `Mono`.
`Mono<T>`	`onTerminateDetach()` Detaches the both the child `Subscriber` and the `Subscription` on termination or cancellation.
`Mono<T>`	`or(Mono<? extends T> other)` Emit the any of the result from this mono or from the given mono
`<E extends Throwable> Mono<T>`	`otherwise(Class<E> type, Function<? super E,? extends Mono<? extends T>> fallback)` Deprecated. Use `onErrorResume(Class, Function)` instead. Will be removed in 3.1.0.
`Mono<T>`	`otherwise(Function<? super Throwable,? extends Mono<? extends T>> fallback)` Deprecated. Use `onErrorResume(Function)`} instead. Will be removed in 3.1.0.
`Mono<T>`	`otherwise(Predicate<? super Throwable> predicate, Function<? super Throwable,? extends Mono<? extends T>> fallback)` Deprecated. Use `onErrorResume(Predicate, Function)` instead. Will be removed in 3.1.0.
`Mono<T>`	`otherwiseIfEmpty(Mono<? extends T> alternate)` Deprecated. Use `switchIfEmpty(reactor.core.publisher.Mono<? extends T>)` instead. Will be removed in 3.1.0.
`<E extends Throwable> Mono<T>`	`otherwiseReturn(Class<E> type, T fallbackValue)` Deprecated. use `onErrorReturn(Class, Object)` instead. Will be removed in 3.1.0.
`<E extends Throwable> Mono<T>`	`otherwiseReturn(Predicate<? super Throwable> predicate, T fallbackValue)` Deprecated. use `onErrorReturn(Predicate, Object)` instead. Will be removed in 3.1.0.
`Mono<T>`	`otherwiseReturn(T fallback)` Deprecated. use `onErrorReturn(Object)` instead. Will be removed in 3.1.0.
`<R> Mono<R>`	`publish(Function<? super Mono<T>,? extends Mono<? extends R>> transform)` Shares a `Mono` for the duration of a function that may transform it and consume it as many times as necessary without causing multiple subscriptions to the upstream.
`Mono<T>`	`publishOn(Scheduler scheduler)` Run onNext, onComplete and onError on a supplied `Scheduler`
`Flux<T>`	`repeat()` Repeatedly subscribe to the source completion of the previous subscription.
`Flux<T>`	`repeat(BooleanSupplier predicate)` Repeatedly subscribe to the source if the predicate returns true after completion of the previous subscription.
`Flux<T>`	`repeat(long numRepeat)` Repeatedly subscribe to the source if the predicate returns true after completion of the previous subscription.
`Flux<T>`	`repeat(long numRepeat, BooleanSupplier predicate)` Repeatedly subscribe to the source if the predicate returns true after completion of the previous subscription.
`Flux<T>`	`repeatWhen(Function<Flux<Long>,? extends Publisher<?>> whenFactory)` Repeatedly subscribe to this `Mono` when a companion sequence signals a number of emitted elements in response to the flux completion signal.
`Mono<T>`	`repeatWhenEmpty(Function<Flux<Long>,? extends Publisher<?>> repeatFactory)` Repeatedly subscribe to this `Mono` until there is an onNext signal when a companion sequence signals a number of emitted elements.
`Mono<T>`	`repeatWhenEmpty(int maxRepeat, Function<Flux<Long>,? extends Publisher<?>> repeatFactory)` Repeatedly subscribe to this `Mono` until there is an onNext signal when a companion sequence signals a number of emitted elements.
`Mono<T>`	`retry()` Re-subscribes to this `Mono` sequence if it signals any error either indefinitely.
`Mono<T>`	`retry(long numRetries)` Re-subscribes to this `Mono` sequence if it signals any error either indefinitely or a fixed number of times.
`Mono<T>`	`retry(long numRetries, Predicate<Throwable> retryMatcher)` Re-subscribes to this `Mono` sequence up to the specified number of retries if it signals any error and the given `Predicate` matches otherwise push the error downstream.
`Mono<T>`	`retry(Predicate<Throwable> retryMatcher)` Re-subscribes to this `Mono` sequence if it signals any error and the given `Predicate` matches otherwise push the error downstream.
`Mono<T>`	`retryWhen(Function<Flux<Throwable>,? extends Publisher<?>> whenFactory)` Retries this `Mono` when a companion sequence signals an item in response to this `Mono` error signal
`static <T> Mono<Boolean>`	`sequenceEqual(Publisher<? extends T> source1, Publisher<? extends T> source2)` Returns a Mono that emits a Boolean value that indicates whether two Publisher sequences are the same by comparing the items emitted by each Publisher pairwise.
`static <T> Mono<Boolean>`	`sequenceEqual(Publisher<? extends T> source1, Publisher<? extends T> source2, BiPredicate<? super T,? super T> isEqual)` Returns a Mono that emits a Boolean value that indicates whether two Publisher sequences are the same by comparing the items emitted by each Publisher pairwise based on the results of a specified equality function.
`static <T> Mono<Boolean>`	`sequenceEqual(Publisher<? extends T> source1, Publisher<? extends T> source2, BiPredicate<? super T,? super T> isEqual, int bufferSize)` Returns a Mono that emits a Boolean value that indicates whether two Publisher sequences are the same by comparing the items emitted by each Publisher pairwise based on the results of a specified equality function.
`MonoProcessor<T>`	`subscribe()` Start the chain and request unbounded demand.
`Disposable`	`subscribe(Consumer<? super T> consumer)` Subscribe a `Consumer` to this `Mono` that will consume all the sequence.
`Disposable`	`subscribe(Consumer<? super T> consumer, Consumer<? super Throwable> errorConsumer)` Subscribe `Consumer` to this `Mono` that will consume all the sequence.
`Disposable`	`subscribe(Consumer<? super T> consumer, Consumer<? super Throwable> errorConsumer, Runnable completeConsumer)` Subscribe `Consumer` to this `Mono` that will consume all the sequence.
`Disposable`	`subscribe(Consumer<? super T> consumer, Consumer<? super Throwable> errorConsumer, Runnable completeConsumer, Consumer<? super Subscription> subscriptionConsumer)` Subscribe `Consumer` to this `Mono` that will consume all the sequence.
`Mono<T>`	`subscribeOn(Scheduler scheduler)` Run the requests to this Publisher `Mono` on a given worker assigned by the supplied `Scheduler`.
`<E extends Subscriber<? super T>> E`	`subscribeWith(E subscriber)` Subscribe the `Mono` with the givne `Subscriber` and return it.
`Mono<T>`	`switchIfEmpty(Mono<? extends T> alternate)` Provide an alternative `Mono` if this mono is completed without data
`Mono<Void>`	`then()` Return a `Mono<Void>` which only replays complete and error signals from this `Mono`.
`<R> Mono<R>`	`then(Function<? super T,? extends Mono<? extends R>> transformer)` Convert the value of `Mono` to another `Mono` possibly with another value type.
`<V> Mono<V>`	`then(Mono<V> other)` Ignore element from this `Mono` and transform its completion signal into the emission and completion signal of a provided `Mono<V>`.
`<V> Mono<V>`	`then(Supplier<? extends Mono<V>> sourceSupplier)` Deprecated. removed in 3.1, use `then(Mono)` with `defer(java.util.function.Supplier<? extends reactor.core.publisher.Mono<? extends T>>)`. The competing overload was causing confusion and the generic was not symmetric with `then(Mono)`.
`Mono<Void>`	`thenEmpty(Publisher<Void> other)` Return a `Mono<Void>` that waits for this `Mono` to complete then for a supplied `Publisher<Void>` to also complete.
`<V> Flux<V>`	`thenMany(Publisher<V> other)` Ignore element from this mono and transform the completion signal into a `Flux<V>` that will emit elements from the provided `Publisher`.
`<V> Flux<V>`	`thenMany(Supplier<? extends Publisher<V>> afterSupplier)` Deprecated. removed in 3.1, use `thenMany(Publisher)` with `defer(java.util.function.Supplier<? extends reactor.core.publisher.Mono<? extends T>>)`. The competing overload was called unnecessary by extended feedback and aligns with removing of Supplier of Publisher aliases elsewhere.
`Mono<T>`	`timeout(Duration timeout)` Signal a `TimeoutException` in case an item doesn't arrive before the given period.
`Mono<T>`	`timeout(Duration timeout, Mono<? extends T> fallback)` Switch to a fallback `Mono` in case an item doesn't arrive before the given period.
`Mono<T>`	`timeout(Duration timeout, Mono<? extends T> fallback, Scheduler timer)` Switch to a fallback `Mono` in case an item doesn't arrive before the given period.
`Mono<T>`	`timeout(Duration timeout, Scheduler timer)` Signal a `TimeoutException` error in case an item doesn't arrive before the given period.
`<U> Mono<T>`	`timeout(Publisher<U> firstTimeout)` Signal a `TimeoutException` in case the item from this `Mono` has not been emitted before the given `Publisher` emits.
`<U> Mono<T>`	`timeout(Publisher<U> firstTimeout, Mono<? extends T> fallback)` Switch to a fallback `Publisher` in case the item from this `Mono` has not been emitted before the given `Publisher` emits.
`Mono<T>`	`timeoutMillis(long timeout)` Deprecated. use the `Duration` based variants instead, will be removed in 3.1.0
`Mono<T>`	`timeoutMillis(long timeout, Mono<? extends T> fallback)` Deprecated. use the `Duration` based variants instead, will be removed in 3.1.0
`Mono<T>`	`timeoutMillis(long timeout, Mono<? extends T> fallback, TimedScheduler timer)` Deprecated. use the `Duration` based variants instead, will be removed in 3.1.0
`Mono<T>`	`timeoutMillis(long timeout, TimedScheduler timer)` Deprecated. use the `Duration` based variants instead, will be removed in 3.1.0
`Mono<Tuple2<Long,T>>`	`timestamp()` Emit a `Tuple2` pair of T1 `Long` current system time in millis and T2 `T` associated data for the eventual item from this `Mono`
`Mono<Tuple2<Long,T>>`	`timestamp(Scheduler scheduler)` Emit a `Tuple2` pair of T1 `Long` current system time in millis and T2 `T` associated data for the eventual item from this `Mono`
`Mono<Tuple2<Long,T>>`	`timestamp(TimedScheduler scheduler)` Deprecated. use `timestamp(Scheduler)`
`CompletableFuture<T>`	`toFuture()` Transform this `Mono` into a `CompletableFuture` completing on onNext or onComplete and failing on onError.
`String`	`toString()`
`<V> Mono<V>`	`transform(Function<? super Mono<T>,? extends Publisher<V>> transformer)` Transform this `Mono` in order to generate a target `Mono`.
`Mono<T>`	`untilOther(Publisher<?> anyPublisher)` Subscribe to this Mono and another Publisher, which will be used as a trigger for the emission of this Mono's element.
`Mono<T>`	`untilOtherDelayError(Publisher<?> anyPublisher)` Subscribe to this Mono and another Publisher, which will be used as a trigger for the emission of this Mono's element, mapped through a provided function.
`static <T,D> Mono<T>`	`using(Callable<? extends D> resourceSupplier, Function<? super D,? extends Mono<? extends T>> sourceSupplier, Consumer<? super D> resourceCleanup)` Uses a resource, generated by a supplier for each individual Subscriber, while streaming the value from a Mono derived from the same resource and makes sure the resource is released if the sequence terminates or the Subscriber cancels.
`static <T,D> Mono<T>`	`using(Callable<? extends D> resourceSupplier, Function<? super D,? extends Mono<? extends T>> sourceSupplier, Consumer<? super D> resourceCleanup, boolean eager)` Uses a resource, generated by a supplier for each individual Subscriber, while streaming the value from a Mono derived from the same resource and makes sure the resource is released if the sequence terminates or the Subscriber cancels.
`static <R> Mono<R>`	`when(Function<? super Object[],? extends R> combinator, Mono<?>... monos)` Aggregate given monos into a new a Mono that will be fulfilled when all of the given Monos have been fulfilled.
`static <R> Mono<R>`	`when(Iterable<? extends Mono<?>> monos, Function<? super Object[],? extends R> combinator)` Aggregate given monos into a new a Mono that will be fulfilled when all of the given Monos have been fulfilled.
`static Mono<Void>`	`when(Iterable<? extends Publisher<Void>> sources)` Aggregate given void publishers into a new a Mono that will be fulfilled when all of the given Monos have been fulfilled.
`static <T1,T2> Mono<Tuple2<T1,T2>>`	`when(Mono<? extends T1> p1, Mono<? extends T2> p2)` Merge given monos into a new a Mono that will be fulfilled when all of the given Monos have been fulfilled.
`static <T1,T2,O> Mono<O>`	`when(Mono<? extends T1> p1, Mono<? extends T2> p2, BiFunction<? super T1,? super T2,? extends O> combinator)` Merge given monos into a new a Mono that will be fulfilled when all of the given Monos have been fulfilled.
`static <T1,T2,T3> Mono<Tuple3<T1,T2,T3>>`	`when(Mono<? extends T1> p1, Mono<? extends T2> p2, Mono<? extends T3> p3)` Merge given monos into a new a Mono that will be fulfilled when all of the given Monos have been fulfilled.
`static <T1,T2,T3,T4> Mono<Tuple4<T1,T2,T3,T4>>`	`when(Mono<? extends T1> p1, Mono<? extends T2> p2, Mono<? extends T3> p3, Mono<? extends T4> p4)` Merge given monos into a new a Mono that will be fulfilled when all of the given Monos have been fulfilled.
`static <T1,T2,T3,T4,T5> Mono<Tuple5<T1,T2,T3,T4,T5>>`	`when(Mono<? extends T1> p1, Mono<? extends T2> p2, Mono<? extends T3> p3, Mono<? extends T4> p4, Mono<? extends T5> p5)` Merge given monos into a new a Mono that will be fulfilled when all of the given Monos have been fulfilled.
`static <T1,T2,T3,T4,T5,T6> Mono<Tuple6<T1,T2,T3,T4,T5,T6>>`	`when(Mono<? extends T1> p1, Mono<? extends T2> p2, Mono<? extends T3> p3, Mono<? extends T4> p4, Mono<? extends T5> p5, Mono<? extends T6> p6)` Merge given monos into a new a Mono that will be fulfilled when all of the given Monos have been fulfilled.
`static Mono<Void>`	`when(Publisher<Void>... sources)` Aggregate given void publisher into a new a Mono that will be fulfilled when all of the given sources have been fulfilled.
`static <R> Mono<R>`	`whenDelayError(Function<? super Object[],? extends R> combinator, Mono<?>... monos)` Merge given monos into a new a Mono that will be fulfilled when all of the given Monos have been fulfilled.
`static <R> Mono<R>`	`whenDelayError(Iterable<? extends Mono<?>> monos, Function<? super Object[],? extends R> combinator)` Aggregate given monos into a new a Mono that will be fulfilled when all of the given Monos have been fulfilled.
`static Mono<Void>`	`whenDelayError(Iterable<? extends Publisher<Void>> sources)` Aggregate given void publishers into a new a Mono that will be fulfilled when all of the given sources have been fulfilled.
`static <T1,T2> Mono<Tuple2<T1,T2>>`	`whenDelayError(Mono<? extends T1> p1, Mono<? extends T2> p2)` Merge given monos into a new a Mono that will be fulfilled when all of the given Monos have been fulfilled.
`static <T1,T2,T3> Mono<Tuple3<T1,T2,T3>>`	`whenDelayError(Mono<? extends T1> p1, Mono<? extends T2> p2, Mono<? extends T3> p3)` Merge given monos into a new a Mono that will be fulfilled when all of the given Mono Monos have been fulfilled.
`static <T1,T2,T3,T4> Mono<Tuple4<T1,T2,T3,T4>>`	`whenDelayError(Mono<? extends T1> p1, Mono<? extends T2> p2, Mono<? extends T3> p3, Mono<? extends T4> p4)` Merge given monos into a new a Mono that will be fulfilled when all of the given Monos have been fulfilled.
`static <T1,T2,T3,T4,T5> Mono<Tuple5<T1,T2,T3,T4,T5>>`	`whenDelayError(Mono<? extends T1> p1, Mono<? extends T2> p2, Mono<? extends T3> p3, Mono<? extends T4> p4, Mono<? extends T5> p5)` Merge given monos into a new a Mono that will be fulfilled when all of the given Monos have been fulfilled.
`static <T1,T2,T3,T4,T5,T6> Mono<Tuple6<T1,T2,T3,T4,T5,T6>>`	`whenDelayError(Mono<? extends T1> p1, Mono<? extends T2> p2, Mono<? extends T3> p3, Mono<? extends T4> p4, Mono<? extends T5> p5, Mono<? extends T6> p6)` Merge given monos into a new a Mono that will be fulfilled when all of the given Monos have been fulfilled.
`static Mono<Void>`	`whenDelayError(Publisher<Void>... sources)` Merge given void publishers into a new a Mono that will be fulfilled when all of the given sources have been fulfilled.
`static <T,V> Mono<V>`	`zip(Function<? super Object[],? extends V> combinator, Iterable<? extends Mono<? extends T>> monos)` Aggregate given monos into a new a Mono that will be fulfilled when all of the given Monos have been fulfilled.
`static <T,V> Mono<V>`	`zip(Function<? super Object[],? extends V> combinator, Mono<? extends T>... monos)` Aggregate given monos into a new a Mono that will be fulfilled when all of the given Monos have been fulfilled.

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

Methods inherited from interface org.reactivestreams.Publisher
subscribe

- Constructor Detail
 - Mono
```
public Mono()
```
- Method Detail
 - create
```
public static <T> Mono<T> create(Consumer<MonoSink<T>> callback)
```
 Creates a deferred emitter that can be used with callback-based APIs to signal at most one value, a complete or an error signal.
 Bridging legacy API involves mostly boilerplate code due to the lack of standard types and methods. There are two kinds of API surfaces: 1) addListener/removeListener and 2) callback-handler.
 1) addListener/removeListener pairs
 To work with such API one has to instantiate the listener, wire up the SingleEmitter inside it then add the listener to the source:
```
 Mono.<String>create(sink -> {
 HttpListener listener = event -> {
 if (event.getResponseCode() >= 400) {
 sink.error(new RuntimeExeption("Failed"));
 } else {
 String body = event.getBody();
 if (body.isEmpty()) {
 sink.success();
 } else {
 sink.success(body.toLowerCase());
 }
 }
 };
 
 client.addListener(listener);
 
 sink.onDispose(() -> client.removeListener(listener));
 });
 
```
 Note that this works only with single-value emitting listeners. Otherwise, all subsequent signals are dropped. You may have to add client.removeListener(this); to the listener's body.
 2) callback handler
 This requires a similar instantiation pattern such as above, but usually the successful completion and error are separated into different methods. In addition, the legacy API may or may not support some cancellation mechanism.
```
 Mono.<String>create(sink -> {
 Callback<String> callback = new Callback<String>() {
 @Override
 public void onResult(String data) {
 sink.success(data.toLowerCase());
 }
 
 @Override
 public void onError(Exception e) {
 sink.error(e);
 }
 }
 
 // without cancellation support:
 
 client.call("query", callback);
 
 // with cancellation support:
 
 AutoCloseable cancel = client.call("query", callback);
 sink.onDispose(() -> {
 try {
 cancel.close();
 } catch (Exception ex) {
 Exceptions.onErrorDropped(ex);
 }
 });
 }); 
 
```
 Type Parameters: T - The type of the value emitted Parameters: callback - the consumer who will receive a per-subscriber MonoSink. Returns: a Mono
 defer public static <T> Mono<T> defer(Supplier<? extends Mono<? extends T>> supplier) Create a Mono provider that will supply a target Mono to subscribe to for each Subscriber downstream. Type Parameters: T - the element type of the returned Mono instance Parameters: supplier - a Mono factory Returns: a new Mono factory delay public static Mono<Long> delay(Duration duration) Create a Mono which delays an onNext signal of duration of given unit and complete on the global timer. If the demand cannot be produced in time, an onError will be signalled instead. The delay is introduced through the parallel default Scheduler. Parameters: duration - the duration of the delay Returns: a new Mono delay public static Mono<Long> delay(Duration duration, Scheduler timer) Create a Mono which delays an onNext signal by a given duration and completes. If the demand cannot be produced in time, an onError will be signalled instead. Parameters: duration - the Duration of the delay timer - a time-capable Scheduler instance to run on Returns: a new Mono delayMillis @Deprecated public static Mono<Long> delayMillis(long duration) Deprecated. use the Duration based variants instead, will be removed in 3.1.0 Create a Mono which delays an onNext signal of duration milliseconds and complete. If the demand cannot be produced in time, an onError will be signalled instead. Parameters: duration - the duration in milliseconds of the delay Returns: a new Mono delayMillis @Deprecated public static Mono<Long> delayMillis(long duration, TimedScheduler timer) Deprecated. use the Duration based variants instead, will be removed in 3.1.0 Create a Mono which delays an onNext signal of duration milliseconds and complete. If the demand cannot be produced in time, an onError will be signalled instead. Parameters: duration - the duration in milliseconds of the delay timer - a time-capable Scheduler instance to run on Returns: a new Mono empty public static <T> Mono<T> empty() Create a Mono that completes without emitting any item. Type Parameters: T - the reified Subscriber type Returns: a completed Mono empty public static <T> Mono<Void> empty(Publisher<T> source) Create a new Mono that ignores onNext (dropping them) and only react on Completion signal. Type Parameters: T - the reified Publisher type Parameters: source - the to ignore Returns: a new completable Mono. error public static <T> Mono<T> error(Throwable error) Create a Mono that completes with the specified error immediately after onSubscribe. Type Parameters: T - the reified Subscriber type Parameters: error - the onError signal Returns: a failed Mono first @SafeVarargs public static <T> Mono<T> first(Mono<? extends T>... monos) Pick the first result coming from any of the given monos and populate a new Mono. Type Parameters: T - The type of the function result. Parameters: monos - The deferred monos to use. Returns: a Mono. first public static <T> Mono<T> first(Iterable<? extends Mono<? extends T>> monos) Pick the first result coming from any of the given monos and populate a new Mono. Type Parameters: T - The type of the function result. Parameters: monos - The monos to use. Returns: a Mono. from public static <T> Mono<T> from(Publisher<? extends T> source) Expose the specified Publisher with the Mono API, and ensure it will emit 0 or 1 item. The source emitter will be cancelled on the first `onNext`. Type Parameters: T - the source type Parameters: source - the Publisher source Returns: the next item emitted as a Mono fromCallable public static <T> Mono<T> fromCallable(Callable<? extends T> supplier) Create a Mono producing the value for the Mono using the given supplier. Type Parameters: T - type of the expected value Parameters: supplier - Callable that will produce the value Returns: A Mono. fromCompletionStage public static <T> Mono<T> fromCompletionStage(CompletionStage<? extends T> completionStage) Create a Mono producing the value for the Mono using the given CompletionStage. Type Parameters: T - type of the expected value Parameters: completionStage - CompletionStage that will produce the value or null to complete immediately Returns: A Mono. fromDirect public static Mono fromDirect(Publisher<? extends I> source) Unchecked cardinality conversion of Publisher as Mono, supporting Fuseable sources. Type Parameters: I - input upstream type Parameters: source - the Publisher to wrap Returns: a wrapped Mono fromFuture public static <T> Mono<T> fromFuture(CompletableFuture<? extends T> future) Create a Mono producing the value for the Mono using the given CompletableFuture. Type Parameters: T - type of the expected value Parameters: future - CompletableFuture that will produce the value or null to complete immediately Returns: A Mono. See Also: fromCompletionStage for a generalization fromRunnable public static Mono<Void> fromRunnable(Runnable runnable) Create a Mono only producing a completion signal after using the given runnable. Parameters: runnable - Runnable that will callback the completion signal Returns: A Mono. fromSupplier public static <T> Mono<T> fromSupplier(Supplier<? extends T> supplier) Create a Mono producing the value for the Mono using the given supplier. Type Parameters: T - type of the expected value Parameters: supplier - Supplier that will produce the value Returns: A Mono. ignoreElements public static <T> Mono<T> ignoreElements(Publisher<T> source) Create a new Mono that ignores onNext (dropping them) and only react on Completion signal. Type Parameters: T - the source type of the ignored data Parameters: source - the to ignore Returns: a new completable Mono. just public static <T> Mono<T> just(T data) Create a new Mono that emits the specified item. Type Parameters: T - the type of the produced item Parameters: data - the only item to onNext Returns: a Mono. justOrEmpty public static <T> Mono<T> justOrEmpty(Optional<? extends T> data) Create a new Mono that emits the specified item if Optional.isPresent() otherwise only emits onComplete. Type Parameters: T - the type of the produced item Parameters: data - the Optional item to onNext or onComplete if not present Returns: a Mono. justOrEmpty public static <T> Mono<T> justOrEmpty(T data) Create a new Mono that emits the specified item if non null otherwise only emits onComplete. Type Parameters: T - the type of the produced item Parameters: data - the item to onNext or onComplete if null Returns: a Mono. never public static <T> Mono<T> never() Return a Mono that will never signal any data, error or completion signal. Type Parameters: T - the Subscriber type target Returns: a never completing Mono sequenceEqual public static <T> Mono<Boolean> sequenceEqual(Publisher<? extends T> source1, Publisher<? extends T> source2) Returns a Mono that emits a Boolean value that indicates whether two Publisher sequences are the same by comparing the items emitted by each Publisher pairwise. Type Parameters: T - the type of items emitted by each Publisher Parameters: source1 - the first Publisher to compare source2 - the second Publisher to compare Returns: a Mono that emits a Boolean value that indicates whether the two sequences are the same sequenceEqual public static <T> Mono<Boolean> sequenceEqual(Publisher<? extends T> source1, Publisher<? extends T> source2, BiPredicate<? super T,? super T> isEqual) Returns a Mono that emits a Boolean value that indicates whether two Publisher sequences are the same by comparing the items emitted by each Publisher pairwise based on the results of a specified equality function. Type Parameters: T - the type of items emitted by each Publisher Parameters: source1 - the first Publisher to compare source2 - the second Publisher to compare isEqual - a function used to compare items emitted by each Publisher Returns: a Mono that emits a Boolean value that indicates whether the two Publisher two sequences are the same according to the specified function sequenceEqual public static <T> Mono<Boolean> sequenceEqual(Publisher<? extends T> source1, Publisher<? extends T> source2, BiPredicate<? super T,? super T> isEqual, int bufferSize) Returns a Mono that emits a Boolean value that indicates whether two Publisher sequences are the same by comparing the items emitted by each Publisher pairwise based on the results of a specified equality function. Type Parameters: T - the type of items emitted by each Publisher Parameters: source1 - the first Publisher to compare source2 - the second Publisher to compare isEqual - a function used to compare items emitted by each Publisher bufferSize - the number of items to prefetch from the first and second source Publisher Returns: a Mono that emits a Boolean value that indicates whether the two Publisher two sequences are the same according to the specified function using public static <T,D> Mono<T> using(Callable<? extends D> resourceSupplier, Function<? super D,? extends Mono<? extends T>> sourceSupplier, Consumer<? super D> resourceCleanup, boolean eager) Uses a resource, generated by a supplier for each individual Subscriber, while streaming the value from a Mono derived from the same resource and makes sure the resource is released if the sequence terminates or the Subscriber cancels. Eager resource cleanup happens just before the source termination and exceptions raised by the cleanup Consumer may override the terminal even. Non-eager cleanup will drop any exception. Type Parameters: T - emitted type D - resource type Parameters: resourceSupplier - a Callable that is called on subscribe sourceSupplier - a Mono factory derived from the supplied resource resourceCleanup - invoked on completion eager - true to clean before terminating downstream subscribers Returns: new Mono using public static <T,D> Mono<T> using(Callable<? extends D> resourceSupplier, Function<? super D,? extends Mono<? extends T>> sourceSupplier, Consumer<? super D> resourceCleanup) Uses a resource, generated by a supplier for each individual Subscriber, while streaming the value from a Mono derived from the same resource and makes sure the resource is released if the sequence terminates or the Subscriber cancels. Eager resource cleanup happens just before the source termination and exceptions raised by the cleanup Consumer may override the terminal even. Type Parameters: T - emitted type D - resource type Parameters: resourceSupplier - a Callable that is called on subscribe sourceSupplier - a Mono factory derived from the supplied resource resourceCleanup - invoked on completion Returns: new Mono untilOther public Mono<T> untilOther(Publisher<?> anyPublisher) Subscribe to this Mono and another Publisher, which will be used as a trigger for the emission of this Mono's element. That is to say, this Mono's element is delayed until the trigger Publisher emits for the first time (or terminates empty). Parameters: anyPublisher - the publisher which first emission or termination will trigger the emission of this Mono's value. Returns: this Mono, but delayed until the given publisher emits first or terminates. untilOtherDelayError public Mono<T> untilOtherDelayError(Publisher<?> anyPublisher) Subscribe to this Mono and another Publisher, which will be used as a trigger for the emission of this Mono's element, mapped through a provided function. That is to say, this Mono's element is delayed until the trigger Publisher emits for the first time (or terminates empty). Any error is delayed until all publishers have triggered, and multiple errors are combined into one. Parameters: anyPublisher - the publisher which first emission or termination will trigger the emission of this Mono's value. Returns: this Mono, but delayed until the given publisher emits first or terminates. when public static <T1,T2> Mono<Tuple2<T1,T2>> when(Mono<? extends T1> p1, Mono<? extends T2> p2) Merge given monos into a new a Mono that will be fulfilled when all of the given Monos have been fulfilled. An error will cause pending results to be cancelled and immediate error emission to the returned Mono. Type Parameters: T1 - type of the value from source1 T2 - type of the value from source2 Parameters: p1 - The first upstream Publisher to subscribe to. p2 - The second upstream Publisher to subscribe to. Returns: a Mono. when public static <T1,T2,O> Mono<O> when(Mono<? extends T1> p1, Mono<? extends T2> p2, BiFunction<? super T1,? super T2,? extends O> combinator) Merge given monos into a new a Mono that will be fulfilled when all of the given Monos have been fulfilled. An error will cause pending results to be cancelled and immediate error emission to the returned Mono. Type Parameters: T1 - type of the value from source1 T2 - type of the value from source2 O - output value Parameters: p1 - The first upstream Publisher to subscribe to. p2 - The second upstream Publisher to subscribe to. combinator - a BiFunction combinator function when both sources complete Returns: a Mono. when public static <T1,T2,T3> Mono<Tuple3<T1,T2,T3>> when(Mono<? extends T1> p1, Mono<? extends T2> p2, Mono<? extends T3> p3) Merge given monos into a new a Mono that will be fulfilled when all of the given Monos have been fulfilled. An error will cause pending results to be cancelled and immediate error emission to the returned Mono. Type Parameters: T1 - type of the value from source1 T2 - type of the value from source2 T3 - type of the value from source3 Parameters: p1 - The first upstream Publisher to subscribe to. p2 - The second upstream Publisher to subscribe to. p3 - The third upstream Publisher to subscribe to. Returns: a Mono. when public static <T1,T2,T3,T4> Mono<Tuple4<T1,T2,T3,T4>> when(Mono<? extends T1> p1, Mono<? extends T2> p2, Mono<? extends T3> p3, Mono<? extends T4> p4) Merge given monos into a new a Mono that will be fulfilled when all of the given Monos have been fulfilled. An error will cause pending results to be cancelled and immediate error emission to the returned Mono. Type Parameters: T1 - type of the value from source1 T2 - type of the value from source2 T3 - type of the value from source3 T4 - type of the value from source4 Parameters: p1 - The first upstream Publisher to subscribe to. p2 - The second upstream Publisher to subscribe to. p3 - The third upstream Publisher to subscribe to. p4 - The fourth upstream Publisher to subscribe to. Returns: a Mono. when public static <T1,T2,T3,T4,T5> Mono<Tuple5<T1,T2,T3,T4,T5>> when(Mono<? extends T1> p1, Mono<? extends T2> p2, Mono<? extends T3> p3, Mono<? extends T4> p4, Mono<? extends T5> p5) Merge given monos into a new a Mono that will be fulfilled when all of the given Monos have been fulfilled. An error will cause pending results to be cancelled and immediate error emission to the returned Mono. Type Parameters: T1 - type of the value from source1 T2 - type of the value from source2 T3 - type of the value from source3 T4 - type of the value from source4 T5 - type of the value from source5 Parameters: p1 - The first upstream Publisher to subscribe to. p2 - The second upstream Publisher to subscribe to. p3 - The third upstream Publisher to subscribe to. p4 - The fourth upstream Publisher to subscribe to. p5 - The fifth upstream Publisher to subscribe to. Returns: a Mono. when public static <T1,T2,T3,T4,T5,T6> Mono<Tuple6<T1,T2,T3,T4,T5,T6>> when(Mono<? extends T1> p1, Mono<? extends T2> p2, Mono<? extends T3> p3, Mono<? extends T4> p4, Mono<? extends T5> p5, Mono<? extends T6> p6) Merge given monos into a new a Mono that will be fulfilled when all of the given Monos have been fulfilled. An error will cause pending results to be cancelled and immediate error emission to the returned Mono. Type Parameters: T1 - type of the value from source1 T2 - type of the value from source2 T3 - type of the value from source3 T4 - type of the value from source4 T5 - type of the value from source5 T6 - type of the value from source6 Parameters: p1 - The first upstream Publisher to subscribe to. p2 - The second upstream Publisher to subscribe to. p3 - The third upstream Publisher to subscribe to. p4 - The fourth upstream Publisher to subscribe to. p5 - The fifth upstream Publisher to subscribe to. p6 - The sixth upstream Publisher to subscribe to. Returns: a Mono. when public static Mono<Void> when(Iterable<? extends Publisher<Void>> sources) Aggregate given void publishers into a new a Mono that will be fulfilled when all of the given Monos have been fulfilled. If any Mono terminates without value, the returned sequence will be terminated immediately and pending results cancelled. Parameters: sources - The sources to use. Returns: a Mono. when public static <R> Mono<R> when(Iterable<? extends Mono<?>> monos, Function<? super Object[],? extends R> combinator) Aggregate given monos into a new a Mono that will be fulfilled when all of the given Monos have been fulfilled. If any Mono terminates without value, the returned sequence will be terminated immediately and pending results cancelled. Type Parameters: R - the combined result Parameters: monos - The monos to use. combinator - the function to transform the combined array into an arbitrary object. Returns: a Mono. when @SafeVarargs public static Mono<Void> when(Publisher<Void>... sources) Aggregate given void publisher into a new a Mono that will be fulfilled when all of the given sources have been fulfilled. An error will cause pending results to be cancelled and immediate error emission to the returned Mono. Parameters: sources - The sources to use. Returns: a Mono. when public static <R> Mono<R> when(Function<? super Object[],? extends R> combinator, Mono<?>... monos) Aggregate given monos into a new a Mono that will be fulfilled when all of the given Monos have been fulfilled. An error will cause pending results to be cancelled and immediate error emission to the returned Mono. Type Parameters: R - the combined result Parameters: monos - The monos to use. combinator - the function to transform the combined array into an arbitrary object. Returns: a Mono. whenDelayError public static <T1,T2> Mono<Tuple2<T1,T2>> whenDelayError(Mono<? extends T1> p1, Mono<? extends T2> p2) Merge given monos into a new a Mono that will be fulfilled when all of the given Monos have been fulfilled. If both Monos error, the two exceptions are combined (suppressed into a combining exception). Type Parameters: T1 - type of the value from source1 T2 - type of the value from source2 Parameters: p1 - The first upstream Publisher to subscribe to. p2 - The second upstream Publisher to subscribe to. Returns: a Mono. whenDelayError public static <T1,T2,T3> Mono<Tuple3<T1,T2,T3>> whenDelayError(Mono<? extends T1> p1, Mono<? extends T2> p2, Mono<? extends T3> p3) Merge given monos into a new a Mono that will be fulfilled when all of the given Mono Monos have been fulfilled. If several Monos error, the exceptions are combined (suppressed into a combining exception). Type Parameters: T1 - type of the value from source1 T2 - type of the value from source2 T3 - type of the value from source3 Parameters: p1 - The first upstream Publisher to subscribe to. p2 - The second upstream Publisher to subscribe to. p3 - The third upstream Publisher to subscribe to. Returns: a Mono. whenDelayError public static <T1,T2,T3,T4> Mono<Tuple4<T1,T2,T3,T4>> whenDelayError(Mono<? extends T1> p1, Mono<? extends T2> p2, Mono<? extends T3> p3, Mono<? extends T4> p4) Merge given monos into a new a Mono that will be fulfilled when all of the given Monos have been fulfilled. If several Monos error, the exceptions are combined (suppressed into a combining exception). Type Parameters: T1 - type of the value from source1 T2 - type of the value from source2 T3 - type of the value from source3 T4 - type of the value from source4 Parameters: p1 - The first upstream Publisher to subscribe to. p2 - The second upstream Publisher to subscribe to. p3 - The third upstream Publisher to subscribe to. p4 - The fourth upstream Publisher to subscribe to. Returns: a Mono. whenDelayError public static <T1,T2,T3,T4,T5> Mono<Tuple5<T1,T2,T3,T4,T5>> whenDelayError(Mono<? extends T1> p1, Mono<? extends T2> p2, Mono<? extends T3> p3, Mono<? extends T4> p4, Mono<? extends T5> p5) Merge given monos into a new a Mono that will be fulfilled when all of the given Monos have been fulfilled. If several Monos error, the exceptions are combined (suppressed into a combining exception). Type Parameters: T1 - type of the value from source1 T2 - type of the value from source2 T3 - type of the value from source3 T4 - type of the value from source4 T5 - type of the value from source5 Parameters: p1 - The first upstream Publisher to subscribe to. p2 - The second upstream Publisher to subscribe to. p3 - The third upstream Publisher to subscribe to. p4 - The fourth upstream Publisher to subscribe to. p5 - The fifth upstream Publisher to subscribe to. Returns: a Mono. whenDelayError public static <T1,T2,T3,T4,T5,T6> Mono<Tuple6<T1,T2,T3,T4,T5,T6>> whenDelayError(Mono<? extends T1> p1, Mono<? extends T2> p2, Mono<? extends T3> p3, Mono<? extends T4> p4, Mono<? extends T5> p5, Mono<? extends T6> p6) Merge given monos into a new a Mono that will be fulfilled when all of the given Monos have been fulfilled. If several Monos error, the exceptions are combined (suppressed into a combining exception). Type Parameters: T1 - type of the value from source1 T2 - type of the value from source2 T3 - type of the value from source3 T4 - type of the value from source4 T5 - type of the value from source5 T6 - type of the value from source6 Parameters: p1 - The first upstream Publisher to subscribe to. p2 - The second upstream Publisher to subscribe to. p3 - The third upstream Publisher to subscribe to. p4 - The fourth upstream Publisher to subscribe to. p5 - The fifth upstream Publisher to subscribe to. p6 - The sixth upstream Publisher to subscribe to. Returns: a Mono. whenDelayError public static Mono<Void> whenDelayError(Iterable<? extends Publisher<Void>> sources) Aggregate given void publishers into a new a Mono that will be fulfilled when all of the given sources have been fulfilled. If any Publisher terminates without value, the returned sequence will be terminated immediately and pending results cancelled. If several Publishers error, the exceptions are combined (suppressed into a combining exception). Parameters: sources - The sources to use. Returns: a Mono. whenDelayError public static <R> Mono<R> whenDelayError(Iterable<? extends Mono<?>> monos, Function<? super Object[],? extends R> combinator) Aggregate given monos into a new a Mono that will be fulfilled when all of the given Monos have been fulfilled. If any Mono terminates without value, the returned sequence will be terminated immediately and pending results cancelled. If several Monos error, the exceptions are combined (suppressed into a combining exception). Type Parameters: R - the combined result Parameters: monos - The monos to use. combinator - the function to transform the combined array into an arbitrary object. Returns: a Mono. whenDelayError @SafeVarargs public static Mono<Void> whenDelayError(Publisher<Void>... sources) Merge given void publishers into a new a Mono that will be fulfilled when all of the given sources have been fulfilled. If several Publishers error, the exceptions are combined (suppressed into a combining exception). Parameters: sources - The sources to use. Returns: a Mono. whenDelayError public static <R> Mono<R> whenDelayError(Function<? super Object[],? extends R> combinator, Mono<?>... monos) Merge given monos into a new a Mono that will be fulfilled when all of the given Monos have been fulfilled. If several Monos error, the exceptions are combined (suppressed into a combining exception). Type Parameters: R - the combined result Parameters: monos - The monos to use. combinator - the function to transform the combined array into an arbitrary object. Returns: a combined Mono. zip @SafeVarargs public static <T,V> Mono<V> zip(Function<? super Object[],? extends V> combinator, Mono<? extends T>... monos) Aggregate given monos into a new a Mono that will be fulfilled when all of the given Monos have been fulfilled. If any Mono terminates without value, the returned sequence will be terminated immediately and pending results cancelled. Type Parameters: T - The super incoming type V - The type of the function result. Parameters: combinator - the combinator Function monos - The monos to use. Returns: a Mono. zip public static <T,V> Mono<V> zip(Function<? super Object[],? extends V> combinator, Iterable<? extends Mono<? extends T>> monos) Aggregate given monos into a new a Mono that will be fulfilled when all of the given Monos have been fulfilled. If any Mono terminates without value, the returned sequence will be terminated immediately and pending results cancelled. Type Parameters: T - The type of the function result. V - The result type Parameters: combinator - the combinator Function monos - The monos to use. Returns: a Mono. as public final P as(Function<? super Mono<T>,P> transformer) Transform this Mono into a target type. mono.as(Flux::from).subscribe() Type Parameters: P - the returned instance type Parameters: transformer - the Function applying this Mono Returns: the transformed Mono to instance P See Also: for a bounded conversion to {@link Publisher} and public final <T2> Mono<Tuple2<T,T2>> and(Mono<? extends T2> other) Combine the result from this mono and another into a Tuple2. Type Parameters: T2 - the element type of the other Mono instance Parameters: other - the Mono to combine with Returns: a new combined Mono See Also: when(reactor.core.publisher.Mono<? extends T1>, reactor.core.publisher.Mono<? extends T2>) and public final <T2,O> Mono<O> and(Mono<? extends T2> other, BiFunction<? super T,? super T2,? extends O> combinator) Combine the result from this mono and another into an arbitrary O object, as defined by the provided combinator function. Type Parameters: T2 - the element type of the other Mono instance O - the element type of the combination Parameters: other - the Mono to combine with combinator - a BiFunction combinator function when both sources complete Returns: a new combined Mono See Also: when(reactor.core.publisher.Mono<? extends T1>, reactor.core.publisher.Mono<? extends T2>) and public final <T2> Mono<Tuple2<T,T2>> and(Function<T,Mono<? extends T2>> rightGenerator) Wait for the result from this mono, use it to create a second mono via the provided rightGenerator function and combine both results into a Tuple2. Type Parameters: T2 - the element type of the other Mono instance Parameters: rightGenerator - the Function to generate a Mono to combine with Returns: a new combined Mono and public final <T2,O> Mono<O> and(Function<T,Mono<? extends T2>> rightGenerator, BiFunction<T,T2,O> combinator) Wait for the result from this mono, use it to create a second mono via the provided rightGenerator function and combine both results into an arbitrary O object, as defined by the provided combinator function. Type Parameters: T2 - the element type of the other Mono instance O - the element type of the combination Parameters: rightGenerator - the Function to generate a Mono to combine with combinator - a BiFunction combinator function when both sources complete Returns: a new combined Mono awaitOnSubscribe public final Mono<T> awaitOnSubscribe() Intercepts the onSubscribe call and makes sure calls to Subscription methods only happen after the child Subscriber has returned from its onSubscribe method. This helps with child Subscribers that don't expect a recursive call from onSubscribe into their onNext because, for example, they request immediately from their onSubscribe but don't finish their preparation before that and onNext runs into a half-prepared state. This can happen with non Reactor based Subscribers. Returns: non reentrant onSubscribe Mono block public T block() Block until a next signal is received, will return null if onComplete, T if onNext, throw a Exceptions.DownstreamException if checked error or origin RuntimeException if unchecked. Returns: T the result block public T block(Duration timeout) Block until a next signal is received, will return null if onComplete, T if onNext, throw a Exceptions.DownstreamException if checked error or origin RuntimeException if unchecked. If the default timeout 30 seconds has elapsed,a RuntimeException will be thrown. Note that each block() will subscribe a new single (MonoSink) subscriber, in other words, the result might miss signal from hot publishers. Parameters: timeout - maximum time period to wait for before raising a RuntimeException Returns: T the result blockMillis @Deprecated public final T blockMillis(long timeout) Deprecated. use the Duration based variants instead, will be removed in 3.1.0 Block until a next signal is received, will return null if onComplete, T if onNext, throw a Exceptions.DownstreamException if checked error or origin RuntimeException if unchecked. If the default timeout 30 seconds has elapsed, a RuntimeException will be thrown. Note that each block() will subscribe a new single (MonoSink) subscriber, in other words, the result might miss signal from hot publishers. Parameters: timeout - maximum time period to wait for in milliseconds before raising a RuntimeException Returns: T the result cast public final <E> Mono<E> cast(Class<E> clazz) Cast the current Mono produced type into a target produced type. Type Parameters: E - the Mono output type Parameters: clazz - the target type to cast to Returns: a casted Mono cache public final Mono<T> cache() Turn this Mono into a hot source and cache last emitted signals for further Subscriber. Completion and Error will also be replayed. Returns: a replaying Mono cancelOn public final Mono<T> cancelOn(Scheduler scheduler) Prepare this Mono so that subscribers will cancel from it on a specified Scheduler. Parameters: scheduler - the Scheduler to signal cancel on Returns: a scheduled cancel Mono checkpoint public final Mono<T> checkpoint() Activate assembly tracing for this particular Mono, in case of an error upstream of the checkpoint. It should be placed towards the end of the reactive chain, as errors triggered downstream of it cannot be observed and augmented with assembly trace. Returns: the assembly tracing Mono checkpoint public final Mono<T> checkpoint(String description) Activate assembly tracing for this particular Mono and give it a description that will be reflected in the assembly traceback, in case of an error upstream of the checkpoint. It should be placed towards the end of the reactive chain, as errors triggered downstream of it cannot be observed and augmented with assembly trace. The description could for example be a meaningful name for the assembled mono or a wider correlation ID. Parameters: description - a description to include in the assembly traceback. Returns: the assembly tracing Mono compose public final <V> Mono<V> compose(Function<? super Mono<T>,? extends Publisher<V>> transformer) Defer the given transformation to this Mono in order to generate a target Mono type. A transformation will occur for each Subscriber. flux.compose(Mono::from).subscribe() Type Parameters: V - the item type in the returned Publisher Parameters: transformer - the Function to immediately map this Mono into a target Mono instance. Returns: a new Mono See Also: for a loose conversion to an arbitrary type concatWith public final Flux<T> concatWith(Publisher<? extends T> other) Concatenate emissions of this Mono with the provided Publisher (no interleave). Parameters: other - the Publisher sequence to concat after this Flux Returns: a concatenated Flux defaultIfEmpty public final Mono<T> defaultIfEmpty(T defaultV) Provide a default unique value if this mono is completed without any data Parameters: defaultV - the alternate value if this sequence is empty Returns: a new Mono See Also: Flux.defaultIfEmpty(Object) delayElement public final Mono<T> delayElement(Duration delay) Delay this Flux element (Subscriber.onNext(T) signal) by a given duration. Empty monos or error signals are not delayed. Note that the scheduler on which the mono chain continues execution will be the parallel scheduler if the mono is valued, or the current scheduler if the mono completes empty or errors. Parameters: delay - period to delay each Subscriber.onNext(T) signal Returns: a delayed Mono delayElement public final Mono<T> delayElement(Duration delay, Scheduler timer) Delay this Flux element (Subscriber.onNext(T) signal) by a given Duration. Empty monos or error signals are not delayed. Note that the scheduler on which the mono chain continues execution will be the time scheduler provided if the mono is valued, or the current scheduler if the mono completes empty or errors. Parameters: delay - Duration to delay each Subscriber.onNext(T) signal timer - a time-capable Scheduler instance to delay the value signal on Returns: a delayed Mono delayElementMillis @Deprecated public final Mono<T> delayElementMillis(long delay) Deprecated. use the Duration based variants instead, will be removed in 3.1.0 Delay this Flux element (Subscriber.onNext(T) signal) by a given duration, in milliseconds. Empty monos or error signals are not delayed. Note that the scheduler on which the mono chain continues execution will be the time scheduler provided if the mono is valued, or the current scheduler if the mono completes empty or errors. Parameters: delay - period to delay each Subscriber.onNext(T) signal, in milliseconds Returns: a delayed Mono delayElementMillis @Deprecated public final Mono<T> delayElementMillis(long delay, TimedScheduler timer) Deprecated. use the Duration based variants instead, will be removed in 3.1.0 Delay this Flux element (Subscriber.onNext(T) signal) by a given duration, in milliseconds. Empty monos or error signals are not delayed. Note that the scheduler on which the mono chain continues execution will be the parallel if the mono is valued, or the current scheduler if the mono completes empty or errors. Parameters: delay - period to delay each Subscriber.onNext(T) signal, in milliseconds timer - a time-capable Scheduler instance to delay the value signal on Returns: a delayed Mono delaySubscription public final Mono<T> delaySubscription(Duration delay) Delay the subscription to this Mono source until the given period elapses. Parameters: delay - duration before subscribing this Mono Returns: a delayed Mono delaySubscription public final Mono<T> delaySubscription(Duration delay, Scheduler timer) Delay the subscription to this Mono source until the given Duration elapses. Parameters: delay - Duration before subscribing this Mono timer - a time-capable Scheduler instance to run on Returns: a delayed Mono delaySubscription public final Mono<T> delaySubscription(Publisher subscriptionDelay) Delay the subscription to this Mono until another Publisher signals a value or completes. Type Parameters: U - the other source type Parameters: subscriptionDelay - a Publisher to signal by next or complete this Publisher.subscribe(Subscriber) Returns: a delayed Mono delaySubscriptionMillis @Deprecated public final Mono<T> delaySubscriptionMillis(long delay) Deprecated. use the Duration based variants instead, will be removed in 3.1.0 Delay the subscription to this Mono source until the given period elapses. The delay is introduced through the parallel default Scheduler. Parameters: delay - period in milliseconds before subscribing this Mono Returns: a delayed Mono delaySubscriptionMillis @Deprecated public final Mono<T> delaySubscriptionMillis(long delay, TimedScheduler timer) Deprecated. use the Duration based variants instead, will be removed in 3.1.0 Delay the subscription to this Mono source until the given period elapses. The delay is introduced through the parallel default Scheduler. Parameters: delay - period in milliseconds before subscribing this Mono timer - a time-capable Scheduler instance to run on Returns: a delayed Mono dematerialize public final <X> Mono<X> dematerialize() A "phantom-operator" working only if this Mono is a emits onNext, onError or onComplete Signal. The relative Subscriber callback will be invoked, error Signal will trigger onError and complete Signal will trigger onComplete. Type Parameters: X - the dematerialized type Returns: a dematerialized Mono doAfterTerminate public final Mono<T> doAfterTerminate(BiConsumer<? super T,Throwable> afterTerminate) Triggered after the Mono terminates, either by completing downstream successfully or with an error. The arguments will be null depending on success, success with data and error: null, null : completed without data T, null : completed with data null, Throwable : failed with/without data Parameters: afterTerminate - the callback to call after Subscriber.onNext(T), Subscriber.onComplete() without preceding Subscriber.onNext(T) or Subscriber.onError(java.lang.Throwable) Returns: a new Mono doFinally public final Mono<T> doFinally(Consumer<SignalType> onFinally) Triggering afterthe Mono terminates for any reason, including cancellation. The terminating event (SignalType.ON_COMPLETE, SignalType.ON_ERROR and SignalType.CANCEL) is passed to the consumer, which is executed after the signal has been passed downstream. Note that the fact that the signal is propagated downstream before the callback is executed means that several doFinally in a row will be executed in reverse order. If you want to assert the execution of the callback please keep in mind that the Mono will complete before it is executed, so its effect might not be visible immediately after eg. a block(). Parameters: onFinally - the callback to execute after a terminal signal (complete, error or cancel) Returns: an observed Mono doOnCancel public final Mono<T> doOnCancel(Runnable onCancel) Triggered when the Mono is cancelled. Parameters: onCancel - the callback to call on Subscription.cancel() Returns: a new Mono doOnNext public final Mono<T> doOnNext(Consumer<? super T> onNext) Triggered when the Mono emits a data successfully. Parameters: onNext - the callback to call on Subscriber.onNext(T) Returns: a new Mono doOnSuccess public final Mono<T> doOnSuccess(Consumer<? super T> onSuccess) Triggered when the Mono completes successfully. null : completed without data T: completed with data Parameters: onSuccess - the callback to call on, argument is null if the Mono completes without data Subscriber.onNext(T) or Subscriber.onComplete() without preceding Subscriber.onNext(T) Returns: a new Mono doOnEach public final Mono<T> doOnEach(Consumer<? super Signal<T>> signalConsumer) Triggers side-effects when the Mono emits an item, fails with an error or completes successfully. All these events are represented as a Signal that is passed to the side-effect callback. Note that this is an advanced operator, typically used for monitoring of a Mono. Parameters: signalConsumer - the mandatory callback to call on Subscriber.onNext(Object), Subscriber.onError(Throwable) and Subscriber.onComplete() Returns: an observed Mono See Also: doOnNext(Consumer), doOnError(Consumer), materialize(), Signal doOnError public final Mono<T> doOnError(Consumer<? super Throwable> onError) Triggered when the Mono completes with an error. Parameters: onError - the error callback to call on Subscriber.onError(Throwable) Returns: a new Mono doOnError public final <E extends Throwable> Mono<T> doOnError(Class<E> exceptionType, Consumer<? super E> onError) Triggered when the Mono completes with an error matching the given exception type. Type Parameters: E - type of the error to handle Parameters: exceptionType - the type of exceptions to handle onError - the error handler for each error Returns: an observed Mono doOnError public final Mono<T> doOnError(Predicate<? super Throwable> predicate, Consumer<? super Throwable> onError) Triggered when the Mono completes with an error matching the given exception. Parameters: predicate - the matcher for exceptions to handle onError - the error handler for each error Returns: an observed Mono doOnRequest public final Mono<T> doOnRequest(LongConsumer consumer) Attach a LongConsumer to this Mono that will observe any request to this Mono. Parameters: consumer - the consumer to invoke on each request Returns: an observed Mono doOnSubscribe public final Mono<T> doOnSubscribe(Consumer<? super Subscription> onSubscribe) Triggered when the Mono is subscribed. Parameters: onSubscribe - the callback to call on Subscriber.onSubscribe(Subscription) Returns: a new Mono doOnTerminate public final Mono<T> doOnTerminate(BiConsumer<? super T,Throwable> onTerminate) Triggered when the Mono terminates, either by completing successfully or with an error. null, null : completing without data T, null : completing with data null, Throwable : failing with/without data Parameters: onTerminate - the callback to call Subscriber.onNext(T), Subscriber.onComplete() without preceding Subscriber.onNext(T) or Subscriber.onError(java.lang.Throwable) Returns: a new Mono elapsed public final Mono<Tuple2<Long,T>> elapsed() Map this Mono sequence into Tuple2 of T1 Long timemillis and T2 T associated data. The timemillis corresponds to the elapsed time between the subscribe and the first next signal. Returns: a transforming Mono that emits a tuple of time elapsed in milliseconds and matching data elapsed @Deprecated public final Mono<Tuple2<Long,T>> elapsed(TimedScheduler scheduler) Deprecated. use elapsed(Scheduler) Map this Mono sequence into Tuple2 of T1 Long timemillis and T2 T associated data. The timemillis corresponds to the elapsed time between the subscribe and the first next signal. Parameters: scheduler - a Scheduler instance to read time from Returns: a transforming Mono that emits a tuple of time elapsed in milliseconds and matching data elapsed public final Mono<Tuple2<Long,T>> elapsed(Scheduler scheduler) Map this Mono sequence into Tuple2 of T1 Long timemillis and T2 T associated data. The timemillis corresponds to the elapsed time between the subscribe and the first next signal. Parameters: scheduler - a Scheduler instance to read time from Returns: a transforming Mono that emits a tuple of time elapsed in milliseconds and matching data filter public final Mono<T> filter(Predicate<? super T> tester) Test the result if any of this Mono and replay it if predicate returns true. Otherwise complete without value. Parameters: tester - the predicate to evaluate Returns: a filtered Mono filterWhen public final Mono<T> filterWhen(Function<? super T,? extends Publisher<Boolean>> asyncPredicate) If this Mono is valued, test the value asynchronously using a generated Publisher<Boolean> test. The value from the Mono is replayed if the first item emitted by the test is true. It is dropped if the test is either empty or its first emitted value is false. Note that only the first value of the test publisher is considered, and unless it is a Mono, test will be cancelled after receiving that first value. Parameters: asyncPredicate - the function generating a Publisher of Boolean to filter the Mono with Returns: a filtered Mono flatMap @Deprecated public final <R> Flux<R> flatMap(Function<? super T,? extends Publisher<? extends R>> mapper) Deprecated. will change signature and behavior in 3.1 to reflect current then(Function). flatMap will be renamed flatMapMany(Function), so use that instead. Transform the item emitted by this Mono into a Publisher, then forward its emissions into the returned Flux. Type Parameters: R - the merged sequence type Parameters: mapper - the Function to produce a sequence of R from the the eventual passed Subscriber.onNext(T) Returns: a new Flux as the sequence is not guaranteed to be single at most flatMap @Deprecated public final <R> Flux<R> flatMap(Function<? super T,? extends Publisher<? extends R>> mapperOnNext, Function<Throwable,? extends Publisher<? extends R>> mapperOnError, Supplier<? extends Publisher<? extends R>> mapperOnComplete) Deprecated. will change signature and behavior in 3.1 to reflect current then(Function). flatMap will be renamed flatMapMany(Function, Function, Supplier), so use that instead. Transform the signals emitted by this Mono into a Publisher, then forward its emissions into the returned Flux. Type Parameters: R - the type of the produced inner sequence Parameters: mapperOnNext - the Function to call on next data and returning a sequence to merge mapperOnError - the Function to call on error signal and returning a sequence to merge mapperOnComplete - the Function to call on complete signal and returning a sequence to merge Returns: a new Flux as the sequence is not guaranteed to be single at most See Also: Flux.flatMap(Function, Function, Supplier) flatMapMany public final <R> Flux<R> flatMapMany(Function<? super T,? extends Publisher<? extends R>> mapper) Transform the item emitted by this Mono into a Publisher, then forward its emissions into the returned Flux. Type Parameters: R - the merged sequence type Parameters: mapper - the Function to produce a sequence of R from the the eventual passed Subscriber.onNext(T) Returns: a new Flux as the sequence is not guaranteed to be single at most flatMapMany public final <R> Flux<R> flatMapMany(Function<? super T,? extends Publisher<? extends R>> mapperOnNext, Function<? super Throwable,? extends Publisher<? extends R>> mapperOnError, Supplier<? extends Publisher<? extends R>> mapperOnComplete) Transform the signals emitted by this Mono into a Publisher, then forward its emissions into the returned Flux. Type Parameters: R - the type of the produced inner sequence Parameters: mapperOnNext - the Function to call on next data and returning a sequence to merge mapperOnError - the Function to call on error signal and returning a sequence to merge mapperOnComplete - the Function to call on complete signal and returning a sequence to merge Returns: a new Flux as the sequence is not guaranteed to be single at most See Also: Flux.flatMap(Function, Function, Supplier) flatMapIterable public final <R> Flux<R> flatMapIterable(Function<? super T,? extends Iterable<? extends R>> mapper) Transform the item emitted by this Mono into Iterable, , then forward its elements into the returned Flux. The prefetch argument allows to give an arbitrary prefetch size to the inner Iterable. Type Parameters: R - the merged output sequence type Parameters: mapper - the Function to transform input item into a sequence Iterable Returns: a merged Flux flux public final Flux<T> flux() Convert this Mono to a Flux Returns: a Flux variant of this Mono hasElement public final Mono<Boolean> hasElement() Emit a single boolean true if this Mono has an element. Returns: a new Mono with true if a value is emitted and false otherwise handle public final <R> Mono<R> handle(BiConsumer<? super T,SynchronousSink<R>> handler) Handle the items emitted by this Mono by calling a biconsumer with the output sink for each onNext. At most one SynchronousSink.next(Object) call must be performed and/or 0 or 1 SynchronousSink.error(Throwable) or SynchronousSink.complete(). Type Parameters: R - the transformed type Parameters: handler - the handling BiConsumer Returns: a transformed Mono hide public final Mono<T> hide() Hides the identity of this Mono instance. The main purpose of this operator is to prevent certain identity-based optimizations from happening, mostly for diagnostic purposes. Returns: a new Mono instance ignoreElement public final Mono<T> ignoreElement() Ignores onNext signal (dropping it) and only reacts on termination. Returns: a new completable Mono. log public final Mono<T> log() Observe all Reactive Streams signals and use Logger support to handle trace implementation. Default will use Level.INFO and java.util.logging. If SLF4J is available, it will be used instead. The default log category will be "Mono". A generated operator suffix will complete, e.g. "reactor.Flux.Map". Returns: a new Mono See Also: Flux.log() log public final Mono<T> log(String category) Observe all Reactive Streams signals and use Logger support to handle trace implementation. Default will use Level.INFO and java.util.logging. If SLF4J is available, it will be used instead. Parameters: category - to be mapped into logger configuration (e.g. org.springframework .reactor). If category ends with "." like "reactor.", a generated operator suffix will complete, e.g. "reactor.Flux.Map". Returns: a new Mono log public final Mono<T> log(String category, Level level, SignalType... options) Observe Reactive Streams signals matching the passed flags options and use Logger support to handle trace implementation. Default will use the passed Level and java.util.logging. If SLF4J is available, it will be used instead. Options allow fine grained filtering of the traced signal, for instance to only capture onNext and onError: mono.log("category", SignalType.ON_NEXT, SignalType.ON_ERROR) Parameters: category - to be mapped into logger configuration (e.g. org.springframework .reactor). If category ends with "." like "reactor.", a generated operator suffix will complete, e.g. "reactor.Flux.Map". level - the Level to enforce for this tracing Mono (only FINEST, FINE, INFO, WARNING and SEVERE are taken into account) options - a vararg SignalType option to filter log messages Returns: a new Mono log public final Mono<T> log(String category, Level level, boolean showOperatorLine, SignalType... options) Observe Reactive Streams signals matching the passed filter options and use Logger support to handle trace implementation. Default will use the passed Level and java.util.logging. If SLF4J is available, it will be used instead. Options allow fine grained filtering of the traced signal, for instance to only capture onNext and onError: mono.log("category", Level.INFO, SignalType.ON_NEXT, SignalType.ON_ERROR) Parameters: category - to be mapped into logger configuration (e.g. org.springframework .reactor). If category ends with "." like "reactor.", a generated operator suffix will complete, e.g. "reactor.Mono.Map". level - the Level to enforce for this tracing Mono (only FINEST, FINE, INFO, WARNING and SEVERE are taken into account) showOperatorLine - capture the current stack to display operator class/line number. options - a vararg SignalType option to filter log messages Returns: a new unaltered Mono map public final <R> Mono<R> map(Function<? super T,? extends R> mapper) Transform the item emitted by this Mono by applying a function to item emitted. Type Parameters: R - the transformed type Parameters: mapper - the transforming function Returns: a new Mono mapError @Deprecated public final Mono<T> mapError(Function<Throwable,? extends Throwable> mapper) Deprecated. use onErrorMap(java.util.function.Function<? super java.lang.Throwable, ? extends java.lang.Throwable>) instead. Will be removed in 3.1.0. Transform the error emitted by this Mono by applying a function. Parameters: mapper - the error transforming Function Returns: a transformed Mono mapError @Deprecated public final <E extends Throwable> Mono<T> mapError(Class<E> type, Function<? super E,? extends Throwable> mapper) Deprecated. use onErrorMap(java.util.function.Function<? super java.lang.Throwable, ? extends java.lang.Throwable>) instead. Will be removed in 3.1.0. Transform the error emitted by this Mono by applying a function if the error matches the given type, otherwise let the error flow. Type Parameters: E - the error type Parameters: type - the type to match mapper - the error transforming Function Returns: a transformed Mono mapError @Deprecated public final Mono<T> mapError(Predicate<? super Throwable> predicate, Function<? super Throwable,? extends Throwable> mapper) Deprecated. use onErrorMap(java.util.function.Function<? super java.lang.Throwable, ? extends java.lang.Throwable>) instead. Will be removed in 3.1.0. Transform the error emitted by this Mono by applying a function if the error matches the given predicate, otherwise let the error flow. Parameters: predicate - the error predicate mapper - the error transforming Function Returns: a transformed Mono materialize public final Mono<Signal<T>> materialize() Transform the incoming onNext, onError and onComplete signals into Signal. Since the error is materialized as a Signal, the propagation will be stopped and onComplete will be emitted. Complete signal will first emit a Signal.complete() and then effectively complete the flux. Returns: a Mono of materialized Signal mergeWith public final Flux<T> mergeWith(Publisher<? extends T> other) Merge emissions of this Mono with the provided Publisher. The element from the Mono may be interleaved with the elements of the Publisher. Parameters: other - the other Publisher to merge with Returns: a new Flux as the sequence is not guaranteed to be at most 1 onErrorMap public final Mono<T> onErrorMap(Function<? super Throwable,? extends Throwable> mapper) Transform the error emitted by this Mono by applying a function. Parameters: mapper - the error transforming Function Returns: a transformed Mono onErrorMap public final <E extends Throwable> Mono<T> onErrorMap(Class<E> type, Function<? super E,? extends Throwable> mapper) Transform the error emitted by this Mono by applying a function if the error matches the given type, otherwise let the error flow. Type Parameters: E - the error type Parameters: type - the type to match mapper - the error transforming Function Returns: a transformed Mono onErrorMap public final Mono<T> onErrorMap(Predicate<? super Throwable> predicate, Function<? super Throwable,? extends Throwable> mapper) Transform the error emitted by this Mono by applying a function if the error matches the given predicate, otherwise let the error flow. Parameters: predicate - the error predicate mapper - the error transforming Function Returns: a transformed Mono or public final Mono<T> or(Mono<? extends T> other) Emit the any of the result from this mono or from the given mono Parameters: other - the racing other Mono to compete with for the result Returns: a new Mono See Also: first(reactor.core.publisher.Mono<? extends T>...) ofType public final Mono ofType(Class clazz) Evaluate the accepted value against the given Class type. If the predicate test succeeds, the value is passed into the new Mono. If the predicate test fails, the value is ignored. Parameters: clazz - the Class type to test values against Returns: a new Mono reduced to items converted to the matched type otherwise @Deprecated public final Mono<T> otherwise(Function<? super Throwable,? extends Mono<? extends T>> fallback) Deprecated. Use onErrorResume(Function)} instead. Will be removed in 3.1.0. Subscribe to a returned fallback publisher when any error occurs. Parameters: fallback - the function to map an alternative Mono Returns: an alternating Mono on source onError otherwise @Deprecated public final <E extends Throwable> Mono<T> otherwise(Class<E> type, Function<? super E,? extends Mono<? extends T>> fallback) Deprecated. Use onErrorResume(Class, Function) instead. Will be removed in 3.1.0. Subscribe to a returned fallback publisher when an error matching the given type occurs. Type Parameters: E - the error type Parameters: type - the error type to match fallback - the Function mapping the error to a new Mono sequence Returns: a new Mono otherwise @Deprecated public final Mono<T> otherwise(Predicate<? super Throwable> predicate, Function<? super Throwable,? extends Mono<? extends T>> fallback) Deprecated. Use onErrorResume(Predicate, Function) instead. Will be removed in 3.1.0. Subscribe to a returned fallback publisher when an error matching the given type occurs. Parameters: predicate - the error predicate to match fallback - the Function mapping the error to a new Mono sequence Returns: a new Mono otherwiseIfEmpty @Deprecated public final Mono<T> otherwiseIfEmpty(Mono<? extends T> alternate) Deprecated. Use switchIfEmpty(reactor.core.publisher.Mono<? extends T>) instead. Will be removed in 3.1.0. Provide an alternative Mono if this mono is completed without data Parameters: alternate - the alternate mono if this mono is empty Returns: an alternating Mono on source onComplete without elements otherwiseReturn @Deprecated public final Mono<T> otherwiseReturn(T fallback) Deprecated. use onErrorReturn(Object) instead. Will be removed in 3.1.0. Subscribe to a returned fallback value when any error occurs. Parameters: fallback - the value to emit if an error occurs Returns: a new Mono otherwiseReturn @Deprecated public final <E extends Throwable> Mono<T> otherwiseReturn(Class<E> type, T fallbackValue) Deprecated. use onErrorReturn(Class, Object) instead. Will be removed in 3.1.0. Fallback to the given value if an error of a given type is observed on this Mono Type Parameters: E - the error type Parameters: type - the error type to match fallbackValue - alternate value on fallback Returns: a new Mono otherwiseReturn @Deprecated public final <E extends Throwable> Mono<T> otherwiseReturn(Predicate<? super Throwable> predicate, T fallbackValue) Deprecated. use onErrorReturn(Predicate, Object) instead. Will be removed in 3.1.0. Fallback to the given value if an error matching the given predicate is observed on this Mono Type Parameters: E - the error type Parameters: predicate - the error predicate to match fallbackValue - alternate value on fallback Returns: a new Mono onTerminateDetach public final Mono<T> onTerminateDetach() Detaches the both the child Subscriber and the Subscription on termination or cancellation. This should help with odd retention scenarios when running with non-reactor Subscriber. Returns: a detachable Mono publish public final <R> Mono<R> publish(Function<? super Mono<T>,? extends Mono<? extends R>> transform) Shares a Mono for the duration of a function that may transform it and consume it as many times as necessary without causing multiple subscriptions to the upstream. Type Parameters: R - the output value type Parameters: transform - the tranformation function Returns: a new Mono publishOn public final Mono<T> publishOn(Scheduler scheduler) Run onNext, onComplete and onError on a supplied Scheduler Typically used for fast publisher, slow consumer(s) scenarios. mono.publishOn(Schedulers.single()).subscribe() Parameters: scheduler - a checked Scheduler.Worker factory Returns: an asynchronously producing Mono repeat public final Flux<T> repeat() Repeatedly subscribe to the source completion of the previous subscription. Returns: an indefinitively repeated Flux on onComplete repeat public final Flux<T> repeat(BooleanSupplier predicate) Repeatedly subscribe to the source if the predicate returns true after completion of the previous subscription. Parameters: predicate - the boolean to evaluate on onComplete. Returns: an eventually repeated Flux on onComplete repeat public final Flux<T> repeat(long numRepeat) Repeatedly subscribe to the source if the predicate returns true after completion of the previous subscription. Parameters: numRepeat - the number of times to re-subscribe on onComplete Returns: an eventually repeated Flux on onComplete up to number of repeat specified repeat public final Flux<T> repeat(long numRepeat, BooleanSupplier predicate) Repeatedly subscribe to the source if the predicate returns true after completion of the previous subscription. A specified maximum of repeat will limit the number of re-subscribe. Parameters: numRepeat - the number of times to re-subscribe on complete predicate - the boolean to evaluate on onComplete Returns: an eventually repeated Flux on onComplete up to number of repeat specified OR matching predicate repeatWhen public final Flux<T> repeatWhen(Function<Flux<Long>,? extends Publisher<?>> whenFactory) Repeatedly subscribe to this Mono when a companion sequence signals a number of emitted elements in response to the flux completion signal. If the companion sequence signals when this Mono is active, the repeat attempt is suppressed and any terminal signal will terminate this Flux with the same signal immediately. Parameters: whenFactory - the Function providing a Flux signalling an exclusive number of emitted elements on onComplete and returning a Publisher companion. Returns: an eventually repeated Flux on onComplete when the companion Publisher produces an onNext signal repeatWhenEmpty public final Mono<T> repeatWhenEmpty(Function<Flux<Long>,? extends Publisher<?>> repeatFactory) Repeatedly subscribe to this Mono until there is an onNext signal when a companion sequence signals a number of emitted elements. If the companion sequence signals when this Mono is active, the repeat attempt is suppressed and any terminal signal will terminate this Mono with the same signal immediately. Parameters: repeatFactory - the Function providing a Flux signalling the current number of repeat on onComplete and returning a Publisher companion. Returns: an eventually repeated Mono on onComplete when the companion Publisher produces an onNext signal repeatWhenEmpty public final Mono<T> repeatWhenEmpty(int maxRepeat, Function<Flux<Long>,? extends Publisher<?>> repeatFactory) Repeatedly subscribe to this Mono until there is an onNext signal when a companion sequence signals a number of emitted elements. If the companion sequence signals when this Mono is active, the repeat attempt is suppressed and any terminal signal will terminate this Mono with the same signal immediately. Emits an IllegalStateException if the max repeat is exceeded and different from Integer.MAX_VALUE. Parameters: maxRepeat - the maximum repeat number of time (infinite if Integer.MAX_VALUE) repeatFactory - the Function providing a Flux signalling the current repeat index from 0 on onComplete and returning a Publisher companion. Returns: an eventually repeated Mono on onComplete when the companion Publisher produces an onNext signal retry public final Mono<T> retry() Re-subscribes to this Mono sequence if it signals any error either indefinitely. The times == Long.MAX_VALUE is treated as infinite retry. Returns: a re-subscribing Mono on onError retry public final Mono<T> retry(long numRetries) Re-subscribes to this Mono sequence if it signals any error either indefinitely or a fixed number of times. The times == Long.MAX_VALUE is treated as infinite retry. Parameters: numRetries - the number of times to tolerate an error Returns: a re-subscribing Mono on onError up to the specified number of retries. retry public final Mono<T> retry(Predicate<Throwable> retryMatcher) Re-subscribes to this Mono sequence if it signals any error and the given Predicate matches otherwise push the error downstream. Parameters: retryMatcher - the predicate to evaluate if retry should occur based on a given error signal Returns: a re-subscribing Mono on onError if the predicates matches. retry public final Mono<T> retry(long numRetries, Predicate<Throwable> retryMatcher) Re-subscribes to this Mono sequence up to the specified number of retries if it signals any error and the given Predicate matches otherwise push the error downstream. Parameters: numRetries - the number of times to tolerate an error retryMatcher - the predicate to evaluate if retry should occur based on a given error signal Returns: a re-subscribing Mono on onError up to the specified number of retries and if the predicate matches. retryWhen public final Mono<T> retryWhen(Function<Flux<Throwable>,? extends Publisher<?>> whenFactory) Retries this Mono when a companion sequence signals an item in response to this Mono error signal If the companion sequence signals when the Mono is active, the retry attempt is suppressed and any terminal signal will terminate the Mono source with the same signal immediately. Parameters: whenFactory - the Function providing a Flux signalling any error from the source sequence and returning a Publisher companion. Returns: a re-subscribing Mono on onError when the companion Publisher produces an onNext signal subscribe public final MonoProcessor<T> subscribe() Start the chain and request unbounded demand. Returns: a Runnable task to execute to dispose and cancel the underlying Subscription subscribe public final Disposable subscribe(Consumer<? super T> consumer) Subscribe a Consumer to this Mono that will consume all the sequence. For a passive version that observe and forward incoming data see doOnSuccess(Consumer) and doOnError(java.util.function.Consumer). Parameters: consumer - the consumer to invoke on each value Returns: a new Runnable to dispose the Subscription subscribe public final Disposable subscribe(Consumer<? super T> consumer, Consumer<? super Throwable> errorConsumer) Subscribe Consumer to this Mono that will consume all the sequence. For a passive version that observe and forward incoming data see doOnSuccess(Consumer) and doOnError(java.util.function.Consumer). Parameters: consumer - the consumer to invoke on each next signal errorConsumer - the consumer to invoke on error signal Returns: a new Runnable to dispose the Subscription subscribe public final Disposable subscribe(Consumer<? super T> consumer, Consumer<? super Throwable> errorConsumer, Runnable completeConsumer) Subscribe Consumer to this Mono that will consume all the sequence. For a passive version that observe and forward incoming data see doOnSuccess(Consumer) and doOnError(java.util.function.Consumer). Parameters: consumer - the consumer to invoke on each value errorConsumer - the consumer to invoke on error signal completeConsumer - the consumer to invoke on complete signal Returns: a new Disposable to dispose the Subscription subscribe public final Disposable subscribe(Consumer<? super T> consumer, Consumer<? super Throwable> errorConsumer, Runnable completeConsumer, Consumer<? super Subscription> subscriptionConsumer) Subscribe Consumer to this Mono that will consume all the sequence. For a passive version that observe and forward incoming data see doOnSuccess(Consumer) and doOnError(java.util.function.Consumer). Parameters: consumer - the consumer to invoke on each value errorConsumer - the consumer to invoke on error signal completeConsumer - the consumer to invoke on complete signal subscriptionConsumer - the consumer to invoke on subscribe signal, to be used for the initial request, or null for max request Returns: a new Disposable to dispose the Subscription subscribeOn public final Mono<T> subscribeOn(Scheduler scheduler) Run the requests to this Publisher Mono on a given worker assigned by the supplied Scheduler. mono.subscribeOn(Schedulers.parallel()).subscribe()) Parameters: scheduler - a checked Scheduler.Worker factory Returns: an asynchronously requesting Mono subscribeWith public final <E extends Subscriber<? super T>> E subscribeWith(E subscriber) Subscribe the Mono with the givne Subscriber and return it. Type Parameters: E - the reified type of the Subscriber for chaining Parameters: subscriber - the Subscriber to subscribe Returns: the passed Subscriber after subscribing it to this Mono onErrorResume public final Mono<T> onErrorResume(Function<? super Throwable,? extends Mono<? extends T>> fallback) Subscribe to a returned fallback publisher when any error occurs. Parameters: fallback - the function to map an alternative Mono Returns: an alternating Mono on source onError See Also: Flux.onErrorResume(java.util.function.Function<? super java.lang.Throwable, ? extends org.reactivestreams.Publisher<? extends T>>) onErrorResume public final <E extends Throwable> Mono<T> onErrorResume(Class<E> type, Function<? super E,? extends Mono<? extends T>> fallback) Subscribe to a returned fallback publisher when an error matching the given type occurs. Type Parameters: E - the error type Parameters: type - the error type to match fallback - the Function mapping the error to a new Mono sequence Returns: a new Mono See Also: Flux.onErrorResume(java.util.function.Function<? super java.lang.Throwable, ? extends org.reactivestreams.Publisher<? extends T>>) onErrorResume public final Mono<T> onErrorResume(Predicate<? super Throwable> predicate, Function<? super Throwable,? extends Mono<? extends T>> fallback) $ * Subscribe to a returned fallback publisher when an error matching the given predicate occurs. Parameters: predicate - the error predicate to match fallback - the Function mapping the error to a new Mono sequence Returns: a new Mono See Also: Flux.onErrorResume(java.util.function.Function<? super java.lang.Throwable, ? extends org.reactivestreams.Publisher<? extends T>>) onErrorReturn public final Mono<T> onErrorReturn(T fallback) Simply emit a captured fallback value when any error is observed on this Mono. Parameters: fallback - the value to emit if an error occurs Returns: a new falling back Mono onErrorReturn public final <E extends Throwable> Mono<T> onErrorReturn(Class<E> type, T fallbackValue) Simply emit a captured fallback value when an error of the specified type is observed on this Mono. Type Parameters: E - the error type Parameters: type - the error type to match fallbackValue - the value to emit if a matching error occurs Returns: a new falling back Mono onErrorReturn public final <E extends Throwable> Mono<T> onErrorReturn(Predicate<? super Throwable> predicate, T fallbackValue) Simply emit a captured fallback value when an error matching the given predicate is observed on this Mono. Type Parameters: E - the error type Parameters: predicate - the error predicate to match fallbackValue - the value to emit if a matching error occurs Returns: a new Mono switchIfEmpty public final Mono<T> switchIfEmpty(Mono<? extends T> alternate) Provide an alternative Mono if this mono is completed without data Parameters: alternate - the alternate mono if this mono is empty Returns: an alternating Mono on source onComplete without elements See Also: Flux.switchIfEmpty(org.reactivestreams.Publisher<? extends T>) then public final Mono<Void> then() Return a Mono<Void> which only replays complete and error signals from this Mono. Returns: a Mono igoring its payload (actively dropping) then public final <R> Mono<R> then(Function<? super T,? extends Mono<? extends R>> transformer) Convert the value of Mono to another Mono possibly with another value type. Type Parameters: R - the result type bound Parameters: transformer - the function to dynamically bind a new Mono Returns: a new Mono containing the merged values API Note: in 3.1.0.M1 this method will be renamed `flatMap`. However, until then the behavior of flatMap(Function) remains the current one, so it is not yet possible to anticipate this migration. then public final <V> Mono<V> then(Mono<V> other) Ignore element from this Mono and transform its completion signal into the emission and completion signal of a provided Mono<V>. Error signal is replayed in the resulting Mono<V>. Type Parameters: V - the element type of the supplied Mono Parameters: other - a Mono to emit from after termination Returns: a new Mono that emits from the supplied Mono then @Deprecated public final <V> Mono<V> then(Supplier<? extends Mono<V>> sourceSupplier) Deprecated. removed in 3.1, use then(Mono) with defer(java.util.function.Supplier<? extends reactor.core.publisher.Mono<? extends T>>). The competing overload was causing confusion and the generic was not symmetric with then(Mono). Ignore element from this Mono and transform its completion signal into the emission and completion signal of a supplied Mono<V>. Error signal is replayed in the resulting Mono<V>. Type Parameters: V - the element type of the supplied Mono Parameters: sourceSupplier - a Supplier of Mono to emit from after termination Returns: a new Mono that emits from the supplied Mono thenEmpty public final Mono<Void> thenEmpty(Publisher<Void> other) Return a Mono<Void> that waits for this Mono to complete then for a supplied Publisher<Void> to also complete. The second completion signal is replayed, or any error signal that occurs instead. Parameters: other - a Publisher to wait for after this Mono's termination Returns: a new Mono completing when both publishers have completed in sequence thenMany public final <V> Flux<V> thenMany(Publisher<V> other) Ignore element from this mono and transform the completion signal into a Flux<V> that will emit elements from the provided Publisher. Type Parameters: V - the element type of the supplied Publisher Parameters: other - a Publisher to emit from after termination Returns: a new Flux that emits from the supplied Publisher after this Mono completes. thenMany @Deprecated public final <V> Flux<V> thenMany(Supplier<? extends Publisher<V>> afterSupplier) Deprecated. removed in 3.1, use thenMany(Publisher) with defer(java.util.function.Supplier<? extends reactor.core.publisher.Mono<? extends T>>). The competing overload was called unnecessary by extended feedback and aligns with removing of Supplier of Publisher aliases elsewhere. Ignore element from this mono and transform the completion signal into a Flux<V> that will emit elements from the supplier-provided Publisher. Type Parameters: V - the element type of the supplied Publisher Parameters: afterSupplier - a Supplier of Publisher to emit from after completion Returns: a new Flux that emits from the supplied Publisher timeout public final Mono<T> timeout(Duration timeout) Signal a TimeoutException in case an item doesn't arrive before the given period. Parameters: timeout - the timeout before the onNext signal from this Mono Returns: an expirable Mono timeout public final Mono<T> timeout(Duration timeout, Mono<? extends T> fallback) Switch to a fallback Mono in case an item doesn't arrive before the given period. If the given Publisher is null, signal a TimeoutException. Parameters: timeout - the timeout before the onNext signal from this Mono fallback - the fallback Mono to subscribe when a timeout occurs Returns: an expirable Mono with a fallback Mono timeout public final Mono<T> timeout(Duration timeout, Scheduler timer) Signal a TimeoutException error in case an item doesn't arrive before the given period. Parameters: timeout - the timeout before the onNext signal from this Mono timer - a time-capable Scheduler instance to run on Returns: an expirable Mono timeout public final Mono<T> timeout(Duration timeout, Mono<? extends T> fallback, Scheduler timer) Switch to a fallback Mono in case an item doesn't arrive before the given period. If the given Publisher is null, signal a TimeoutException. Parameters: timeout - the timeout before the onNext signal from this Mono fallback - the fallback Mono to subscribe when a timeout occurs timer - a time-capable Scheduler instance to run on Returns: an expirable Mono with a fallback Mono timeout public final Mono<T> timeout(Publisher firstTimeout) Signal a TimeoutException in case the item from this Mono has not been emitted before the given Publisher emits. Type Parameters: U - the element type of the timeout Publisher Parameters: firstTimeout - the timeout Publisher that must not emit before the first signal from this Mono Returns: an expirable Mono if the first item does not come before a Publisher signal timeout public final Mono<T> timeout(Publisher firstTimeout, Mono<? extends T> fallback) Switch to a fallback Publisher in case the item from this Mono has not been emitted before the given Publisher emits. The following items will be individually timed via the factory provided Publisher. Type Parameters: U - the element type of the timeout Publisher Parameters: firstTimeout - the timeout Publisher that must not emit before the first signal from this Mono fallback - the fallback Publisher to subscribe when a timeout occurs Returns: a first then per-item expirable Mono with a fallback Publisher timeoutMillis @Deprecated public final Mono<T> timeoutMillis(long timeout) Deprecated. use the Duration based variants instead, will be removed in 3.1.0 Signal a TimeoutException error in case an item doesn't arrive before the given period. Parameters: timeout - the timeout before the onNext signal from this Mono Returns: an expirable Mono timeoutMillis @Deprecated public final Mono<T> timeoutMillis(long timeout, TimedScheduler timer) Deprecated. use the Duration based variants instead, will be removed in 3.1.0 Signal a TimeoutException error in case an item doesn't arrive before the given period. Parameters: timeout - the timeout before the onNext signal from this Mono timer - a time-capable Scheduler instance to run on Returns: an expirable Mono timeoutMillis @Deprecated public final Mono<T> timeoutMillis(long timeout, Mono<? extends T> fallback) Deprecated. use the Duration based variants instead, will be removed in 3.1.0 Switch to a fallback Mono in case an item doesn't arrive before the given period. If the given Publisher is null, signal a TimeoutException. Parameters: timeout - the timeout before the onNext signal from this Mono in milliseconds fallback - the fallback Mono to subscribe when a timeout occurs Returns: an expirable Mono with a fallback Mono timeoutMillis @Deprecated public final Mono<T> timeoutMillis(long timeout, Mono<? extends T> fallback, TimedScheduler timer) Deprecated. use the Duration based variants instead, will be removed in 3.1.0 Switch to a fallback Mono in case an item doesn't arrive before the given period. If the given Publisher is null, signal a TimeoutException. Parameters: timeout - the timeout before the onNext signal from this Mono in milliseconds fallback - the fallback Mono to subscribe when a timeout occurs timer - a time-capable Scheduler instance to run on Returns: an expirable Mono with a fallback Mono timestamp public final Mono<Tuple2<Long,T>> timestamp() Emit a Tuple2 pair of T1 Long current system time in millis and T2 T associated data for the eventual item from this Mono Returns: a timestamped Mono timestamp @Deprecated public final Mono<Tuple2<Long,T>> timestamp(TimedScheduler scheduler) Deprecated. use timestamp(Scheduler) Emit a Tuple2 pair of T1 Long current system time in millis and T2 T associated data for the eventual item from this Mono Parameters: scheduler - a Scheduler instance to read time from Returns: a timestamped Mono timestamp public final Mono<Tuple2<Long,T>> timestamp(Scheduler scheduler) Emit a Tuple2 pair of T1 Long current system time in millis and T2 T associated data for the eventual item from this Mono Parameters: scheduler - a Scheduler instance to read time from Returns: a timestamped Mono toFuture public final CompletableFuture<T> toFuture() Transform this Mono into a CompletableFuture completing on onNext or onComplete and failing on onError. Returns: a CompletableFuture transform public final <V> Mono<V> transform(Function<? super Mono<T>,? extends Publisher<V>> transformer) Transform this Mono in order to generate a target Mono. Unlike compose(Function), the provided function is executed as part of assembly. Function<Mono, Mono> applySchedulers = mono -> mono.subscribeOn(Schedulers.io()).publishOn(Schedulers.parallel()); mono.transform(applySchedulers).map(v -> v * v).subscribe() Type Parameters: V - the item type in the returned Mono Parameters: transformer - the Function to immediately map this Mono into a target Mono instance. Returns: a new Mono See Also: for deferred composition of {@link Mono} for each {@link Subscriber}, for a loose conversion to an arbitrary type onAssembly protected static <T> Mono<T> onAssembly(Mono<T> source) Invoke Hooks pointcut given a Mono and returning an eventually new Mono Type Parameters: T - the value type Parameters: source - the source to wrap Returns: the potentially wrapped source toString public String toString() Overrides: toString in class Object

Class Mono<T>

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface org.reactivestreams.Publisher

Constructor Detail

Mono

Method Detail

create

defer

delay

delay

delayMillis

delayMillis

empty

empty

error

first

first

from

fromCallable

fromCompletionStage

fromDirect

fromFuture

fromRunnable

fromSupplier

ignoreElements

just

justOrEmpty

justOrEmpty

never

sequenceEqual

sequenceEqual

sequenceEqual

using

using

untilOther

untilOtherDelayError

when

when

when

when

when

when

when

when

when

when

whenDelayError

whenDelayError

whenDelayError

whenDelayError

whenDelayError

whenDelayError

whenDelayError

whenDelayError

whenDelayError

zip

zip

as

and

and

and

and

awaitOnSubscribe

block

block

blockMillis

cast

cache

cancelOn

checkpoint

checkpoint

compose

concatWith

defaultIfEmpty

delayElement

delayElement

delayElementMillis

delayElementMillis