JManus 分析

在 Java 中，与 JavaScript 的 Promise 最接近的是 CompletableFuture（Java 8+）。下面是对比和示例：

主要等价物

1. CompletableFuture（最接近 Promise）

CompletableFuture 提供了与 Promise 类似的链式调用和组合能力：

#### JavaScript Promise 示例

// TypeScript/JavaScript
async function getDetails(planId: string) {
  const response = await fetch(`/api/details/${planId}`)
  return response.json()
}

#### Java CompletableFuture 等价写法

import java.util.concurrent.CompletableFuture;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public CompletableFuture<String> getDetails(String planId) {
    HttpClient client = HttpClient.newHttpClient();
    HttpRequest request = HttpRequest.newBuilder()
        .uri(URI.create("/api/details/" + planId))
        .build();
    
    return client.sendAsync(request, HttpResponse.BodyHandlers.ofString())
        .thenApply(response -> {
            // 处理响应
            return response.body();
        });
}

对比表

实际代码对比

JavaScript（来自你的代码）

// agent.ts 中的代码风格
export const getAllAgents = async (): Promise<AgentEntity[]> => {
  const response = await fetch('/api/agent-management')
  return handleResponse(response)
}

Java 等价写法

import java.util.concurrent.CompletableFuture;
import java.util.List;

public class AgentService {
    private static final String BASE_URL = "/api/agent-management";
    
    public CompletableFuture<List<AgentEntity>> getAllAgents() {
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create(BASE_URL))
            .build();
        
        return client.sendAsync(request, HttpResponse.BodyHandlers.ofString())
            .thenApply(response -> {
                if (response.statusCode() != 200) {
                    throw new RuntimeException("HTTP error: " + response.statusCode());
                }
                return parseJson(response.body()); // 解析 JSON
            })
            .exceptionally(error -> {
                System.err.println("Failed to get agents: " + error);
                throw new RuntimeException(error);
            });
    }
}

其他 Java 异步选项

2. Future（基础版本）

import java.util.concurrent.Future;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

ExecutorService executor = Executors.newCachedThreadPool();
Future<String> future = executor.submit(() -> {
    // 异步任务
    return "result";
});

String result = future.get(); // 阻塞等待

• 功能较少，不支持链式调用
• 需要手动管理线程池

3. ListenableFuture（Guava）

import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.Futures;

ListenableFuture<String> future = service.submit(() -> "result");
Futures.addCallback(future, new FutureCallback<String>() {
    public void onSuccess(String result) { }
    public void onFailure(Throwable t) { }
}, executor);

• 需要 Guava 依赖
• 功能不如 CompletableFuture 丰富

4. Reactive Streams（RxJava / Project Reactor）

// RxJava
Observable<String> observable = Observable.fromCallable(() -> "result");
observable.subscribe(
    result -> System.out.println(result),
    error -> System.err.println(error)
);

// Project Reactor (Spring WebFlux)
Mono<String> mono = Mono.fromCallable(() -> "result");
mono.subscribe(
    result -> System.out.println(result),
    error -> System.err.println(error)
);

• 更强大的响应式编程模型
• 适合复杂的数据流处理

推荐使用

对于大多数场景，推荐使用 CompletableFuture：

优点

• Java 8+ 内置，无需额外依赖
• 支持链式调用，代码清晰
• 支持组合多个异步操作
• 错误处理机制完善

示例：类似你的 handleResponse

private CompletableFuture<Response> handleResponse(HttpResponse<String> response) {
    if (response.statusCode() != 200) {
        return CompletableFuture.failedFuture(
            new RuntimeException("HTTP error: " + response.statusCode())
        );
    }
    return CompletableFuture.completedFuture(response);
}

// 使用
public CompletableFuture<AgentEntity[]> getAllAgents() {
    return sendRequest("/api/agent-management")
        .thenCompose(this::handleResponse)
        .thenApply(response -> parseJson(response.body()));
}

总结

• 最接近 Promise：CompletableFuture
• 使用场景：异步网络请求、并发任务处理
• 优势：内置、链式调用、组合能力强
• 适用版本：Java 8+