Java 任务链中可完成的未来错误处理

我完全不知道如何处理CompletableFutures的错误。我需要的是让多个任务异步运行。这些任务由多个步骤组成，如本例所示：

从数据库接收数据->将此数据用于请求->执行另一个请求->更新数据库记录

现在，每个步骤都可能导致异常，即未找到数据库记录或数据不正确、请求失败、响应错误或更新数据库失败等。我想处理这些异常以记录错误并停止任务，甚至可能恢复任务

现在，我构建了一个新项目来使用CompletableFutures来模拟这个过程。我使用了以下代码：

public static Integer randomError() {
        Random rd = new Random();
        if(rd.nextBoolean()) {
            try {
                throw new Exception("RANDOM ERROR");
            } catch (Exception e) {
                e.printStackTrace();
            }
        } else {
            return rd.nextInt();
        }
        return 0;
    }


ExecutorService ex = Executors.newFixedThreadPool(64);
        System.out.println("Main thread: " + Thread.currentThread());
        //Starting tasks
        List<CompletableFuture> listTasks = new ArrayList<CompletableFuture>();
        List<String> listErrors = new ArrayList<String>();
        System.out.println("Starting threads...");
        for (int i = 0; i < 10; i++) {
            int counter = i;
            //Add tasks to TaskQueue (taskList)
            listTasks.add(
                CompletableFuture.supplyAsync(()->{
                    //Simulate step 1
                    return 0;
                },ex).thenApplyAsync(x -> {
                    //Simulate step 2
                    try {
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    return x + 1;
                }, ex).thenApplyAsync(x -> {
                    //Simulate step 3 with a potential error
                    randomError();
                    return x + 1;
                }, ex).thenApplyAsync(x -> {
                    //On error this shouldnt be executed?
                    //Simulate tep 4
                    try {
                        Thread.sleep(3000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    return x + 1;
                }, ex).thenAcceptAsync( x -> {
                      //Simulate COMPLETION step 5 
//                    listTasks.remove(counter);
                }, ex).exceptionally(e -> {
                    listErrors.add("ERROR: " + counter);
                    System.out.println(e);
                    return null;
                })
            );
        }
        System.out.println("Done");

public静态整数randomError（）{
随机rd=新随机（）；
if（rd.nextBoolean（））{
试一试{
抛出新异常（“随机错误”）；
}捕获（例外e）{
e、 printStackTrace（）；
}
}否则{
return rd.nextInt（）；
}
返回0；
}
ExecutorService ex=Executors.newFixedThreadPool（64）；
System.out.println（“主线程：+thread.currentThread（））；
//开始任务
List listTasks=new ArrayList（）；
List listerrrors=new ArrayList（）；
System.out.println（“起始线程…”）；
对于（int i=0；i<10；i++）{
int计数器=i；
//将任务添加到任务队列（任务列表）
listTasks.add(
CompletableFuture.SupplySync（（）->{
//模拟步骤1
返回0；
}然后应用同步（x->{
//模拟步骤2
试一试{
《睡眠》（2000年）；
}捕捉（中断异常e）{
e、 printStackTrace（）；
}
返回x+1；
}然后应用同步（x->{
//用一个潜在的错误模拟步骤3
随机误差（）；
返回x+1；
}然后应用同步（x->{
//出现错误时，是否不应执行此操作？
//模拟步骤4
试一试{
睡眠（3000）；
}捕捉（中断异常e）{
e、 printStackTrace（）；
}
返回x+1；
}，例如）。然后同步（x->{
//模拟完成步骤5
//listTasks.remove（计数器）；
}，例如）。例外情况下（e->{
添加（“错误：+计数器”）；
系统输出打印ln（e）；
返回null；
})
);
}
系统输出打印项次（“完成”）；

现在，这段代码创建了10个任务，其中每个任务由5个步骤组成。现在，当步骤3产生异常时，步骤4仍然执行。为什么？在串行监视器中，我看到抛出的错误，但CompletableFuture仍然完成OK。当我做

1/0。这会产生一个错误，该错误会被
.exception（）
捕获。如何捕获该异常而不是自定义抛出的异常

我想要的是出错，停止链并执行
.Exception（）
来处理错误。
因为，对于
捕获（异常e）{e.printStackTrace（）；}
。您的代码从不引发异常。它不
返回0Try{…}Catch（异常e）{…}
会做什么？它尝试抛出异常，一旦出错，它就会捕获异常。然而，这不应该抛出异常，这让我想知道为什么我必须使用Try-Catch块来抛出异常。