Production API Consumption & Integration Patterns in Java

import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.URL;
import java.nio.charset.StandardCharsets;

public class HttpURLConnectionProductionDemo {

    public static String executePost(String urlStr, String jsonBody, String bearerToken) throws Exception {
        URL url = new URL(urlStr);
        HttpURLConnection conn = (HttpURLConnection) url.openConnection();

        // 1. Mandatory Socket Timeout Configuration
        conn.setConnectTimeout(4000); // 4 seconds connect timeout
        conn.setReadTimeout(6000);    // 6 seconds socket read timeout

        // 2. Request Configuration
        conn.setRequestMethod("POST");
        conn.setRequestProperty("Content-Type", "application/json; charset=utf-8");
        conn.setRequestProperty("Accept", "application/json");
        conn.setRequestProperty("Authorization", "Bearer " + bearerToken);
        conn.setDoOutput(true); // Enables sending request body

        // 3. Write Request Body Stream
        try (OutputStream os = conn.getOutputStream()) {
            byte[] input = jsonBody.getBytes(StandardCharsets.UTF_8);
            os.write(input, 0, input.length);
        }

        // 4. Inspect Response Status Code
        int statusCode = conn.getResponseCode();

        // 5. Handle InputStream vs ErrorStream
        InputStream responseStream;
        if (statusCode >= 200 && statusCode < 300) {
            responseStream = conn.getInputStream();
        } else {
            // Read error details from getErrorStream()!
            responseStream = conn.getErrorStream();
        }

        // 6. Read Stream Content
        StringBuilder response = new StringBuilder();
        try (BufferedReader br = new BufferedReader(new InputStreamReader(responseStream, StandardCharsets.UTF_8))) {
            String responseLine;
            while ((responseLine = br.readLine()) != null) {
                response.append(responseLine.trim());
            }
        }

        conn.disconnect();

        if (statusCode < 200 || statusCode >= 300) {
            throw new RuntimeException("API Error HTTP " + statusCode + ": " + response.toString());
        }

        return response.toString();
    }
}

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.time.Duration;
import java.util.concurrent.CompletableFuture;

public class Java11HttpClientDemo {

    // Reuse a single HttpClient instance across the application (Thread-Safe with Connection Pool)
    private static final HttpClient HTTP_CLIENT = HttpClient.newBuilder()
            .version(HttpClient.Version.HTTP_2)
            .connectTimeout(Duration.ofSeconds(5))
            .build();

    public static CompletableFuture<String> fetchUserAsync(String userId) {
        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create("https://api.example.com/v1/users/" + userId))
                .timeout(Duration.ofSeconds(5))
                .header("Accept", "application/json")
                .header("Authorization", "Bearer token_abc123")
                .GET()
                .build();

        // Non-blocking Asynchronous Request Execution!
        return HTTP_CLIENT.sendAsync(request, HttpResponse.BodyHandlers.ofString())
                .thenApply(response -> {
                    if (response.statusCode() == 200) {
                        return response.body();
                    } else {
                        throw new RuntimeException("HTTP Error " + response.statusCode() + ": " + response.body());
                    }
                });
    }

    public static void main(String[] args) throws Exception {
        System.out.println("Dispatching Async Request...");
        CompletableFuture<String> future = fetchUserAsync("1088");

        future.thenAccept(json -> System.out.println("Async Response Received: " + json))
              .join();
    }
}

import java.util.Random;
import java.util.concurrent.Callable;

public class ResilienceUtils {

    private static final Random RANDOM = new Random();

    public static <T> T executeWithBackoff(Callable<T> task, int maxRetries, long baseDelayMs) throws Exception {
        int attempt = 0;

        while (true) {
            try {
                return task.call();
            } catch (Exception e) {
                attempt++;
                if (attempt > maxRetries) {
                    System.err.println("Exhausted all " + maxRetries + " retry attempts. Operation failed.");
                    throw e;
                }

                // 1. Calculate Exponential Backoff: base * 2^(attempt - 1)
                long exponentialDelay = baseDelayMs * (1L << (attempt - 1));

                // 2. Apply Full Jitter: random(0, exponentialDelay) to prevent Thundering Herd!
                long jitteredDelay = (long) (RANDOM.nextDouble() * exponentialDelay);

                System.out.println(String.format("Attempt %d failed (%s). Retrying in %d ms...", 
                        attempt, e.getMessage(), jitteredDelay));

                Thread.sleep(jitteredDelay);
            }
        }
    }
}