Startseite / I/O / WebSocket-Clients mit java.net.http
I/O Fortgeschritten

WebSocket-Clients mit java.net.http

Den asynchronen Standard-WebSocket-Client verwenden, statt eine Drittanbieterabhängigkeit hinzuzufügen.

HTTP I/O Async Programming
Code-Vergleich
✕ 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);
            }
        });
Problem mit diesem Code entdeckt? Sag uns Bescheid.
Warum der moderne Weg gewinnt
📦

Keine zusätzliche Abhängigkeit

Der WebSocket-Client ist Bestandteil des JDK.

🧵

Asynchrone API

Verbindungsaufbau und Nachrichtenverarbeitung lassen sich mit CompletionStage kombinieren.

🔗

Gemeinsamer HTTP-Stack

Proxy-, TLS- und Executor-Konfiguration verwenden die Standardfunktionen des JDK.

Alter Ansatz
WebSocket-Client eines Drittanbieters
Moderner Ansatz
java.net.http.WebSocket
Seit JDK
11
Schwierigkeitsgrad
Fortgeschritten
JDK-Unterstützung
WebSocket-Clients mit java.net.http
Verfügbar

Weitgehend verfügbar seit JDK 11 (September 2018)

Wie es funktioniert

Das Paket java.net.http enthält einen asynchronen WebSocket-Client, der in den Standard-HTTP-Client integriert ist. Verbindungen werden mit CompletableFuture aufgebaut, Listener-Callbacks unterstützen über CompletionStage die nicht blockierende Nachrichtenverarbeitung, und der Client verwendet die standardmäßige Proxy-, TLS- und Executor-Konfiguration des JDK.

Zugehörige Dokumentation
WebSocket ↗ HTTP Client (JEP 321) ↗
Beweis
Beweisquelle ansehen ↗
Verwandte Muster
I/O Einsteiger

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();
Hover für Modernes ➜
JDK 11+ →
Concurrency Fortgeschritten

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);
Hover für Modernes ➜
JDK 8+ →
Concurrency Fortgeschritten

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();
}
Hover für Modernes ➜
JDK 21+ →