如何在CompletableFuture中同时收集成功与错误结果？

我来帮你搞定这个lambda变量不可修改的问题～ 核心原因是Java的lambda表达式要求引用的外部变量必须是final或者effectively final的，直接修改errors列表肯定不行，而且你不想提前初始化空列表的优化思路非常合理，下面给你两种优雅的解决方案：

方案1：使用AtomicReference（推荐） #

用AtomicReference来包裹你的错误列表，既能保持变量的effectively final特性，又能实现懒初始化：

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.atomic.AtomicReference;
import java.util.stream.Collectors;

public Map.Entry<List<Rsp>, List<Req>> sendApiRequests(List<Req> reqs) { 
    // 用AtomicReference包裹错误请求列表，初始为null
    AtomicReference<List<Req>> errorReqRef = new AtomicReference<>();

    List<CompletableFuture<Rsp>> futures = reqs.stream()
        .map(req -> CompletableFuture.supplyAsync(() -> send(req))
            .exceptionally(ex -> {
                // 原子操作懒创建列表并添加错误请求
                errorReqRef.updateAndGet(errorReqs -> {
                    if (errorReqs == null) {
                        errorReqs = new ArrayList<>();
                    }
                    errorReqs.add(req);
                    return errorReqs;
                });
                // 返回null或者带错误标记的Rsp实例，根据业务需求调整
                return null;
            }))
        .collect(Collectors.toList());

    // 等待所有请求完成，收集成功响应（过滤错误时返回的null）
    List<Rsp> successResponses = futures.stream()
        .map(CompletableFuture::join)
        .filter(Objects::nonNull)
        .collect(Collectors.toList());

    // 获取错误列表，无错误则为null
    List<Req> errorReqs = errorReqRef.get();

    // 返回成功结果与错误请求集合（原方法返回类型可根据实际业务调整）
    return Map.entry(successResponses, errorReqs);
}

// 假设的send方法
private Rsp send(Req req) {
    // 你的API调用逻辑
    return new Rsp();
}

// 假设的Req、Rsp类
class Req {}
class Rsp {}

方案2：自定义可变容器类 #

如果你不想用原子类，也可以自己写一个简单的容器类存放列表，原理是容器本身是final的，修改的是容器内部的列表属性：

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.concurrent.CompletableFuture;
import java.util.stream.Collectors;

// 自定义可变列表容器
private static class MutableList<T> {
    private List<T> list;

    public void add(T item) {
        if (list == null) {
            list = new ArrayList<>();
        }
        list.add(item);
    }

    public List<T> get() {
        return list;
    }
}

public Map.Entry<List<Rsp>, List<Req>> sendApiRequests(List<Req> reqs) { 
    MutableList<Req> errorContainer = new MutableList<>();

    List<CompletableFuture<Rsp>> futures = reqs.stream()
        .map(req -> CompletableFuture.supplyAsync(() -> send(req))
            .exceptionally(ex -> {
                errorContainer.add(req);
                return null; // 返回错误标记对象
            }))
        .collect(Collectors.toList());

    List<Rsp> successResponses = futures.stream()
        .map(CompletableFuture::join)
        .filter(Objects::nonNull)
        .collect(Collectors.toList());

    return Map.entry(successResponses, errorContainer.get());
}

// 假设的send、Req、Rsp类同方案1

额外注意点 #

1. 原代码中exceptionally的返回值需要修正：supplyAsync要求返回Rsp类型，所以必须返回一个合法的Rsp实例（比如null、空对象或者带错误信息的Rsp），否则编译不通过。
2. 我调整了方法返回类型为Map.Entry<List<Rsp>, List<Req>>，因为原方法的Map.Entry<Rsp, Errors>看起来不符合批量请求的场景，你可以根据自己的Errors类做对应替换。

内容的提问来源于stack exchange，提问作者membersound