springboot webflux mono 使用说明

我会带着你远行 2023-02-20 06:21 12阅读 0赞

--------------------

### springboot webflux mono 使用说明 ###

### \*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* ###

**相关类与接口**

**Mono：包含0或者1个元素**

public abstract class Mono<T> implements CorePublisher<T> {
 static final BiPredicate EQUALS_BIPREDICATE = Object::equals;
 
 public Mono() {
 }
 
 public static <T> Mono<T> create(Consumer<MonoSink<T>> callback) { //创建Mono对象
 
 public static Mono<Long> delay(Duration duration) {
 public static Mono<Long> delay(Duration duration, Scheduler timer) {
 
 public static <T> Mono<T> empty() { //内容为空，订阅时执行Operators.complete操作
 return MonoEmpty.instance();
 }
 
 
 public static <T> Mono<T> never() { //内容为空，订阅时不执行任何操作
 return MonoNever.instance();
 }
 
 
 public static <T> Mono<T> error(Throwable error) {
 public static <T> Mono<T> error(Supplier<? extends Throwable> errorSupplier) {
 
 @SafeVarargs
 public static <T> Mono<T> first(Mono<? extends T>... monos) {
 public static <T> Mono<T> first(Iterable<? extends Mono<? extends T>> monos) {
 
 
 static <T> Mono<Void> empty(Publisher<T> source) { //方法权限default，只能在同一个包中调用
 Mono<Void> then = ignoreElements(source);
 return then;
 }
 
 public static <T> Mono<T> ignoreElements(Publisher<T> source) {
 public static Mono<Context> subscriberContext() {
 
 
 
 ***************
 just 操作：立刻创建Mono对象
 
 public static <T> Mono<T> just(T data) { //创建不为空的Mono对象
 
 public static <T> Mono<T> justOrEmpty(@Nullable Optional<? extends T> data) {
 public static <T> Mono<T> justOrEmpty(@Nullable T data) { //创建包含0或者1个元素的对象
 
 
 
 ***************
 defer 操作：延时创建Mono对象，当subscribe方法调用时，才会创建对象
 
 public static <T> Mono<T> defer(Supplier<? extends Mono<? extends T>> supplier) {
 public static <T> Mono<T> deferWithContext(Function<Context, ? extends Mono<? extends T>> supplier) {
 
 
 
 ***************
 from 操作
 
 public static <T> Mono<T> from(Publisher<? extends T> source) {
 public static Mono fromDirect(Publisher<? extends I> source) {
 
 public static <T> Mono<T> fromSupplier(Supplier<? extends T> supplier) {
 
 public static <T> Mono<T> fromRunnable(Runnable runnable) {
 public static <T> Mono<T> fromCallable(Callable<? extends T> supplier) {
 
 public static <T> Mono<T> fromCompletionStage(CompletionStage<? extends T> completionStage) {
 public static <T> Mono<T> fromCompletionStage(Supplier<? extends CompletionStage<? extends T>> stageSupplier) {
 
 public static <T> Mono<T> fromFuture(CompletableFuture<? extends T> future) {
 public static <T> Mono<T> fromFuture(Supplier<? extends CompletableFuture<? extends T>> futureSupplier) {
 
 
 
 ***************
 sequenceEqual 操作：比较对象流是否相等
 
 public static <T> Mono<Boolean> sequenceEqual(Publisher<? extends T> source1, Publisher<? extends T> source2) {
 public static <T> Mono<Boolean> sequenceEqual(Publisher<? extends T> source1, Publisher<? extends T> source2, BiPredicate<? super T, ? super T> isEqual) {
 public static <T> Mono<Boolean> sequenceEqual(Publisher<? extends T> source1, Publisher<? extends T> source2, BiPredicate<? super T, ? super T> isEqual, int prefetch) {
 
 
 
 ***************
 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) {
 //callable返回初始的数据源，function对初始的数据源进行操作
 //consumer执行清理操作
 //eager为true（默认）：consumer在subscribe之前调用
 //eager为false：consumer在subscribe之后调用
 
 public static <T, D> Mono<T> using(Callable<? extends D> resourceSupplier, Function<? super D, ? extends Mono<? extends T>> sourceSupplier, Consumer<? super D> resourceCleanup) {
 return using(resourceSupplier, sourceSupplier, resourceCleanup, true);
 } //consumer操作默认在subscribe之前调用
 
 public static <T, D> Mono<T> usingWhen(Publisher<D> resourceSupplier, Function<? super D, ? extends Mono<? extends T>> resourceClosure, Function<? super D, ? extends Publisher<?>> asyncCleanup) {
 public static <T, D> Mono<T> usingWhen(Publisher<D> resourceSupplier, Function<? super D, ? extends Mono<? extends T>> resourceClosure, Function<? super D, ? extends Publisher<?>> asyncComplete, BiFunction<? super D, ? super Throwable, ? extends Publisher<?>> asyncError, Function<? super D, ? extends Publisher<?>> asyncCancel) {
 
 
 
 ***************
 when 操作：当被调用的时候执行预设的操作
 
 public static Mono<Void> when(Publisher<?>... sources) {
 public static Mono<Void> when(Iterable<? extends Publisher<?>> sources) {
 
 public static Mono<Void> whenDelayError(Iterable<? extends Publisher<?>> sources) {
 public static Mono<Void> whenDelayError(Publisher<?>... sources) {
 
 
 
 ***************
 zip 操作：压缩对象流
 
 public static <T1, T2> Mono<Tuple2<T1, T2>> zip(Mono<? extends T1> p1, Mono<? extends T2> p2) {
 public static <T1, T2, O> Mono<O> zip(Mono<? extends T1> p1, Mono<? extends T2> p2, BiFunction<? super T1, ? super T2, ? extends O> combinator) {
 public static <T1, T2, T3> Mono<Tuple3<T1, T2, T3>> zip(Mono<? extends T1> p1, Mono<? extends T2> p2, Mono<? extends T3> p3) {
 public static <T1, T2, T3, T4> Mono<Tuple4<T1, T2, T3, T4>> zip(Mono<? extends T1> p1, Mono<? extends T2> p2, Mono<? extends T3> p3, Mono<? extends T4> p4) {
 public static <T1, T2, T3, T4, T5> Mono<Tuple5<T1, T2, T3, T4, T5>> zip(Mono<? extends T1> p1, Mono<? extends T2> p2, Mono<? extends T3> p3, Mono<? extends T4> p4, Mono<? extends T5> p5) {
 public static <T1, T2, T3, T4, T5, T6> Mono<Tuple6<T1, T2, T3, T4, T5, T6>> zip(Mono<? extends T1> p1, Mono<? extends T2> p2, Mono<? extends T3> p3, Mono<? extends T4> p4, Mono<? extends T5> p5, Mono<? extends T6> p6) {
 public static <T1, T2, T3, T4, T5, T6, T7> Mono<Tuple7<T1, T2, T3, T4, T5, T6, T7>> zip(Mono<? extends T1> p1, Mono<? extends T2> p2, Mono<? extends T3> p3, Mono<? extends T4> p4, Mono<? extends T5> p5, Mono<? extends T6> p6, Mono<? extends T7> p7) {
 public static <T1, T2, T3, T4, T5, T6, T7, T8> Mono<Tuple8<T1, T2, T3, T4, T5, T6, T7, T8>> zip(Mono<? extends T1> p1, Mono<? extends T2> p2, Mono<? extends T3> p3, Mono<? extends T4> p4, Mono<? extends T5> p5, Mono<? extends T6> p6, Mono<? extends T7> p7, Mono<? extends T8> p8) {
 
 public static <R> Mono<R> zip(Iterable<? extends Mono<?>> monos, Function<? super Object[], ? extends R> combinator) {
 public static <R> Mono<R> zip(Function<? super Object[], ? extends R> combinator, Mono<?>... monos) {
 
 
 public static <T1, T2> Mono<Tuple2<T1, T2>> zipDelayError(Mono<? extends T1> p1, Mono<? extends T2> p2) {
 public static <T1, T2, T3> Mono<Tuple3<T1, T2, T3>> zipDelayError(Mono<? extends T1> p1, Mono<? extends T2> p2, Mono<? extends T3> p3) {
 public static <T1, T2, T3, T4> Mono<Tuple4<T1, T2, T3, T4>> zipDelayError(Mono<? extends T1> p1, Mono<? extends T2> p2, Mono<? extends T3> p3, Mono<? extends T4> p4) {
 public static <T1, T2, T3, T4, T5> Mono<Tuple5<T1, T2, T3, T4, T5>> zipDelayError(Mono<? extends T1> p1, Mono<? extends T2> p2, Mono<? extends T3> p3, Mono<? extends T4> p4, Mono<? extends T5> p5) {
 public static <T1, T2, T3, T4, T5, T6> Mono<Tuple6<T1, T2, T3, T4, T5, T6>> zipDelayError(Mono<? extends T1> p1, Mono<? extends T2> p2, Mono<? extends T3> p3, Mono<? extends T4> p4, Mono<? extends T5> p5, Mono<? extends T6> p6) {
 public static <T1, T2, T3, T4, T5, T6, T7> Mono<Tuple7<T1, T2, T3, T4, T5, T6, T7>> zipDelayError(Mono<? extends T1> p1, Mono<? extends T2> p2, Mono<? extends T3> p3, Mono<? extends T4> p4, Mono<? extends T5> p5, Mono<? extends T6> p6, Mono<? extends T7> p7) {
 public static <T1, T2, T3, T4, T5, T6, T7, T8> Mono<Tuple8<T1, T2, T3, T4, T5, T6, T7, T8>> zipDelayError(Mono<? extends T1> p1, Mono<? extends T2> p2, Mono<? extends T3> p3, Mono<? extends T4> p4, Mono<? extends T5> p5, Mono<? extends T6> p6, Mono<? extends T7> p7, Mono<? extends T8> p8) {
 
 public static <R> Mono<R> zipDelayError(Iterable<? extends Mono<?>> monos, Function<? super Object[], ? extends R> combinator) {
 public static <R> Mono<R> zipDelayError(Function<? super Object[], ? extends R> combinator, Mono<?>... monos) {
 
 
 
 ***************
 flatMap 操作
 
 public final <R> Mono<R> flatMap(Function<? super T, ? extends Mono<? extends R>> transformer) {
 
 public final <R> Flux<R> flatMapMany(Function<? super T, ? extends Publisher<? extends R>> mapper) {
 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) {
 
 public final <R> Flux<R> flatMapIterable(Function<? super T, ? extends Iterable<? extends R>> mapper) {
 
 
 ***************
 map 操作
 
 public final <R> Mono<R> map(Function<? super T, ? extends R> mapper) {
 
 
 
 ***************
 transform 操作
 
 public final <V> Mono<V> transform(Function<? super Mono<T>, ? extends Publisher<V>> transformer) {
 
 public final <V> Mono<V> transformDeferred(Function<? super Mono<T>, ? extends Publisher<V>> transformer) {
 
 
 
 ***************
 filter 操作
 
 public final Mono<T> filter(Predicate<? super T> tester) {
 public final Mono<T> filterWhen(Function<? super T, ? extends Publisher<Boolean>> asyncPredicate) {
 
 
 
 ***************
 do 操作
 
 public final Mono<T> doFirst(Runnable onFirst) {
 public final Mono<T> doFinally(Consumer<SignalType> onFinally) {
 
 public final Mono<T> doOnCancel(Runnable onCancel) {
 public final <R> Mono<T> doOnDiscard(Class<R> type, Consumer<? super R> discardHook) {
 public final Mono<T> doOnNext(Consumer<? super T> onNext) {
 public final Mono<T> doOnSuccess(Consumer<? super T> onSuccess) {
 public final Mono<T> doOnEach(Consumer<? super Signal<T>> signalConsumer) {
 
 public final Mono<T> doOnError(Consumer<? super Throwable> onError) {
 public final <E extends Throwable> Mono<T> doOnError(Class<E> exceptionType, Consumer<? super E> onError) {
 public final Mono<T> doOnError(Predicate<? super Throwable> predicate, Consumer<? super Throwable> onError) {
 
 public final Mono<T> doOnRequest(LongConsumer consumer) {
 public final Mono<T> doOnSubscribe(Consumer<? super Subscription> onSubscribe) {
 
 public final Mono<T> doOnTerminate(Runnable onTerminate) {
 public final Mono<T> doAfterTerminate(Runnable afterTerminate) {
 
 
 
 ***************
 block 操作
 
 @Nullable
 public T block() {
 
 @Nullable
 public T block(Duration timeout) {
 
 public Optional<T> blockOptional() {
 public Optional<T> blockOptional(Duration timeout) {
 
 
 
 ***************
 cache 操作
 
 public final Mono<T> cache() {
 public final Mono<T> cache(Duration ttl) {
 public final Mono<T> cache(Duration ttl, Scheduler timer) {
 public final Mono<T> cache(Function<? super T, Duration> ttlForValue, Function<Throwable, Duration> ttlForError, Supplier<Duration> ttlForEmpty) {
 
 
 
 ***************
 checkpoint 操作
 
 public final Mono<T> checkpoint() {
 public final Mono<T> checkpoint(String description) {
 public final Mono<T> checkpoint(@Nullable String description, boolean forceStackTrace) {
 
 
 ***************
 delay 操作
 
 public final Mono<T> delayElement(Duration delay) {
 public final Mono<T> delayElement(Duration delay, Scheduler timer) {
 
 public final Mono<T> delayUntil(Function<? super T, ? extends Publisher<?>> triggerProvider) {
 
 public final Mono<T> delaySubscription(Duration delay) {
 public final Mono<T> delaySubscription(Duration delay, Scheduler timer) {
 public final Mono<T> delaySubscription(Publisher subscriptionDelay) {
 
 
 ***************
 elapsed 操作
 
 public final Mono<Tuple2<Long, T>> elapsed() {
 public final Mono<Tuple2<Long, T>> elapsed(Scheduler scheduler) {
 
 
 
 ***************
 expand 操作
 
 public final Flux<T> expandDeep(Function<? super T, ? extends Publisher<? extends T>> expander, int capacityHint) {
 public final Flux<T> expandDeep(Function<? super T, ? extends Publisher<? extends T>> expander) {
 public final Flux<T> expand(Function<? super T, ? extends Publisher<? extends T>> expander, int capacityHint) {
 public final Flux<T> expand(Function<? super T, ? extends Publisher<? extends T>> expander) {
 
 
 
 ***************
 log 操作
 
 public final Mono<T> log() {
 return this.log((String)null, Level.INFO);
 }
 
 public final Mono<T> log(@Nullable String category) {
 return this.log(category, Level.INFO);
 }
 
 public final Mono<T> log(@Nullable String category, Level level, SignalType... options) {
 return this.log(category, level, false, options);
 }
 
 public final Mono<T> log(@Nullable String category, Level level, boolean showOperatorLine, SignalType... options) {
 SignalLogger<T> log = new SignalLogger(this, category, level, showOperatorLine, options);
 return this instanceof Fuseable ? onAssembly(new MonoLogFuseable(this, log)) : onAssembly(new MonoLog(this, log));
 }
 
 public final Mono<T> log(Logger logger) {
 return this.log(logger, Level.INFO, false);
 }
 
 public final Mono<T> log(Logger logger, Level level, boolean showOperatorLine, SignalType... options) {
 
 
 
 ***************
 onError 操作
 
 public final Mono<T> onErrorContinue(BiConsumer<Throwable, Object> errorConsumer) {
 public final <E extends Throwable> Mono<T> onErrorContinue(Class<E> type, BiConsumer<Throwable, Object> errorConsumer) {
 public final <E extends Throwable> Mono<T> onErrorContinue(Predicate<E> errorPredicate, BiConsumer<Throwable, Object> errorConsumer) {
 
 
 public final Mono<T> onErrorStop() {
 
 public final Mono<T> onErrorMap(Predicate<? super Throwable> predicate, Function<? super Throwable, ? extends Throwable> mapper) {
 public final Mono<T> onErrorMap(Function<? super Throwable, ? extends Throwable> mapper) {
 public final <E extends Throwable> Mono<T> onErrorMap(Class<E> type, Function<? super E, ? extends Throwable> mapper) {
 
 
 public final Mono<T> onErrorResume(Function<? super Throwable, ? extends Mono<? extends T>> fallback) {
 public final <E extends Throwable> Mono<T> onErrorResume(Class<E> type, Function<? super E, ? extends Mono<? extends T>> fallback) {
 public final Mono<T> onErrorResume(Predicate<? super Throwable> predicate, Function<? super Throwable, ? extends Mono<? extends T>> fallback) {
 
 public final Mono<T> onErrorReturn(T fallback) {
 public final <E extends Throwable> Mono<T> onErrorReturn(Class<E> type, T fallbackValue) {
 public final Mono<T> onErrorReturn(Predicate<? super Throwable> predicate, T fallbackValue) {
 
 
 
 ***************
 publish 操作
 
 public final <R> Mono<R> publish(Function<? super Mono<T>, ? extends Mono<? extends R>> transform) {
 
 public final Mono<T> publishOn(Scheduler scheduler) {
 
 
 
 ***************
 repeat 操作
 
 public final Flux<T> repeat() {
 public final Flux<T> repeat(BooleanSupplier predicate) {
 
 public final Flux<T> repeat(long numRepeat) {
 public final Flux<T> repeat(long numRepeat, BooleanSupplier predicate) {
 
 public final Flux<T> repeatWhen(Function<Flux<Long>, ? extends Publisher<?>> repeatFactory) {
 
 public final Mono<T> repeatWhenEmpty(Function<Flux<Long>, ? extends Publisher<?>> repeatFactory) {
 public final Mono<T> repeatWhenEmpty(int maxRepeat, Function<Flux<Long>, ? extends Publisher<?>> repeatFactory) {
 
 
 ***************
 retry 操作
 
 public final Mono<T> retry() {
 return this.retry(9223372036854775807L);
 }
 
 public final Mono<T> retry(long numRetries) {
 return onAssembly(new MonoRetry(this, numRetries));
 }
 
 public final Mono<T> retryWhen(Retry retrySpec) {
 return onAssembly(new MonoRetryWhen(this, retrySpec));
 }
 
 
 
 ***************
 take 操作
 
 public final Mono<T> take(Duration duration) {
 public final Mono<T> take(Duration duration, Scheduler timer) {
 public final Mono<T> takeUntilOther(Publisher<?> other) {
 
 
 ***************
 then 操作
 
 public final Mono<Void> then() {
 
 public final <V> Mono<V> then(Mono<V> other) {
 public final <V> Mono<V> thenReturn(V value) {
 
 public final Mono<Void> thenEmpty(Publisher<Void> other) {
 
 public final <V> Flux<V> thenMany(Publisher<V> other) {
 
 
 
 ***************
 timeout 操作
 
 public final Mono<T> timeout(Duration timeout) {
 public final Mono<T> timeout(Duration timeout, Mono<? extends T> fallback) {
 public final Mono<T> timeout(Duration timeout, Scheduler timer) {
 public final Mono<T> timeout(Duration timeout, @Nullable Mono<? extends T> fallback, Scheduler timer) {
 
 public final Mono<T> timeout(Publisher firstTimeout) {
 public final Mono<T> timeout(Publisher firstTimeout, Mono<? extends T> fallback) {
 
 
 
 ***************
 timestamp 操作
 
 public final Mono<Tuple2<Long, T>> timestamp() {
 public final Mono<Tuple2<Long, T>> timestamp(Scheduler scheduler) {
 
 
 
 ***************
 zipwhen、zipwith 操作
 
 public final <T2> Mono<Tuple2<T, T2>> zipWhen(Function<T, Mono<? extends T2>> rightGenerator) {
 public final <T2, O> Mono<O> zipWhen(Function<T, Mono<? extends T2>> rightGenerator, BiFunction<T, T2, O> combinator) {
 
 public final <T2> Mono<Tuple2<T, T2>> zipWith(Mono<? extends T2> other) {
 public final <T2, O> Mono<O> zipWith(Mono<? extends T2> other, BiFunction<? super T, ? super T2, ? extends O> combinator) {
 
 
 ***************
 subscribe 操作
 
 public final Disposable subscribe() {
 
 public final Disposable subscribe(Consumer<? super T> consumer) {
 public final Disposable subscribe(@Nullable Consumer<? super T> consumer, Consumer<? super Throwable> errorConsumer) {
 public final Disposable subscribe(@Nullable Consumer<? super T> consumer, @Nullable Consumer<? super Throwable> errorConsumer, @Nullable Runnable completeConsumer) {
 public final Disposable subscribe(@Nullable Consumer<? super T> consumer, @Nullable Consumer<? super Throwable> errorConsumer, @Nullable Runnable completeConsumer, @Nullable Consumer<? super Subscription> subscriptionConsumer) {
 public final Disposable subscribe(@Nullable Consumer<? super T> consumer, @Nullable Consumer<? super Throwable> errorConsumer, @Nullable Runnable completeConsumer, @Nullable Context initialContext) {
 
 public final void subscribe(Subscriber<? super T> actual) {
 public abstract void subscribe(CoreSubscriber<? super T> var1);
 
 public final Mono<T> subscriberContext(Context mergeContext) {
 public final Mono<T> subscriberContext(Function<Context, Context> doOnContext) {
 
 public final Mono<T> subscribeOn(Scheduler scheduler) {
 public final <E extends Subscriber<? super T>> E subscribeWith(E subscriber) {
 
 
 
 ***************
 其他操作
 
 public final Mono<T> ignoreElement() { //忽略Mono内容
 public final Mono<Boolean> hasElement() { //判断是否含有元素
 
 public final Mono<T> defaultIfEmpty(T defaultV) { //如果当前对象为空，设置默认的zhidefaultValue
 public final Mono<T> switchIfEmpty(Mono<? extends T> alternate) { //当前对象为空，返回新的Mono对象 alternate
 
 
 public final Flux<T> flux() { //将Mono对象转换为 flux对象
 public final CompletableFuture<T> toFuture() { //转换为CompleteableFuture对象
 public final MonoProcessor<T> toProcessor() { //转换为MonoProcessor
 
 
 public final Flux<T> concatWith(Publisher<? extends T> other) { //拼接，返回Flux对象
 public final Flux<T> mergeWith(Publisher<? extends T> other) { //合并，返回Flux对象
 
 
 public final <E> Mono<E> cast(Class<E> clazz) { //将存储元素转换为指定的类型E
 public final Mono ofType(Class clazz) {
 Objects.requireNonNull(clazz, "clazz");
 return this.filter((o) -> {
 return clazz.isAssignableFrom(o.getClass());
 }).cast(clazz);
 }
 
 public final Mono<Void> and(Publisher<?> other) {
 if (this instanceof MonoWhen) {
 MonoWhen o = (MonoWhen)this;
 Mono<Void> result = o.whenAdditionalSource(other);
 if (result != null) {
 return result;
 }
 }
 
 return when(this, other);
 }
 
 public final Mono<T> or(Mono<? extends T> other) {
 if (this instanceof MonoFirst) {
 MonoFirst<T> a = (MonoFirst)this;
 Mono<T> result = a.orAdditionalSource(other);
 if (result != null) {
 return result;
 }
 }
 
 return first(this, other);
 }
 
 
 public final Mono<T> cancelOn(Scheduler scheduler) {
 
 public final Mono<T> name(String name) { //设置名称
 public final Mono<T> tag(String key, String value) { //设置标签
 
 
 public final Mono<Signal<T>> materialize() {
 public final <X> Mono<X> dematerialize() {
 
 public final Mono<T> hide() {
 public final Mono<T> single() {
 public final Mono<T> metrics() {
 public final Mono<T> onTerminateDetach() {
 
 public final P as(Function<? super Mono<T>, P> transformer) {
 public final <R> Mono<R> handle(BiConsumer<? super T, SynchronousSink<R>> handler) {
 
 
 protected static <T> Mono<T> onAssembly(Mono<T> source) {
 Function<Publisher, Publisher> hook = Hooks.onEachOperatorHook;
 if (hook != null) {
 source = (Mono)hook.apply(source);
 }
 
 if (Hooks.GLOBAL_TRACE) {
 AssemblySnapshot stacktrace = new AssemblySnapshot((String)null, (Supplier)Traces.callSiteSupplierFactory.get());
 source = (Mono)Hooks.addAssemblyInfo(source, stacktrace);
 }
 
 return source;
 }
 
 
 static <T> Mono<T> doOnSignal(Mono<T> source, @Nullable Consumer<? super Subscription> onSubscribe, @Nullable Consumer<? super T> onNext, @Nullable LongConsumer onRequest, @Nullable Runnable onCancel) {
 static <T> Mono<T> doOnTerminalSignal(Mono<T> source, @Nullable Consumer<? super T> onSuccess, @Nullable Consumer<? super Throwable> onError, @Nullable BiConsumer<? super T, Throwable> onAfterTerminate) {
 
 
 static <T> Mono<T> wrap(Publisher<T> source, boolean enforceMonoContract) {
 static <T> BiPredicate<? super T, ? super T> equalsBiPredicate() {
 public String toString() {