Java Networking & HTTP Client

HttpClient client = HttpClient.newHttpClient();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("https://api.example.com/users"))
    .header("Accept", "application/json")
    .GET()
    .build();

HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.statusCode());
System.out.println(response.body());

Common follow-ups: Why did the JDK team decide to introduce an entirely new HTTP client rather than improving HttpURLConnection directly?;What third-party libraries (like Apache HttpClient or OkHttp) were commonly used to work around HttpURLConnection's limitations before Java 11?

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("https://api.example.com/data"))
    .build();

CompletableFuture<String> futureBody = client.sendAsync(request, HttpResponse.BodyHandlers.ofString())
    .thenApply(HttpResponse::body)
    .exceptionally(ex -> {
        System.err.println("Request failed: " + ex.getMessage());
        return "";
    });

futureBody.thenAccept(System.out::println);  // processes the result once it eventually arrives

Common follow-ups: How would you set a per-request timeout that's independent of the HttpClient's own default connection timeout?;What thread does the CompletableFuture's continuation callbacks (like thenApply) actually execute on by default?

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("https://example.com/large-file.zip"))
    .build();

// Stream the response body directly to a file, without buffering it fully in memory
HttpResponse<Path> response = client.send(request,
    HttpResponse.BodyHandlers.ofFile(Path.of("downloaded-file.zip")));

// Or process line-by-line for a large text response
HttpResponse<Stream<String>> lineResponse = client.send(request, HttpResponse.BodyHandlers.ofLines());
lineResponse.body().forEach(line -> processLine(line));

Common follow-ups: What's the performance and memory trade-off of ofInputStream() versus a fully custom BodySubscriber implementation?;How would you implement progress reporting (bytes downloaded so far) for a large streaming download using a custom BodySubscriber?

HttpClient client = HttpClient.newBuilder()
    .connectTimeout(Duration.ofSeconds(5))   // max time to establish the connection itself
    .proxy(ProxySelector.of(new InetSocketAddress("proxy.example.com", 8080)))
    .build();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("https://api.example.com/data"))
    .timeout(Duration.ofSeconds(10))          // max time for THIS specific request/response exchange
    .build();

Common follow-ups: What happens to an in-flight request if the configured timeout is exceeded -- what specific exception is thrown?;How does HttpClient's connection pooling and reuse behavior differ between HTTP/1.1 and HTTP/2 protocol versions?

public <T> HttpResponse<T> sendWithRetry(HttpRequest request, HttpResponse.BodyHandler<T> handler, int maxAttempts) throws Exception {
    int attempt = 0;
    while (true) {
        try {
            HttpResponse<T> response = client.send(request, handler);
            if (response.statusCode() < 500) return response;  // don't retry client errors, only server errors
            throw new IOException("Server error: " + response.statusCode());
        } catch (IOException e) {
            attempt++;
            if (attempt >= maxAttempts) throw e;
            long delayMs = (long) (Math.pow(2, attempt) * 100);  // exponential backoff
            Thread.sleep(delayMs);
        }
    }
}

Common follow-ups: Why is it important to add random jitter to exponential backoff delays in a system with many concurrent clients, rather than using purely deterministic delay values?;What HTTP status codes and exception types genuinely warrant a retry versus those that don't?

ObjectMapper mapper = new ObjectMapper();
String jsonBody = mapper.writeValueAsString(new CreateUserRequest("Alice", "alice@example.com"));

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("https://api.example.com/users"))
    .header("Content-Type", "application/json")
    .POST(HttpRequest.BodyPublishers.ofString(jsonBody))
    .build();

HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
User createdUser = mapper.readValue(response.body(), User.class);

Common follow-ups: Why did the JDK team deliberately choose NOT to include built-in JSON support directly in HttpClient?;How would you handle a non-2xx response status code gracefully when parsing the response body, given an error response might have a different JSON structure than a success response?

WebSocket.Listener listener = new WebSocket.Listener() {
    public void onOpen(WebSocket webSocket) {
        System.out.println("Connected");
        WebSocket.Listener.super.onOpen(webSocket);
    }
    public CompletionStage<?> onText(WebSocket webSocket, CharSequence data, boolean last) {
        System.out.println("Received: " + data);
        return WebSocket.Listener.super.onText(webSocket, data, last);
    }
};

WebSocket webSocket = client.newWebSocketBuilder()
    .buildAsync(URI.create("wss://echo.example.com"), listener)
    .join();
webSocket.sendText("Hello!", true);

Common follow-ups: Why must Listener implementations typically call the super method (WebSocket.Listener.super.onText()) at the end of their own overrides -- what does the default implementation do?;How would you implement automatic reconnection logic if the WebSocket connection drops unexpectedly?

// Server
ServerSocket serverSocket = new ServerSocket(8080);
Socket clientSocket = serverSocket.accept();  // blocks until a client connects
BufferedReader in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
String message = in.readLine();

// Client
Socket socket = new Socket("localhost", 8080);
PrintWriter out = new PrintWriter(socket.getOutputStream(), true);
out.println("Hello, server!");

Common follow-ups: Why would you choose raw sockets over HttpClient or gRPC for a custom protocol, given both provide more built-in structure?;How does this classic blocking Socket API relate to NIO's non-blocking SocketChannel discussed earlier?

// Correct approach: trust a SPECIFIC known certificate via a properly configured TrustManager
KeyStore trustStore = KeyStore.getInstance("PKCS12");
trustStore.load(new FileInputStream("custom-truststore.p12"), "password".toCharArray());
TrustManagerFactory tmf = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
tmf.init(trustStore);
SSLContext sslContext = SSLContext.getInstance("TLS");
sslContext.init(null, tmf.getTrustManagers(), null);

HttpClient client = HttpClient.newBuilder().sslContext(sslContext).build();

Common follow-ups: What's the specific difference in risk between trusting one known self-signed certificate versus disabling certificate validation entirely?;How would you generate and configure a proper internal certificate authority for a company's internal services rather than relying on self-signed certificates per-service?

Map<String, String> formData = Map.of("grant_type", "client_credentials", "client_id", "abc123");
String encodedBody = formData.entrySet().stream()
    .map(e -> URLEncoder.encode(e.getKey(), StandardCharsets.UTF_8) + "=" + URLEncoder.encode(e.getValue(), StandardCharsets.UTF_8))
    .collect(Collectors.joining("&"));

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("https://auth.example.com/oauth/token"))
    .header("Content-Type", "application/x-www-form-urlencoded")
    .POST(HttpRequest.BodyPublishers.ofString(encodedBody))
    .build();

Common follow-ups: Why do OAuth2 and many older web APIs specifically use form encoding rather than JSON for these particular requests?;What specific characters does URLEncoder.encode() escape, and why is manual string concatenation without encoding dangerous?