Java中如何构建多态结构统一处理异步任务的成功与错误响应？

你的问题很典型——在异步批量处理中，既要保留所有成功/失败结果，又要避免繁琐的类型强转。当前基于SomeResponse接口的方案是可行的，但确实存在强转不够优雅的问题，这里给你几个更优的替代思路：

方案一：用访问者模式消除强转（面向对象风格） #

访问者模式可以让你在不修改SomeResponse实现类的前提下，安全地处理不同类型的响应，完全避免显式强转。

首先修改你的SomeResponse接口，添加一个接受访问者的方法：

public interface SomeResponse {
    boolean isSuccess();
    void accept(ResponseVisitor visitor);
}

// 定义访问者接口，对应两种响应类型
public interface ResponseVisitor {
    void visitSuccess(SomeSuccessResponse successResponse);
    void visitError(SomeErrorResponse errorResponse);
}

然后让两个实现类实现accept方法：

public class SomeSuccessResponse implements SomeResponse {
    private final String value;
    private final boolean success = true;

    // 构造器、getter省略

    @Override
    public void accept(ResponseVisitor visitor) {
        visitor.visitSuccess(this);
    }
}

public class SomeErrorResponse implements SomeResponse {
    private final Throwable error;
    private final boolean success = false;

    // 构造器、getter省略

    @Override
    public void accept(ResponseVisitor visitor) {
        visitor.visitError(this);
    }
}

调用方处理响应时，直接通过访问者处理不同类型，不用强转：

List<SomeResponse> responses = processor.process(requestList);
for (SomeResponse resp : responses) {
    resp.accept(new ResponseVisitor() {
        @Override
        public void visitSuccess(SomeSuccessResponse success) {
            // 直接处理成功结果，比如success.getValue()
            System.out.println("处理成功：" + success.getValue());
        }

        @Override
        public void visitError(SomeErrorResponse error) {
            // 直接处理错误，比如error.getError()
            System.err.println("处理失败：" + error.getError().getMessage());
        }
    });
}

这种方式类型安全，符合开闭原则，后续如果新增响应类型，只需要扩展访问者接口和实现类即可。

方案二：用Either类型区分成功/失败（函数式风格） #

如果你的项目偏向函数式编程，Either类型是更简洁的选择——它明确将结果分为“左（错误）”和“右（成功）”两个分支，语义清晰，无需额外的接口判断。

如果没有引入Vavr这类函数式库，你可以自己实现一个极简版的Either：

public class Either<L, R> {
    private final L left; // 错误分支
    private final R right; // 成功分支
    private final boolean isLeft;

    private Either(L left, R right, boolean isLeft) {
        this.left = left;
        this.right = right;
        this.isLeft = isLeft;
    }

    // 静态工厂方法创建错误/成功实例
    public static <L, R> Either<L, R> left(L left) {
        return new Either<>(left, null, true);
    }

    public static <L, R> Either<L, R> right(R right) {
        return new Either<>(null, right, false);
    }

    // 判断分支的方法
    public boolean isLeft() { return isLeft; }
    public boolean isRight() { return !isLeft; }

    // 获取对应分支的值（注意：非对应分支调用会抛异常，也可以添加安全获取的方法）
    public L getLeft() {
        if (!isLeft) throw new IllegalStateException("当前不是错误分支");
        return left;
    }

    public R getRight() {
        if (isLeft) throw new IllegalStateException("当前不是成功分支");
        return right;
    }
}

然后修改你的处理方法，返回Either类型：

public class MyProcessorClass {
    private final SomeOtherClass someOtherClass;

    // 构造器省略

    public CompletableFuture<List<Either<SomeErrorResponse, SomeSuccessResponse>>> process(List<String> requestList) {
        List<CompletableFuture<Either<SomeErrorResponse, SomeSuccessResponse>>> futures = requestList.stream()
                .map(this::processRequestAsync)
                .collect(Collectors.toList());

        // 等待所有异步任务完成后收集结果
        return CompletableFuture.allOf(futures.toArray(new CompletableFuture[0]))
                .thenApply(v -> futures.stream()
                        .map(CompletableFuture::join)
                        .collect(Collectors.toList()));
    }

    private CompletableFuture<Either<SomeErrorResponse, SomeSuccessResponse>> processRequestAsync(String request) {
        return CompletableFuture.supplyAsync(() -> someOtherClass.execute(request))
                .thenApply(result -> Either.right(new SomeSuccessResponse(result)))
                .exceptionally(e -> Either.left(new SomeErrorResponse(e.getCause())));
    }
}

调用方处理时，直接判断分支即可：

processor.process(requestList).thenAccept(results -> {
    for (Either<SomeErrorResponse, SomeSuccessResponse> result : results) {
        if (result.isRight()) {
            SomeSuccessResponse success = result.getRight();
            // 处理成功
        } else {
            SomeErrorResponse error = result.getLeft();
            // 处理错误
        }
    }
});

重要优化：修复异步处理的阻塞问题 #

注意到你原有代码中用了completableFuture.get()，这会阻塞当前线程，完全失去了异步处理的意义。上面的示例中已经改成了用CompletableFuture.allOf()等待所有任务完成，然后收集结果，这样整个处理流程是真正异步的，不会阻塞调用线程。

不推荐的方案：统一DTO #

有些同学会想到用一个包含所有字段的统一DTO（比如同时有success、value、error字段），但这种方式存在字段冗余和NPE风险（成功时error为null，错误时value为null），类型安全性差，所以不推荐。

总结 #

• 如果喜欢面向对象的扩展性，访问者模式是最佳选择，完全避免强转，类型安全；
• 如果偏向函数式编程风格，Either类型更简洁清晰，语义明确；
• 一定要修正异步处理的方式，避免使用get()阻塞线程，充分利用CompletableFuture的异步特性。

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