Strona główna / I/O / Klienci WebSocket z java.net.http
I/O Średniozaawansowany

Klienci WebSocket z java.net.http

Używaj standardowego asynchronicznego klienta WebSocket zamiast dodawać zewnętrzną zależność.

HTTP I/O Async Programming
Porównanie kodu
✕ Third-party library 
WebSocketClient client =
    new WebSocketClient(serverUri) {
        @Override
        public void onMessage(String message) {
            handle(message);
        }
    };
client.connect();
✓ Java 11+ 
HttpClient.newHttpClient()
    .newWebSocketBuilder()
    .buildAsync(serverUri,
        new WebSocket.Listener() {
            @Override
            public CompletionStage<?> onText(
                    WebSocket socket,
                    CharSequence data,
                    boolean last) {
                handle(data.toString());
                return WebSocket.Listener.super
                    .onText(socket, data, last);
            }
        });
Widzisz problem z tym kodem? Daj nam znać.
Dlaczego nowoczesne podejście wygrywa
📦

Bez dodatkowej zależności

Klient WebSocket jest dostarczany z JDK.

🧵

Asynchroniczne API

Nawiązywanie połączenia i obsługę wiadomości można komponować z CompletionStage.

🔗

Wspólny stos HTTP

Konfiguracja proxy, TLS i executora korzysta ze standardowych mechanizmów JDK.

Stare podejście
Klient WebSocket z biblioteki zewnętrznej
Nowoczesne podejście
java.net.http.WebSocket
Od JDK
11
Poziom trudności
Średniozaawansowany
Wsparcie JDK
Klienci WebSocket z java.net.http
Dostępne

Szeroko dostępne od JDK 11 (wrzesień 2018)

Jak to działa

Pakiet java.net.http zawiera asynchronicznego klienta WebSocket zintegrowanego ze standardowym klientem HTTP. Połączenia są nawiązywane za pomocą CompletableFuture, wywołania zwrotne listenera umożliwiają nieblokujące przetwarzanie wiadomości przez CompletionStage, a klient korzysta ze standardowej konfiguracji proxy, TLS i executora w JDK.

Powiązana dokumentacja
WebSocket ↗ HTTP Client (JEP 321) ↗
Dowód
Zobacz źródło dowodu ↗
Powiązane wzorce
I/O Początkujący

Modern HTTP client

Java 8
URL url = new URL("https://api.com/data");
HttpURLConnection con =
    (HttpURLConnection) url.openConnection();
con.setRequestMethod("GET");
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
// read lines, close streams...
Java 11+
var client = HttpClient.newHttpClient();
var request = HttpRequest.newBuilder()
    .uri(URI.create("https://api.com/data"))
    .build();
var response = client.send(
    request, BodyHandlers.ofString());
String body = response.body();
Najedź, aby zobaczyć nową wersję ➜
JDK 11+ →
Concurrency Średniozaawansowany

CompletableFuture chaining

Pre-Java 8
Future<String> future =
    executor.submit(this::fetchData);
String data = future.get(); // blocks
String result = transform(data);
Java 8+
CompletableFuture.supplyAsync(
    this::fetchData
)
.thenApply(this::transform)
.thenAccept(IO::println);
Najedź, aby zobaczyć nową wersję ➜
JDK 8+ →
Concurrency Średniozaawansowany

Concurrent HTTP with virtual threads

Java 8
ExecutorService pool =
    Executors.newFixedThreadPool(10);
List<Future<String>> futures =
    urls.stream()
    .map(u -> pool.submit(
        () -> fetchUrl(u)))
    .toList();
// manual shutdown, blocking get()
Java 21+
try (var exec = Executors
    .newVirtualThreadPerTaskExecutor()) {
    var results = urls.stream()
        .map(u -> exec.submit(
            () -> client.send(req(u),
                ofString()).body()))
        .toList().stream()
        .map(Future::join).toList();
}
Najedź, aby zobaczyć nową wersję ➜
JDK 21+ →