springboot webflux mono 使用说明

---

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 <I> Mono<I> 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 <U> Mono<T> delaySubscription(Publisher<U> 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 <U> Mono<T> timeout(Publisher<U> firstTimeout) {
    public final <U> Mono<T> timeout(Publisher<U> 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 <U> Mono<U> ofType(Class<U> 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> 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() {