HttpClient와 네트워킹 — 자바에서 HTTP 요청 보내기

// 클라이언트 소켓 — 서버에 연결
try (Socket socket = new Socket("example.com", 80)) {
    OutputStream out = socket.getOutputStream();
    InputStream in = socket.getInputStream();

    // HTTP 요청을 직접 작성 (실무에서는 이렇게 안 한다)
    String request = "GET / HTTP/1.1\r\nHost: example.com\r\n\r\n";
    out.write(request.getBytes());
    out.flush();

    // 응답 읽기
    byte[] buffer = new byte[4096];
    int bytesRead = in.read(buffer);
    System.out.println(new String(buffer, 0, bytesRead));
}

// 서버 소켓 — 8080 포트에서 연결 대기
try (ServerSocket serverSocket = new ServerSocket(8080)) {
    System.out.println("서버 시작, 연결 대기 중...");

    while (true) {
        // 클라이언트 연결을 수락 (블로킹)
        Socket clientSocket = serverSocket.accept();

        // 연결된 클라이언트 처리
        try (BufferedReader reader = new BufferedReader(
                new InputStreamReader(clientSocket.getInputStream()))) {
            String line;
            while ((line = reader.readLine()) != null && !line.isEmpty()) {
                System.out.println(line); // 요청 헤더 출력
            }
        }
    }
}

// URLConnection으로 GET 요청
URL url = new URL("https://api.example.com/users");
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
conn.setRequestMethod("GET");
conn.setRequestProperty("Accept", "application/json");
conn.setConnectTimeout(5000); // 연결 타임아웃 5초
conn.setReadTimeout(5000);    // 읽기 타임아웃 5초

int statusCode = conn.getResponseCode();
if (statusCode == 200) {
    try (BufferedReader reader = new BufferedReader(
            new InputStreamReader(conn.getInputStream()))) {
        String line;
        StringBuilder response = new StringBuilder();
        while ((line = reader.readLine()) != null) {
            response.append(line);
        }
        System.out.println(response);
    }
}
conn.disconnect();

// HttpClient 생성
HttpClient client = HttpClient.newBuilder()
        .version(HttpClient.Version.HTTP_2)       // HTTP/2 우선
        .connectTimeout(Duration.ofSeconds(10))    // 연결 타임아웃
        .followRedirects(HttpClient.Redirect.NORMAL) // 리다이렉트 자동 추적
        .build();

// GET 요청 생성
HttpRequest request = HttpRequest.newBuilder()
        .uri(URI.create("https://api.example.com/users/1"))
        .header("Accept", "application/json")
        .timeout(Duration.ofSeconds(30))           // 요청 타임아웃
        .GET()                                     // 기본값이 GET이라 생략 가능
        .build();

// 동기 전송 — 응답이 올 때까지 블로킹
HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());

System.out.println("상태 코드: " + response.statusCode());
System.out.println("응답 바디: " + response.body());
System.out.println("헤더: " + response.headers().map());

// 비동기 전송 — CompletableFuture를 반환
CompletableFuture<HttpResponse<String>> future = client.sendAsync(
        request,
        HttpResponse.BodyHandlers.ofString()
);

// 논블로킹으로 후속 처리 체이닝
future.thenApply(HttpResponse::body)
      .thenAccept(body -> System.out.println("응답: " + body))
      .exceptionally(ex -> {
          System.err.println("요청 실패: " + ex.getMessage());
          return null;
      });

// 다른 작업을 하다가 필요할 때 결과 대기
// future.join();

// JSON 바디를 담은 POST 요청
String jsonBody = """
        {
            "name": "홍길동",
            "email": "hong@example.com"
        }
        """;

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

HttpResponse<String> postResponse = client.send(
        postRequest,
        HttpResponse.BodyHandlers.ofString()
);

System.out.println("생성 결과: " + postResponse.statusCode()); // 201

