Java Academy · 课时

异步请求

sendAsync 与 CompletableFuture

异步请求 是 CoddyKit 上的免费 Java Academy 课时。这是第 2 节课，共 4 节。你可以在下方免费阅读本课时的完整内容 — 然后在浏览器中使用内置代码编辑器和全天候 AI 导师进行实践。这是 Java Academy 学习路径的一部分，你的进度在网页和 CoddyKit 应用中同步。 Java Academy 课程共包含 4 节课。

异步请求

每次 HTTP 调用都进行阻塞会浪费线程。JDK HTTP 客户端提供了 sendAsync，它会立即返回一个 CompletableFuture，并在后台执行器中执行任务。

这样，您就可以并发发起多个请求，并组合它们的结果，而无需手动管理线程。

send 与 sendAsync

两者的方法签名在返回值方面有所不同：

send 返回 HttpResponse<T> 并会阻塞，同时声明 IOException 和 InterruptedException。
sendAsync 返回 CompletableFuture<HttpResponse<T>>，从不阻塞；错误会通过异步结果对象暴露出来。

基本的 sendAsync 调用

sendAsync 接受与 send 相同的请求和 BodyHandler。返回的异步结果对象会在响应准备就绪时完成。

import java.net.URI;
import java.net.http.*;
import java.util.concurrent.CompletableFuture;

public class Main {
    public static void main(String[] args) {
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://example.com"))
            .build();
        CompletableFuture<HttpResponse<String>> future =
            client.sendAsync(request, HttpResponse.BodyHandlers.ofString());
        System.out.println("Request sent, future created");
    }
}

使用 thenApply 进行转换

使用 thenApply 在结果到达后进行转换，例如从响应中提取正文。

此操作会在完成前一阶段的线程上同步运行。

import java.util.concurrent.CompletableFuture;

public class Main {
    public static void main(String[] args) throws Exception {
        CompletableFuture<String> future =
            CompletableFuture.completedFuture("OK 200")
                .thenApply(body -> "Length=" + body.length());
        System.out.println(future.get());
    }
}

使用 thenAccept 消费结果

如果您只需要执行副作用而不需要返回值，请使用 thenAccept。它接受一个 Consumer，并生成一个 CompletableFuture<Void>。

import java.util.concurrent.CompletableFuture;

public class Main {
    public static void main(String[] args) throws Exception {
        CompletableFuture<Void> done =
            CompletableFuture.completedFuture("payload")
                .thenAccept(b -> System.out.println("Received: " + b));
        done.get();
    }
}

使用 join 阻塞等待

要在 main 中等待异步结果，请调用 join()（无需检查异常）或 get()（需要检查异常）。在真实服务器中，您应当串联各个阶段，而不是进行阻塞等待。

join() 会将失败包装在未经检查的 CompletionException 中。

import java.util.concurrent.CompletableFuture;

public class Main {
    public static void main(String[] args) {
        CompletableFuture<Integer> f =
            CompletableFuture.supplyAsync(() -> 21).thenApply(n -> n * 2);
        int result = f.join();
        System.out.println("Result: " + result);
    }
}

使用 exceptionally 处理错误

exceptionally 会在某个阶段失败时提供一个回退值，从而恢复流程。

这样可以避免异步 HTTP 流程因网络错误而终止。

import java.util.concurrent.CompletableFuture;

public class Main {
    public static void main(String[] args) {
        CompletableFuture<String> f = CompletableFuture
            .<String>supplyAsync(() -> { throw new RuntimeException("boom"); })
            .exceptionally(ex -> "fallback: " + ex.getMessage());
        System.out.println(f.join());
    }
}

组合两个请求

thenCombine 会等待两个彼此独立的异步结果对象，并合并它们的结果。结合异步 HTTP 使用时，它可以并行获取两个端点的内容，然后合并正文。

import java.util.concurrent.CompletableFuture;

public class Main {
    public static void main(String[] args) {
        CompletableFuture<String> a = CompletableFuture.supplyAsync(() -> "Hello");
        CompletableFuture<String> b = CompletableFuture.supplyAsync(() -> "World");
        String combined = a.thenCombine(b, (x, y) -> x + " " + y).join();
        System.out.println(combined);
    }
}

并行发起多个请求

要运行一批请求，请将每个异步结果对象收集到列表中，然后使用 CompletableFuture.allOf(...) 等待它们全部完成。

allOf 返回 CompletableFuture<Void>；之后您可以单独读取各个结果。

import java.util.*;
import java.util.concurrent.CompletableFuture;

public class Main {
    public static void main(String[] args) {
        List<CompletableFuture<Integer>> futures = new ArrayList<>();
        for (int i = 1; i <= 3; i++) {
            int n = i;
            futures.add(CompletableFuture.supplyAsync(() -> n * n));
        }
        CompletableFuture.allOf(futures.toArray(new CompletableFuture[0])).join();
        for (var f : futures) System.out.println(f.join());
    }
}

异步模式总结

典型的异步 HTTP 流程如下：

client.sendAsync(req, BodyHandlers.ofString())
.thenApply(HttpResponse::body) 用于获取正文
.thenAccept(System.out::println) 用于消费正文
.exceptionally(ex -> ...) 用于恢复

整个过程中不会有线程阻塞等待网络操作。

何时使用异步调用

当您需要并发发起大量调用、向多个服务发起请求，或在响应式/非阻塞服务器中运行时，请选择 sendAsync。对于简单脚本和偶尔执行且允许阻塞的调用，请选择 send。

快速检查

检查您对异步请求的理解。

回顾

您已经学会了如何发起非阻塞 HTTP 调用：

sendAsync 返回一个 CompletableFuture，而不是进行阻塞。
thenApply / thenAccept 用于转换和消费结果。
exceptionally 会在失败时提供回退值。
thenCombine 合并两个并行调用；allOf 等待一批调用完成。
异步调用适合高并发和响应式服务器；同步调用适合简单脚本。

常见问题解答

「异步请求」课时是免费的吗？

是的 — 「异步请求」的完整文本可在网页上免费阅读。要进行交互式练习（内置代码编辑器和全天候 AI 导师）并解锁 Java Academy 课程的其余内容，请升级到 CoddyKit PRO。 Java Academy 课程共包含 4 节课。

「异步请求」这节课中我会学到什么？

sendAsync 与 CompletableFuture 你通过在浏览器中直接运行的动手代码来练习 Java Academy，全天候 AI 导师会在你学习这节课的过程中回答你的问题。

学习 Java Academy 需要有经验吗？

无需任何先前经验。CoddyKit 上的 Java Academy 课程适合初学者到高级学习者，你可以从这里开始或从头开始，按照自己的节奏学习。这是第 2 节课，共 4 节。

「异步请求」课时需要多长时间？

大多数 CoddyKit 课程大约需要 5–10 分钟。每节课都很精短且互动，所以你能稳步进步，并在网页和应用中从离开的地方继续。

我能在这节 Java Academy 课中编写并运行代码吗？

能。每节 Java Academy 课都包含内置代码编辑器，你可以在浏览器中直接编写并运行真实代码，并获得即时 AI 反馈 — 无需本地设置。

此课程中的所有课时

← 返回 Java Academy