Spring WebFlux和WebClient进行许多API调用

Question

Recently I asked question Spring WebFlux create pool of no-blocking threads

I got the answer, read link provided, but still don't understand the right way of doing such stuff.

I use Spring WebFlux (WebClient) to write my REST service. For each incoming request I make several hundred requests to another REST service, so to make them as fast as possible I want to use no-blocking threads.

Let I got request from client and I have to make 600 API calls:

List<String> urls = Arrays.asList("www.example-rest.com/url1", "www.example-rest.com/url2", ..., "www.example-rest.com/url600");

• I want to make them in parallel way and using no-blocking threads (like eventlet in Python)
• I want to create separate shared worker pool with such threads in order not to make one for each incoming request.

Here is the documentation about schedulers http://projectreactor.io/docs/core/release/reference/#schedulers

I found there information about elastic thread pool :

An elastic thread pool (Schedulers.elastic()). It creates new worker pools as needed, and reuse idle ones. This is a good choice for I/O blocking work for instance. Schedulers.elastic() is a handy way to give a blocking process its own thread, so that it does not tie up other resources.

But I can't create new worker pool for each request, and thread inside that pool still works in blocking way.

If anybody did similar task with Spring WebClient please provide an example, explain what is the right way.

Answer 1

I've done something similar... My goal was to create a method with a signature like this:

Flux<BasicIssue> getIssues(WebClient webClient);

Because the website I was calling provided only a paged interface, I needed to feed the results of multiple REST calls into a single Flux. Below is my implementation. Please note my use of CachedThreadPool.

Flux<BasicIssue> getIssues(WebClient webClient) {
    return Flux.generate(
        () -> new IssuesState(webClient),
        (state, sink) -> {
            BasicIssue ret = state.getNext();
            if (ret == null) {
                sink.complete();
            } else {
                sink.next(ret);
            }
            return state;
        }
}


class IssuesState {

    private final AtomicBoolean isDone = new AtomicBoolean(false);
    private final AtomicInteger threadCount = new AtomicInteger(1);
    private final Executor executor = Executors.newCachedThreadPool();
    private final LinkedBlockingQueue<BasicIssue> issueQueue = new LinkedBlockingQueue();

    public IssuesState(WebClient webClient) {
        executor.execute(() -> getNextBlock(webClient, 0));
    }

    private void getNextBlock(final WebClient webClient, final int startAt) {
        webClient
            .get()
            .uri(...)
            .header("Authorization", "Basic " + Base64Utils.encodeToString(("username:password".getBytes(UTF_8))))
            .accept(MediaType.APPLICATION_JSON)
            .retrieve()
            .bodyToMono(PageableIssue.class)
            .subscribe(pageableIssue -> {
                int maxResults = pageableIssue.getMaxResults();
                int total = pageableIssue.getTotal();
                if (startAt == 0) {
                    for (int i = startAt + maxResults; i < total; i += maxResults) {
                        threadCount.incrementAndGet();
                        final int x = i;
                        executor.execute(() -> getNextBlock(webClient, x));
                    }
                }
                synchronized (issueQueue) {
                    for (BasicIssue issue : pageableIssue.getIssues()) {
                        issueQueue.add(issue);
                    }

                    if (threadCount.decrementAndGet() == 0) {
                        isDone.set(true);
                    }
                }
            });
    }

    public BasicIssue getNext() {
        synchronized (issueQueue) {
            if (isDone.get() && issueQueue.isEmpty()) {
                return null;
            }
        }
        try {
            return issueQueue.take();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return null;
    }
}

Using the above method..

getIssues(webClient)
    .subscribe(basicIssue -> System.out.println(basicIssue.getName());