// 파일 다운로드 예시
HttpResponse<Path> fileResponse = client.send(
        HttpRequest.newBuilder()
                .uri(URI.create("https://example.com/report.pdf"))
                .build(),
        HttpResponse.BodyHandlers.ofFile(Path.of("report.pdf"))
);
System.out.println("다운로드 완료: " + fileResponse.body());

HttpClient client = HttpClient.newBuilder()
        .connectTimeout(Duration.ofSeconds(5))  // 1) 연결 타임아웃: TCP 핸드셰이크 제한
        .build();

HttpRequest request = HttpRequest.newBuilder()
        .uri(URI.create("https://api.example.com/slow-endpoint"))
        .timeout(Duration.ofSeconds(30))        // 2) 요청 타임아웃: 응답 대기 제한
        .build();

HttpClient client = HttpClient.newBuilder()
        .followRedirects(HttpClient.Redirect.NORMAL) // 리다이렉트 자동 추적
        .build();

스레드 → 요청 전송 → [대기...대기...대기...] → 응답 수신 → 다음 작업

스레드 → 요청 전송 → (바로 반환) → 다른 작업 수행 → 응답 도착 시 콜백 실행

// 여러 요청을 동시에 보내는 예시
List<URI> urls = List.of(
        URI.create("https://api.example.com/users/1"),
        URI.create("https://api.example.com/users/2"),
        URI.create("https://api.example.com/users/3")
);

// 모든 요청을 비동기로 동시 전송
List<CompletableFuture<String>> futures = urls.stream()
        .map(uri -> HttpRequest.newBuilder().uri(uri).build())
        .map(req -> client.sendAsync(req, HttpResponse.BodyHandlers.ofString())
                .thenApply(HttpResponse::body))
        .toList();

// 모든 응답이 도착할 때까지 대기
CompletableFuture.allOf(futures.toArray(new CompletableFuture[0])).join();

// 결과 출력
futures.forEach(f -> System.out.println(f.join()));

// Spring RestTemplate (레거시 — 참고용)
RestTemplate restTemplate = new RestTemplate();
String result = restTemplate.getForObject(
        "https://api.example.com/users/1", String.class);

// Spring WebClient (리액티브)
WebClient webClient = WebClient.create("https://api.example.com");
Mono<String> mono = webClient.get()
        .uri("/users/1")
        .retrieve()
        .bodyToMono(String.class);

public class HttpClients {

    // HttpClient는 스레드 안전하므로 싱글톤으로 재사용
    private static final HttpClient INSTANCE = HttpClient.newBuilder()
            .version(HttpClient.Version.HTTP_2)
            .connectTimeout(Duration.ofSeconds(10))
            .followRedirects(HttpClient.Redirect.NORMAL)
            .build();

    public static HttpClient getInstance() {
        return INSTANCE;
    }

    private HttpClients() {
        // 인스턴스 생성 방지
    }
}

HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());

// 상태 코드별 분기 처리
switch (response.statusCode() / 100) {
    case 2 -> System.out.println("성공: " + response.body());
    case 3 -> System.out.println("리다이렉트: " + response.headers().firstValue("Location"));
    case 4 -> System.out.println("클라이언트 오류: " + response.statusCode());
    case 5 -> System.out.println("서버 오류: " + response.statusCode());
    default -> System.out.println("알 수 없는 상태: " + response.statusCode());
}

try {
    HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
} catch (HttpTimeoutException e) {
    // 타임아웃 발생
    System.err.println("요청 시간 초과: " + e.getMessage());
} catch (HttpConnectTimeoutException e) {
    // 연결 타임아웃
    System.err.println("연결 시간 초과: " + e.getMessage());
} catch (IOException e) {
    // 네트워크 오류
    System.err.println("네트워크 오류: " + e.getMessage());
} catch (InterruptedException e) {
    // 스레드 인터럽트
    Thread.currentThread().interrupt();
    System.err.println("요청이 중단됨");
}