Mono (reactor-core 3.0.0.RELEASE API)

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

Type Parameters:

T - the type of the single value of this class

All Implemented Interfaces:

org.reactivestreams.Publisher<T>

Direct Known Subclasses:

MonoProcessor, MonoSource
```
public abstract class Mono<T>
extends java.lang.Object
implements org.reactivestreams.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 Flux with possibly more than 1 emission. Its alternative enforcing Mono input is then.
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.

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
Modifier and Type	Method and Description
`<T2> Mono<Tuple2<T,T2>>`	`and(Mono<? extends T2> other)` Combine the result from this mono and another into a `Tuple2`.
`<P> P`	`as(java.util.function.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(java.time.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)` 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.
`Mono<T>`	`cache()` Turn this `Mono` into a hot source and cache last emitted signals for further `Subscriber`.
`<E> Mono<E>`	`cast(java.lang.Class<E> stream)` Cast the current `Mono` produced type into a target produced type.
`<V> Mono<V>`	`compose(java.util.function.Function<? super Mono<T>,? extends org.reactivestreams.Publisher<V>> transformer)` Defer the given transformation to this `Mono` in order to generate a target `Mono` type.
`Flux<T>`	`concatWith(org.reactivestreams.Publisher<? extends T> other)` Concatenate emissions of this `Mono` with the provided `Publisher` (no interleave).
`static <T> Mono<T>`	`create(java.util.function.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(java.util.function.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<java.lang.Long>`	`delay(java.time.Duration duration)` Create a Mono which delays an onNext signal of `duration` of given unit and complete on the global timer.
`static Mono<java.lang.Long>`	`delayMillis(long duration)` Create a Mono which delays an onNext signal of `duration` milliseconds and complete.
`static Mono<java.lang.Long>`	`delayMillis(long duration, TimedScheduler timer)` Create a Mono which delays an onNext signal of `duration` milliseconds and complete.
`Mono<T>`	`delaySubscription(java.time.Duration delay)` Delay the `subscription` to this `Mono` source until the given period elapses.
`<U> Mono<T>`	`delaySubscription(org.reactivestreams.Publisher<U> subscriptionDelay)` Delay the subscription to this `Mono` until another `Publisher` signals a value or completes.
`Mono<T>`	`delaySubscriptionMillis(long delay)` Delay the `subscription` to this `Mono` source until the given period elapses.
`Mono<T>`	`delaySubscriptionMillis(long delay, TimedScheduler timer)` Delay the `subscription` to this `Mono` source until the given period elapses.
`<X> Mono<X>`	`dematerialize()` A "phantom-operator" working only if this `Mono` is a emits onNext, onError or onComplete `Signal`.
`Mono<T>`	`doAfterTerminate(java.util.function.BiConsumer<? super T,java.lang.Throwable> afterTerminate)` Triggered after the `Mono` terminates, either by completing downstream successfully or with an error.
`Mono<T>`	`doOnCancel(java.lang.Runnable onCancel)` Triggered when the `Mono` is cancelled.
`<E extends java.lang.Throwable> Mono<T>`	`doOnError(java.lang.Class<E> exceptionType, java.util.function.Consumer<? super E> onError)` Triggered when the `Mono` completes with an error matching the given exception type.
`Mono<T>`	`doOnError(java.util.function.Consumer<? super java.lang.Throwable> onError)` Triggered when the `Mono` completes with an error.
`Mono<T>`	`doOnError(java.util.function.Predicate<? super java.lang.Throwable> predicate, java.util.function.Consumer<? super java.lang.Throwable> onError)` Triggered when the `Mono` completes with an error matching the given exception.
`Mono<T>`	`doOnNext(java.util.function.Consumer<? super T> onNext)` Triggered when the `Mono` emits a data successfully.
`Mono<T>`	`doOnRequest(java.util.function.LongConsumer consumer)` Attach a `LongConsumer` to this `Mono` that will observe any request to this `Mono`.
`Mono<T>`	`doOnSubscribe(java.util.function.Consumer<? super org.reactivestreams.Subscription> onSubscribe)` Triggered when the `Mono` is subscribed.
`Mono<T>`	`doOnSuccess(java.util.function.Consumer<? super T> onSuccess)` Triggered when the `Mono` completes successfully.
`Mono<T>`	`doOnTerminate(java.util.function.BiConsumer<? super T,java.lang.Throwable> onTerminate)` Triggered when the `Mono` terminates, either by completing successfully or with an error.
`Mono<Tuple2<java.lang.Long,T>>`	`elapsed()` Map this `Mono` sequence into `Tuple2` of T1 `Long` timemillis and T2 `T` associated data.
`static <T> Mono<T>`	`empty()` Create a `Mono` that completes without emitting any item.
`static <T> Mono<java.lang.Void>`	`empty(org.reactivestreams.Publisher<T> source)` Create a new `Mono` that ignores onNext (dropping them) and only react on Completion signal.
`static <T> Mono<T>`	`error(java.lang.Throwable error)` Create a `Mono` that completes with the specified error immediately after onSubscribe.
`Mono<T>`	`filter(java.util.function.Predicate<? super T> tester)` Test the result if any of this `Mono` and replay it if predicate returns true.
`static <T> Mono<T>`	`first(java.lang.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(java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper)` Transform the items emitted by a `Publisher` into Publishers, then flatten the emissions from those by merging them into a single `Flux`, so that they may interleave.
`<R> Flux<R>`	`flatMap(java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapperOnNext, java.util.function.Function<java.lang.Throwable,? extends org.reactivestreams.Publisher<? extends R>> mapperOnError, java.util.function.Supplier<? extends org.reactivestreams.Publisher<? extends R>> mapperOnComplete)` Transform the signals emitted by this `Flux` into Publishers, then flatten the emissions from those by merging them into a single `Flux`, so that they may interleave.
`<R> Flux<R>`	`flatMapIterable(java.util.function.Function<? super T,? extends java.lang.Iterable<? extends R>> mapper)` Transform the items emitted by this `Mono` into `Iterable`, then flatten the elements from those by merging them into a single `Flux`.
`Flux<T>`	`flux()` Convert this `Mono` to a `Flux`
`static <T> Mono<T>`	`from(org.reactivestreams.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(java.util.concurrent.Callable<? extends T> supplier)` Create a `Mono` producing the value for the `Mono` using the given supplier.
`static <T> Mono<T>`	`fromFuture(java.util.concurrent.CompletableFuture<? extends T> future)` Create a `Mono` producing the value for the `Mono` using the given `CompletableFuture`.
`static Mono<java.lang.Void>`	`fromRunnable(java.lang.Runnable runnable)` Create a `Mono` only producing a completion signal after using the given runnable.
`static <T> Mono<T>`	`fromSupplier(java.util.function.Supplier<? extends T> supplier)` Create a `Mono` producing the value for the `Mono` using the given supplier.
`<R> Mono<R>`	`handle(java.util.function.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<java.lang.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(org.reactivestreams.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(java.util.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(java.lang.String category)` Observe all Reactive Streams signals and use `Logger` support to handle trace implementation.
`Mono<T>`	`log(java.lang.String category, java.util.logging.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(java.util.function.Function<? super T,? extends R> mapper)` Transform the item emitted by this `Mono` by applying a function to item emitted.
`<E extends java.lang.Throwable> Mono<T>`	`mapError(java.lang.Class<E> type, java.util.function.Function<? super E,? extends java.lang.Throwable> mapper)` Transform the error emitted by this `Mono` by applying a function if the error matches the given type, otherwise let the error flows.
`Mono<T>`	`mapError(java.util.function.Function<java.lang.Throwable,? extends java.lang.Throwable> mapper)` Transform the error emitted by this `Flux` by applying a function.
`Mono<T>`	`mapError(java.util.function.Predicate<? super java.lang.Throwable> predicate, java.util.function.Function<? super java.lang.Throwable,? extends java.lang.Throwable> mapper)` Transform the error emitted by this `Mono` by applying a function if the error matches the given predicate, otherwise let the error flows.
`Mono<Signal<T>>`	`materialize()` Transform the incoming onNext, onError and onComplete signals into `Signal`.
`Flux<T>`	`mergeWith(org.reactivestreams.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.
`protected static <T> Mono<T>`	`onAssembly(Mono<T> source)` Invoke `Hooks` pointcut given a `Mono` and returning an eventually new `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 java.lang.Throwable> Mono<T>`	`otherwise(java.lang.Class<E> type, java.util.function.Function<? super E,? extends Mono<? extends T>> fallback)` Subscribe to a returned fallback publisher when an error matching the given type occurs.
`Mono<T>`	`otherwise(java.util.function.Function<? super java.lang.Throwable,? extends Mono<? extends T>> fallback)` Subscribe to a returned fallback publisher when any error occurs.
`Mono<T>`	`otherwise(java.util.function.Predicate<? super java.lang.Throwable> predicate, java.util.function.Function<? super java.lang.Throwable,? extends Mono<? extends T>> fallback)` Subscribe to a returned fallback publisher when an error matching the given type occurs.
`Mono<T>`	`otherwiseIfEmpty(Mono<? extends T> alternate)` Provide an alternative `Mono` if this mono is completed without data
`<E extends java.lang.Throwable> Mono<T>`	`otherwiseReturn(java.lang.Class<E> type, T fallbackValue)` Fallback to the given value if an error of a given type is observed on this `Flux`
`<E extends java.lang.Throwable> Mono<T>`	`otherwiseReturn(java.util.function.Predicate<? super java.lang.Throwable> predicate, T fallbackValue)` Fallback to the given value if an error matching the given predicate is observed on this `Flux`
`Mono<T>`	`otherwiseReturn(T fallback)` Subscribe to a returned fallback value when any error occurs.
`<R> Mono<R>`	`publish(java.util.function.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(java.util.function.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, java.util.function.BooleanSupplier predicate)` Repeatedly subscribe to the source if the predicate returns true after completion of the previous subscription.
`Flux<T>`	`repeatWhen(java.util.function.Function<Flux<java.lang.Long>,? extends org.reactivestreams.Publisher<?>> whenFactory)` Repeatedly subscribe to this `Flux` when a companion sequence signals a number of emitted elements in response to the flux completion signal.
`Mono<T>`	`repeatWhenEmpty(java.util.function.Function<Flux<java.lang.Long>,? extends org.reactivestreams.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, java.util.function.Function<Flux<java.lang.Long>,? extends org.reactivestreams.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, java.util.function.Predicate<java.lang.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(java.util.function.Predicate<java.lang.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(java.util.function.Function<Flux<java.lang.Throwable>,? extends org.reactivestreams.Publisher<?>> whenFactory)` Retries this `Mono` when a companion sequence signals an item in response to this `Mono` error signal
`MonoProcessor<T>`	`subscribe()` Start the chain and request unbounded demand.
`Cancellation`	`subscribe(java.util.function.Consumer<? super T> consumer)` Subscribe a `Consumer` to this `Mono` that will consume all the sequence.
`Cancellation`	`subscribe(java.util.function.Consumer<? super T> consumer, java.util.function.Consumer<? super java.lang.Throwable> errorConsumer)` Subscribe `Consumer` to this `Mono` that will consume all the sequence.
`Cancellation`	`subscribe(java.util.function.Consumer<? super T> consumer, java.util.function.Consumer<? super java.lang.Throwable> errorConsumer, java.lang.Runnable completeConsumer)` 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 org.reactivestreams.Subscriber<? super T>> E`	`subscribeWith(E subscriber)` Subscribe the `Mono` with the givne `Subscriber` and return it.
`Mono<java.lang.Void>`	`then()` Return a `Mono<Void>` which only listens for complete and error signals from this `Mono` completes.
`<R> Mono<R>`	`then(java.util.function.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)` Transform the terminal signal (error or completion) into `Mono<V>` that will emit at most one result in the returned `Mono`.
`<V> Mono<V>`	`then(java.util.function.Supplier<? extends Mono<V>> sourceSupplier)` Transform the terminal signal (error or completion) into `Mono<V>` that will emit at most one result in the returned `Mono`.
`<V> Flux<V>`	`thenMany(org.reactivestreams.Publisher<V> other)` Transform the terminal signal (error or completion) into `Publisher<V>` that will emit at most one result in the returned `Flux`.
`<V> Flux<V>`	`thenMany(java.util.function.Supplier<? extends Mono<V>> sourceSupplier)` Transform the terminal signal (error or completion) into `Publisher<V>` that will emit at most one result in the returned `Flux`.
`Mono<T>`	`timeout(java.time.Duration timeout)` Signal a `TimeoutException` in case an item doesn't arrive before the given period.
`Mono<T>`	`timeout(java.time.Duration timeout, Mono<? extends T> fallback)` Switch to a fallback `Mono` in case an item doesn't arrive before the given period.
`<U> Mono<T>`	`timeout(org.reactivestreams.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(org.reactivestreams.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)` Signal a `TimeoutException` error in case an item doesn't arrive before the given period.
`Mono<T>`	`timeoutMillis(long timeout, Mono<? extends T> fallback)` Switch to a fallback `Mono` in case an item doesn't arrive before the given period.
`Mono<T>`	`timeoutMillis(long timeout, Mono<? extends T> fallback, TimedScheduler timer)` Switch to a fallback `Mono` in case an item doesn't arrive before the given period.
`Mono<T>`	`timeoutMillis(long timeout, TimedScheduler timer)` Signal a `TimeoutException` error in case an item doesn't arrive before the given period.
`Mono<Tuple2<java.lang.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`
`java.util.concurrent.CompletableFuture<T>`	`toFuture()` Transform this `Mono` into a `CompletableFuture` completing on onNext or onComplete and failing on onError.
`java.lang.String`	`toString()`
`<V> Mono<V>`	`transform(java.util.function.Function<? super Mono<T>,? extends org.reactivestreams.Publisher<V>> transformer)` Transform this `Mono` in order to generate a target `Mono`.
`static <T,D> Mono<T>`	`using(java.util.concurrent.Callable<? extends D> resourceSupplier, java.util.function.Function<? super D,? extends Mono<? extends T>> sourceSupplier, java.util.function.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(java.util.concurrent.Callable<? extends D> resourceSupplier, java.util.function.Function<? super D,? extends Mono<? extends T>> sourceSupplier, java.util.function.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(java.util.function.Function<? super java.lang.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(java.lang.Iterable<? extends Mono<?>> monos, java.util.function.Function<? super java.lang.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<java.lang.Void>`	`when(java.lang.Iterable<? extends org.reactivestreams.Publisher<java.lang.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,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<java.lang.Void>`	`when(org.reactivestreams.Publisher<java.lang.Void>... sources)` Aggregate given void publisher into a new a Mono that will be fulfilled when all of the given Monos have been fulfilled.
`static <R> Mono<R>`	`whenDelayError(java.util.function.Function<? super java.lang.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 <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<java.lang.Void>`	`whenDelayError(org.reactivestreams.Publisher<java.lang.Void>... sources)` Merge given void publishers into a new a Mono that will be fulfilled when all of the given Monos have been fulfilled.
`static <T,V> Mono<V>`	`zip(java.util.function.Function<? super java.lang.Object[],? extends V> combinator, java.lang.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(java.util.function.Function<? super java.lang.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(java.util.function.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.setCancellation(() -> 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.setCancellation(() -> {
 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(java.util.function.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<java.lang.Long> delay(java.time.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. Parameters: duration - the duration of the delay Returns: a new Mono delayMillis public static Mono<java.lang.Long> delayMillis(long duration) 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 public static Mono<java.lang.Long> delayMillis(long duration, TimedScheduler timer) 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 - the TimedScheduler 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<java.lang.Void> empty(org.reactivestreams.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(java.lang.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(java.lang.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(org.reactivestreams.Publisher<? extends T> source) Expose the specified Publisher with the Mono API, and ensure it will emit 0 or 1 item. 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(java.util.concurrent.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. fromFuture public static <T> Mono<T> fromFuture(java.util.concurrent.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. fromRunnable public static Mono<java.lang.Void> fromRunnable(java.lang.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(java.util.function.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(org.reactivestreams.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(java.util.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 using public static <T,D> Mono<T> using(java.util.concurrent.Callable<? extends D> resourceSupplier, java.util.function.Function<? super D,? extends Mono<? extends T>> sourceSupplier, java.util.function.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(java.util.concurrent.Callable<? extends D> resourceSupplier, java.util.function.Function<? super D,? extends Mono<? extends T>> sourceSupplier, java.util.function.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 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 Flux. 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,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 Flux. 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 Flux. 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 Flux. 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 Flux. 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<java.lang.Void> when(java.lang.Iterable<? extends org.reactivestreams.Publisher<java.lang.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(java.lang.Iterable<? extends Mono<?>> monos, java.util.function.Function<? super java.lang.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<java.lang.Void> when(org.reactivestreams.Publisher<java.lang.Void>... sources) Aggregate given void publisher 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 Flux. Parameters: sources - The sources to use. Returns: a Mono. when public static <R> Mono<R> when(java.util.function.Function<? super java.lang.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 Flux. 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. 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. 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. 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. 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. 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 @SafeVarargs public static Mono<java.lang.Void> whenDelayError(org.reactivestreams.Publisher<java.lang.Void>... sources) Merge given void publishers into a new a Mono that will be fulfilled when all of the given Monos have been fulfilled. Parameters: sources - The sources to use. Returns: a Mono. whenDelayError public static <R> Mono<R> whenDelayError(java.util.function.Function<? super java.lang.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. 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(java.util.function.Function<? super java.lang.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(java.util.function.Function<? super java.lang.Object[],? extends V> combinator, java.lang.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(java.util.function.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>) 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 final T block(java.time.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 public T blockMillis(long 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 in milliseconds before raising a RuntimeException Returns: T the result cast public final <E> Mono<E> cast(java.lang.Class<E> stream) Cast the current Mono produced type into a target produced type. Type Parameters: E - the Mono output type Parameters: stream - 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 compose public final <V> Mono<V> compose(java.util.function.Function<? super Mono<T>,? extends org.reactivestreams.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(org.reactivestreams.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) delaySubscription public final Mono<T> delaySubscription(java.time.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(org.reactivestreams.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 public final Mono<T> delaySubscriptionMillis(long delay) Delay the subscription to this Mono source until the given period elapses. Parameters: delay - period in milliseconds before subscribing this Mono Returns: a delayed Mono delaySubscriptionMillis public final Mono<T> delaySubscriptionMillis(long delay, TimedScheduler timer) Delay the subscription to this Mono source until the given period elapses. Parameters: delay - period in milliseconds before subscribing this Mono timer - the TimedScheduler 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(java.util.function.BiConsumer<? super T,java.lang.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 doOnCancel public final Mono<T> doOnCancel(java.lang.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(java.util.function.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(java.util.function.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 doOnError public final Mono<T> doOnError(java.util.function.Consumer<? super java.lang.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 java.lang.Throwable> Mono<T> doOnError(java.lang.Class<E> exceptionType, java.util.function.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(java.util.function.Predicate<? super java.lang.Throwable> predicate, java.util.function.Consumer<? super java.lang.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(java.util.function.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(java.util.function.Consumer<? super org.reactivestreams.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(java.util.function.BiConsumer<? super T,java.lang.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<java.lang.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 filter public final Mono<T> filter(java.util.function.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 flatMap public final <R> Flux<R> flatMap(java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper) Transform the items emitted by a Publisher into Publishers, then flatten the emissions from those by merging them into a single Flux, so that they may interleave. 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 public final <R> Flux<R> flatMap(java.util.function.Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapperOnNext, java.util.function.Function<java.lang.Throwable,? extends org.reactivestreams.Publisher<? extends R>> mapperOnError, java.util.function.Supplier<? extends org.reactivestreams.Publisher<? extends R>> mapperOnComplete) Transform the signals emitted by this Flux into Publishers, then flatten the emissions from those by merging them into a single Flux, so that they may interleave. Type Parameters: R - the type of the produced merged 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(java.util.function.Function<? super T,? extends java.lang.Iterable<? extends R>> mapper) Transform the items emitted by this Mono into Iterable, then flatten the elements from those by merging them into a single Flux. The prefetch argument allows to give an arbitrary prefetch size to the merged 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<java.lang.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(java.util.function.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". Returns: a new Mono See Also: Flux.log() log public final Mono<T> log(java.lang.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). Returns: a new Mono log public final Mono<T> log(java.lang.String category, java.util.logging.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). level - the level to enforce for this tracing Flux options - a vararg SignalType option to filter log messages Returns: a new Mono map public final <R> Mono<R> map(java.util.function.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 public final Mono<T> mapError(java.util.function.Function<java.lang.Throwable,? extends java.lang.Throwable> mapper) Transform the error emitted by this Flux by applying a function. Parameters: mapper - the error transforming Function Returns: a transformed Flux mapError public final <E extends java.lang.Throwable> Mono<T> mapError(java.lang.Class<E> type, java.util.function.Function<? super E,? extends java.lang.Throwable> mapper) Transform the error emitted by this Mono by applying a function if the error matches the given type, otherwise let the error flows. Type Parameters: E - the error type Parameters: type - the type to match mapper - the error transforming Function Returns: a transformed Mono mapError public final Mono<T> mapError(java.util.function.Predicate<? super java.lang.Throwable> predicate, java.util.function.Function<? super java.lang.Throwable,? extends java.lang.Throwable> mapper) Transform the error emitted by this Mono by applying a function if the error matches the given predicate, otherwise let the error flows. 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(org.reactivestreams.Publisher<? extends T> other) Merge emissions of this Mono with the provided Publisher. Parameters: other - the other Publisher to merge with Returns: a new Flux as the sequence is not guaranteed to be at most 1 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>...) otherwise public final Mono<T> otherwise(java.util.function.Function<? super java.lang.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.onErrorResumeWith(java.util.function.Function<? super java.lang.Throwable, ? extends org.reactivestreams.Publisher<? extends T>>) otherwise public final <E extends java.lang.Throwable> Mono<T> otherwise(java.lang.Class<E> type, java.util.function.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 otherwise public final Mono<T> otherwise(java.util.function.Predicate<? super java.lang.Throwable> predicate, java.util.function.Function<? super java.lang.Throwable,? extends Mono<? extends T>> fallback) 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 public final Mono<T> otherwiseIfEmpty(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>) otherwiseReturn public final Mono<T> otherwiseReturn(T fallback) Subscribe to a returned fallback value when any error occurs. Parameters: fallback - the value to emit if an error occurs Returns: a new Mono See Also: Flux.onErrorReturn(T) otherwiseReturn public final <E extends java.lang.Throwable> Mono<T> otherwiseReturn(java.lang.Class<E> type, T fallbackValue) Fallback to the given value if an error of a given type is observed on this Flux Type Parameters: E - the error type Parameters: type - the error type to match fallbackValue - alternate value on fallback Returns: a new Flux otherwiseReturn public final <E extends java.lang.Throwable> Mono<T> otherwiseReturn(java.util.function.Predicate<? super java.lang.Throwable> predicate, T fallbackValue) Fallback to the given value if an error matching the given predicate is observed on this Flux 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(java.util.function.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 - 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(java.util.function.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, java.util.function.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(java.util.function.Function<Flux<java.lang.Long>,? extends org.reactivestreams.Publisher<?>> whenFactory) Repeatedly subscribe to this Flux when a companion sequence signals a number of emitted elements in response to the flux completion signal. If the companion sequence signals when this Flux 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(java.util.function.Function<Flux<java.lang.Long>,? extends org.reactivestreams.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 Flux 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, java.util.function.Function<Flux<java.lang.Long>,? extends org.reactivestreams.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 Flux 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(java.util.function.Predicate<java.lang.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, java.util.function.Predicate<java.lang.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(java.util.function.Function<Flux<java.lang.Throwable>,? extends org.reactivestreams.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 Cancellation subscribe(java.util.function.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 Cancellation subscribe(java.util.function.Consumer<? super T> consumer, java.util.function.Consumer<? super java.lang.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 Cancellation subscribe(java.util.function.Consumer<? super T> consumer, java.util.function.Consumer<? super java.lang.Throwable> errorConsumer, java.lang.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 Cancellation 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 org.reactivestreams.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 then public final Mono<java.lang.Void> then() Return a Mono<Void> which only listens for complete and error signals from this Mono completes. Returns: a Mono igoring its payload (actively dropping) then public final <R> Mono<R> then(java.util.function.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 then public final <V> Mono<V> then(Mono<V> other) Transform the terminal signal (error or completion) into Mono<V> that will emit at most one result in the returned Mono. 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 public final <V> Mono<V> then(java.util.function.Supplier<? extends Mono<V>> sourceSupplier) Transform the terminal signal (error or completion) into Mono<V> that will emit at most one result in the returned Mono. 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 thenMany public final <V> Flux<V> thenMany(org.reactivestreams.Publisher<V> other) Transform the terminal signal (error or completion) into Publisher<V> that will emit at most one result in the returned Flux. Type Parameters: V - the element type of the supplied Mono Parameters: other - a Publisher to emit from after termination Returns: a new Flux that emits from the supplied Publisher thenMany public final <V> Flux<V> thenMany(java.util.function.Supplier<? extends Mono<V>> sourceSupplier) Transform the terminal signal (error or completion) into Publisher<V> that will emit at most one result in the returned Flux. Type Parameters: V - the element type of the supplied Mono Parameters: sourceSupplier - a Supplier of Publisher to emit from after termination Returns: a new Flux that emits from the supplied Publisher timeout public final Mono<T> timeout(java.time.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(java.time.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(org.reactivestreams.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 Flux Returns: an expirable Mono if the first item does not come before a Publisher signal timeout public final Mono<T> timeout(org.reactivestreams.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 public final Mono<T> timeoutMillis(long timeout) 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 public final Mono<T> timeoutMillis(long timeout, TimedScheduler 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 - the TimedScheduler to run on Returns: an expirable Mono timeoutMillis public final Mono<T> timeoutMillis(long 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 in milliseconds fallback - the fallback Mono to subscribe when a timeout occurs Returns: an expirable Mono with a fallback Mono timeoutMillis public final Mono<T> timeoutMillis(long timeout, Mono<? extends T> fallback, TimedScheduler 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 in milliseconds fallback - the fallback Mono to subscribe when a timeout occurs timer - the TimedScheduler to run on Returns: an expirable Mono with a fallback Mono timestamp public final Mono<Tuple2<java.lang.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 toFuture public final java.util.concurrent.CompletableFuture<T> toFuture() Transform this Mono into a CompletableFuture completing on onNext or onComplete and failing on onError. Returns: a CompletableFuture toString public java.lang.String toString() Overrides: toString in class java.lang.Object transform public final <V> Mono<V> transform(java.util.function.Function<? super Mono<T>,? extends org.reactivestreams.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(Subscribers.unbounded()) 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

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

delayMillis

delayMillis

empty

empty

error

first

first

from

fromCallable

fromFuture

fromRunnable

fromSupplier

ignoreElements

just

justOrEmpty

justOrEmpty

never

using

using

when

when

when

when

when

when

when

when

when

whenDelayError

whenDelayError

whenDelayError

whenDelayError

whenDelayError

whenDelayError

whenDelayError

zip

zip

as

and

awaitOnSubscribe

block

block

blockMillis

cast

cache

compose

concatWith

defaultIfEmpty

delaySubscription

delaySubscription

delaySubscriptionMillis

delaySubscriptionMillis

dematerialize

doAfterTerminate

doOnCancel

doOnNext

doOnSuccess

doOnError

doOnError

doOnError

doOnRequest

doOnSubscribe

doOnTerminate

elapsed

filter

flatMap

flatMap

flatMapIterable

flux