Java Spring Responsive-收集分页结果序列，作为所有结果的一部分

在我的REST服务中，我必须多次调用另一个REST服务以获取结果列表的所有页面。请求包含一个

from

字段，我需要随每个请求增加该字段。响应包含一个

totalResults

字段-当我读取所有结果后，我需要停止调用其他服务，收集所有调用的所有结果并生成一个

Mono

响应

这就是我到目前为止所做的：

@Getter
public class Request {
    private int from;
    private int size = 1000;
    private String type;

    public Request(String type, int from) {
        this.type = type;
        this.from = from;
    }
}

@Getter
@Setter
public class Response {
    private Integer totalResults;
    private Integer size;
    private Integer from;
    private List<Result> results;
}

public Mono<List<Result>> findByType(String type) {
    return Flux.generate(
            () -> new Request(type, 0),
            (Request request, SynchronousSink<List<Result>> sink) -> {
                Response response = find(request).block();
                sink.next(response.getResults());
                int nextFrom = response.getFrom() + response.getSize();
                if (nextFrom >= response.getTotalResults()) {
                    sink.complete();
                }
                return new Request(type, nextFrom);
            })
            .flatMap(Flux::fromIterable)
            .collectList();
}

private Mono<Response> find(Request request) {
    return webClient
            .post()
            .uri("/search")
            .syncBody(request)
            .retrieve()
            .bodyToMono(Response.class);
}

如何以正确的反应方式进行编辑？

在Adam的帮助下，

展开功能解决了此问题

public Mono<List<Result>> findByType(Request request) {
        return find(request)
                .expand(response -> {
                    int nextFrom = response.getFrom() + response.getSize();
                    if (nextFrom >= response.getTotalResults()) {
                        return Mono.empty();
                    }
                    return find(new Request(request.getType(), response.getFrom() + response.getSize()));
                })
                 .flatMap(response -> Flux.fromIterable(response.getResults()))
                 .collectList();;
    }

    private Mono<Response> find(Request request) {
        return webClient
                .post()
                .uri("/search")
                .contentType(MediaType.APPLICATION_JSON)
                .accept(MediaType.APPLICATION_JSON)
                .syncBody(request)
                .retrieve()
                .bodyToMono(Response.class);
    }

公共Mono findByType（请求）{
返回查找（请求）
.展开（响应->{
int nextFrom=response.getFrom（）+response.getSize（）；
if（nextFrom>=response.getTotalResults（））{
返回Mono.empty（）；
}
返回find（新请求（Request.getType（），response.getFrom（）+response.getSize（））；
})
.flatMap（response->Flux.fromIterable（response.getResults（）））
.collectList（）；；
}
专用Mono查找（请求）{
返回网络客户端
.post（）
.uri（“/search”）
.contentType（MediaType.APPLICATION_JSON）
.accept（MediaType.APPLICATION_JSON）
.syncBody（请求）
.retrieve（）
.bodyToMono（Response.class）；
}

我使用了相同的方法，但在我的例子中，expand没有终止

public Mono<List<Result>> findByType(Request request) {
        return find(request)
                .expand(response -> {
                    int nextFrom = response.getFrom() + response.getSize();
                    if (nextFrom >= response.getTotalResults()) {
                        return Mono.empty();
                    }
                    return find(new Request(request.getType(), response.getFrom() + response.getSize()));
                })
                 .flatMap(response -> Flux.fromIterable(response.getResults()))
                 .collectList();;
    }

    private Mono<Response> find(Request request) {
        return webClient
                .post()
                .uri("/search")
                .contentType(MediaType.APPLICATION_JSON)
                .accept(MediaType.APPLICATION_JSON)
                .syncBody(request)
                .retrieve()
                .bodyToMono(Response.class);
    }