Java Reactor：有没有一种转换通量的方法<；单声道<；T>&燃气轮机；进入通量<；T>；没有急切的吸引？

我有一个快速但昂贵的制作人（SpringWebClient）和一个非常慢的订户。我需要一种方法来承受整个链条的背压

在实现过程中，我意识到flatMap、concatMap和其他人使用了即时抓取，似乎不可能禁用这种行为

在没有flatMap的订户中使用demand

Flux.defer(() -> Flux.range(1, 1000))
            .doOnRequest(i -> System.out.println("Requested: " + i))
            .doOnNext(v -> System.out.println("Emitted:   " + v))
            //.flatMap(Mono::just)
            .subscribe(new BaseSubscriber<Object>() {
                protected void hookOnSubscribe(final Subscription subscription) {
                    subscription.request(3);
                }

                protected void hookOnNext(final Object value) {
                    System.out.println("Received:  " + value);
                }
            });

将相同的需求与flatMap（未注释）一起使用会产生：

Requested: 3
Emitted:   1
Received:  1
Emitted:   2
Received:  2
Emitted:   3
Received:  3

Requested: 256
Emitted:   1
Received:  1
Emitted:   2
Received:  2
Emitted:   3
Received:  3
Emitted:   4
Emitted:   5
...
Emitted:   254
Emitted:   255
Emitted:   256

---

这似乎有一个悬而未决的问题：

不管怎样，我找到了一个解决方案：

block（）

。请记住，此操作仅允许在未标记为“仅限非阻塞操作”的线程上进行。（另见）

总而言之，问题是在某一点上，我有一个

通量

和

.flatMap（…）

，

.concatMap（…）

，等等。使用某种急切的抓取。用于测试的

通量

：

final Flux<Mono<Integer>> monoFlux = Flux.<Mono<Integer>, Integer>generate(
() -> 0, 
(state, sink) -> {
    state += 1;
    sink.next(Mono.just(state));
    return state;
}).doOnRequest(i -> System.out.println("Requested: " + i))
  .doOnNext(v -> System.out.println("Emitted:   " + v));

---

concatMap不急于获取。除非一个内部流完成，否则它不会订阅下一个流。它要求32个项目。我可以使用

prefetch

参数限制数量，但是在这种情况下，任何大于prefetch的需求都将被分割。

monoFlux.map(Mono::block)
        .subscribe(new MySubscriber<>());

Requested: 3
Emitted:   MonoJust
Received:  1
Emitted:   MonoJust
Received:  2
Emitted:   MonoJust
Received:  3