java - 一个应用程序依赖于其他应用程序的结果，我们如何在Java中实现这一点？

Question

采访中提出以下问题。让不同的服务互相调用，有一个服务A，它正在调用服务B，需要20秒。 服务A还调用服务C和服务D，分别需要25秒和20秒。当服务A收到B、C、D的响应时，它必须将响应返回给前端。您将如何实现这一目标。

我认为面试官的意思是要求多线程或者并发的ExecutorService。所以我告诉我们可以使用可调用接口(interface)中的 Future 对象返回。为此，我编写了以下代码:以下代码正在运行并返回结果:45，这是正确的。

当一个应用程序依赖于另一个应用程序结果时，我的方法是否正确？在实际应用中我们是否使用这种方法？请告诉我代码中是否有任何更正？

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.*;

class Result{
    String applicationName;
    int result;
    public Result(String applicationName, int result){
        this.applicationName = applicationName;
        this.result = result;
    }
    public void add(int value){
        this.result += value;
    }

    public int getResult() {
        return result;
    }
}
class ApplicationA implements Callable<Result>{
    @Override
    public Result call() throws Exception {
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        List<Future<Result>> list = new ArrayList<Future<Result>>();
        Future<Result> futureB = executorService.submit(new ApplicationB());
        list.add(futureB);
        Future<Result> futureC = executorService.submit(new ApplicationC());
        list.add(futureC);
        Future<Result> futureD = executorService.submit(new ApplicationD());
        list.add(futureD);

        Result result = new Result("ApplicationA", 12);
        for(Future<Result> future: list){
            try {
                Result result1 = future.get();
                result.add(result1.getResult());
            }catch (InterruptedException | ExecutionException e){
                e.printStackTrace();
            }
        }
        executorService.shutdown();
        return result;
    }
}
class ApplicationB implements Callable<Result>{
    @Override
    public Result call() throws Exception {
        Thread.sleep(20000);
        return new Result("ApplicationB",10);
    }
}
class ApplicationC implements Callable<Result>{
    @Override
    public Result call() throws Exception {
        Thread.sleep(25000);
        return new Result("ApplicationC",11);
    }
}
class ApplicationD implements Callable<Result>{
    @Override
    public Result call() throws Exception {
        Thread.sleep(20000);
        return new Result("ApplicationD",12);
    }
}
public class MultiApplicationDemo {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        Future<Result> futureA = executorService.submit(new ApplicationA());
        System.out.println(futureA.get().getResult());
        executorService.shutdown();
    }
}

Answer 1

使用Future是一个阻塞操作。 CompletableFuture另一方面将为您提供非阻塞机制。除了 Future 接口(interface)之外，它还具有 CompletionStage 接口(interface)，允许您通过管道传输多个操作。

CompletableFuture<String> completableFuture 
  = CompletableFuture.supplyAsync(() -> "Hello")
    .thenCompose(s -> CompletableFuture.supplyAsync(() -> s + " World"));

它还可以让您在任何请求的服务抛出异常的情况下优雅地失败。

它与 Javascript 中的 Promise 非常相似。