如何在Maven JavaFX项目中实现异步HTTP GET请求？

首先明确：异步并行调用确实是解决这类问题的核心思路——原来的串行请求是逐个等待响应，总耗时是所有请求耗时的累加；并行请求则是同时发起多个请求，总时间接近单个请求的最大耗时（只要服务器能承受并发，且本地并发数设置合理），完全有可能把半分钟的耗时压缩到1秒内。

下面针对你的Maven JavaFX项目，提供几种可行的实现方案：

第一步：先优化原有同步请求方法 #

原方法里的result += output字符串拼接效率极低，先改成StringBuilder，同时优化资源关闭方式：

public static String dataRequest(String link) throws IOException {
    URL url = new URL(link);
    HttpURLConnection conn = (HttpURLConnection) url.openConnection();
    conn.setRequestMethod("GET");
    conn.setRequestProperty("Accept", "application/json");
    
    if (conn.getResponseCode() != 200) {
        throw new RuntimeException("Failed : HTTP Error code : " + conn.getResponseCode());
    }

    // 使用try-with-resources自动关闭流，避免资源泄漏
    try (InputStreamReader in = new InputStreamReader(conn.getInputStream());
         BufferedReader br = new BufferedReader(in)) {
        StringBuilder result = new StringBuilder();
        String output;
        while ((output = br.readLine()) != null) {
            result.append(output);
        }
        return result.toString();
    } finally {
        conn.disconnect();
    }
}

方案一：用Java原生CompletableFuture实现并行请求 #

无需额外依赖，直接用JDK自带的异步工具类，适合快速实现：

import javafx.application.Platform;
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import java.util.stream.Collectors;

// 假设你有需要请求的链接列表
List<String> requestLinks = Arrays.asList("https://api.example.com/data1", "https://api.example.com/data2", ...);

// 1. 为每个链接创建异步请求任务
List<CompletableFuture<String>> futureList = requestLinks.stream()
        .map(link -> CompletableFuture.supplyAsync(() -> {
            try {
                return getData.dataRequest(link);
            } catch (IOException e) {
                // 捕获单个请求异常，避免影响其他任务
                return "请求失败：" + e.getMessage();
            }
        }))
        .collect(Collectors.toList());

// 2. 等待所有请求完成，设置1秒超时
try {
    CompletableFuture<Void> allTasksDone = CompletableFuture.allOf(futureList.toArray(new CompletableFuture[0]));
    allTasksDone.get(1, TimeUnit.SECONDS); // 超时1秒

    // 3. 收集所有请求结果
    List<String> results = futureList.stream()
            .map(CompletableFuture::join)
            .collect(Collectors.toList());

    // 4. 在JavaFX UI线程更新界面（必须用Platform.runLater，否则会报错）
    Platform.runLater(() -> {
        // 这里写更新UI的逻辑，比如把结果显示到ListView、Label等
        // example: resultListView.getItems().addAll(results);
    });
} catch (InterruptedException | ExecutionException | TimeoutException e) {
    // 处理超时或全局异常
    Platform.runLater(() -> {
        // example: errorLabel.setText("请求超时或失败：" + e.getMessage());
    });
}

方案二：用JavaFX Task实现并行请求 #

JavaFX自带的Task类专门用于异步任务，天然适配UI线程回调：

import javafx.application.Platform;
import javafx.concurrent.Task;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

List<String> requestLinks = Arrays.asList("https://api.example.com/data1", "https://api.example.com/data2", ...);
// 控制并发数，避免无限制创建连接（建议设置为10-20，根据服务器承受能力调整）
ExecutorService executor = Executors.newFixedThreadPool(Math.min(requestLinks.size(), 15));
List<Task<String>> taskList = new ArrayList<>();

for (String link : requestLinks) {
    Task<String> requestTask = new Task<>() {
        @Override
        protected String call() throws Exception {
            return getData.dataRequest(link);
        }
    };

    // 单个任务成功回调（自动在UI线程执行）
    requestTask.setOnSucceeded(event -> {
        String result = requestTask.getValue();
        // 可实时处理单个请求结果，比如逐步添加到UI
        // example: resultListView.getItems().add(result);
    });

    // 单个任务失败回调
    requestTask.setOnFailed(event -> {
        Throwable error = requestTask.getException();
        // example: resultListView.getItems().add("请求失败：" + error.getMessage());
    });

    taskList.add(requestTask);
    executor.submit(requestTask);
}

// 等待所有任务完成或超时1秒
executor.shutdown();
try {
    if (!executor.awaitTermination(1, TimeUnit.SECONDS)) {
        executor.shutdownNow();
        Platform.runLater(() -> {
            // example: errorLabel.setText("部分请求超时");
        });
    }
} catch (InterruptedException e) {
    executor.shutdownNow();
    Thread.currentThread().interrupt();
}

关于RxJava的补充（解决你之前的问题） #

如果一定要用RxJava，核心是正确指定线程调度——请求在IO线程执行，结果回调在JavaFX UI线程处理：

1. 先在Maven中添加依赖：

<dependency>
    <groupId>io.reactivex.rxjava3</groupId>
    <artifactId>rxjava</artifactId>
    <version>3.1.5</version>
</dependency>
<dependency>
    <groupId>io.reactivex.rxjava3</groupId>
    <artifactId>rxjavafx</artifactId>
    <version>3.0.1</version>
</dependency>

2. 代码实现：

import io.reactivex.rxjava3.core.Observable;
import io.reactivex.rxjava3.schedulers.Schedulers;
import io.reactivex.rxjava3.schedulers.JavaFxScheduler;
import java.util.Arrays;
import java.util.List;

List<String> requestLinks = Arrays.asList("https://api.example.com/data1", "https://api.example.com/data2", ...);

Observable.fromIterable(requestLinks)
        // 每个请求在IO线程执行
        .flatMap(link -> Observable.fromCallable(() -> getData.dataRequest(link))
                .subscribeOn(Schedulers.io())
                // 处理单个请求异常，不中断整个流
                .onErrorReturn(e -> "请求失败：" + e.getMessage()))
        // 收集所有结果后，在JavaFX线程回调
        .toList()
        .observeOn(JavaFxScheduler.platform())
        .subscribe(results -> {
            // 更新UI逻辑
        }, error -> {
            // 全局异常处理
        });

关键注意事项 #

• 并发数控制：不要设置过大的并发数，否则可能被服务器限流，或者导致本地资源耗尽，建议根据服务器的并发限制调整（一般10-20个并发比较安全）。
• 异常隔离：单个请求失败不要影响其他请求，每个任务都要单独捕获异常。
• UI线程约束：JavaFX的UI组件只能在FX线程更新，所有涉及UI的操作必须通过Platform.runLater或者Task的回调方法执行。

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