一个应用程序取决于其他应用程序的结果，我们如何在Java中实现呢？

Question

以下问题在采访中问。让不同的服务相互调用，有一个服务A，它调用服务B需要20秒。 Service A也在调用Service C和Service D，它们分别花费25秒和20秒。当服务A从B，C，D获得响应时，它必须返回到前端响应。您将如何实现这一目标。

我认为Interviewer的意思是从并发请求多线程或ExecutorService。因此，我告诉我们可以从Callable接口使用FutureObect Return。为此，我编写了以下代码：以下代码正在工作并返回结果：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接口外，它还具有CompletionStage接口，可用于通过管道传递多个操作。

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

如果有任何请求的服务抛出异常，它还会使您优雅地失败。

它与Javascript中的promise非常相似。