HTTP를 언어별로 비교하기

import java.net.HttpURLConnection
import java.net.URL

fun httpGet(urlStr: String): Result<String> = runCatching {
    val url = URL(urlStr)
    val conn = url.openConnection() as HttpURLConnection
    conn.apply {
        requestMethod = "GET"
        connectTimeout = 5000
        readTimeout = 5000
        setRequestProperty("Accept", "application/json")
    }

    try {
        if (conn.responseCode == 200) {
            conn.inputStream.bufferedReader().use { it.readText() }
        } else {
            throw RuntimeException("HTTP ${conn.responseCode}: ${conn.responseMessage}")
        }
    } finally {
        conn.disconnect()
    }
}

fun httpPost(urlStr: String, body: String): Result<String> = runCatching {
    val conn = URL(urlStr).openConnection() as HttpURLConnection
    conn.apply {
        requestMethod = "POST"
        doOutput = true
        setRequestProperty("Content-Type", "application/json")
    }
    conn.outputStream.use { it.write(body.toByteArray()) }
    conn.inputStream.bufferedReader().use { it.readText() }
}

fun main() {
    httpGet("https://httpbin.org/get").fold(
        onSuccess = { println("응답: ${it.take(200)}...") },
        onFailure = { println("오류: ${it.message}") }
    )
}

# requests 라이브러리 패턴 시뮬레이션
from urllib.request import urlopen, Request
from urllib.error import URLError
import json

# 기본 GET 요청
def http_get(url: str, headers: dict = None) -> dict:
    req = Request(url, headers=headers or {})
    try:
        with urlopen(req, timeout=10) as resp:
            return {
                "status": resp.status,
                "body": resp.read().decode("utf-8"),
                "headers": dict(resp.headers),
            }
    except URLError as e:
        return {"error": str(e)}

# requests 스타일 API 시뮬레이션
class Response:
    def __init__(self, status=200, data=None):
        self.status_code = status
        self._data = data or {}

    def json(self):
        return self._data

    def raise_for_status(self):
        if self.status_code >= 400:
            raise Exception(f"HTTP {self.status_code}")

# 실사용 패턴 (requests 설치 필요)
# import requests
# resp = requests.get("https://api.example.com/users",
#     params={"page": 1},
#     headers={"Authorization": "Bearer TOKEN"},
#     timeout=10,
# )
# resp.raise_for_status()
# users = resp.json()

# httpx (비동기 지원)
# import httpx
# async with httpx.AsyncClient() as client:
#     resp = await client.get("https://api.example.com")

resp = Response(200, {"users": [{"name": "Alice"}]})
print(f"상태: {resp.status_code}")
print(f"데이터: {resp.json()}")

package main

import (
	"context"
	"fmt"
	"io"
	"net/http"
	"time"
)

func main() {
	// 커스텀 클라이언트 (타임아웃 필수!)
	client := &http.Client{
		Timeout: 10 * time.Second,
	}

	// GET 요청
	resp, err := client.Get("https://httpbin.org/get")
	if err != nil {
		fmt.Println("에러:", err)
		return
	}
	defer resp.Body.Close()

	body, _ := io.ReadAll(resp.Body)
	fmt.Printf("상태: %d, 크기: %d bytes\n", resp.StatusCode, len(body))

	// context로 취소 가능한 요청
	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()

	req, _ := http.NewRequestWithContext(ctx, "GET", "https://httpbin.org/get", nil)
	req.Header.Set("Accept", "application/json")

	resp2, err := client.Do(req)
	if err != nil {
		fmt.Println("에러:", err)
		return
	}
	defer resp2.Body.Close()
	fmt.Println("상태:", resp2.StatusCode)
}

import java.net.http.*;
import java.net.URI;
import java.time.Duration;

public class HttpClientDemo {
    public static void main(String[] args) throws Exception {
        // HttpClient 생성 (재사용 권장)
        HttpClient client = HttpClient.newBuilder()
            .version(HttpClient.Version.HTTP_2)
            .connectTimeout(Duration.ofSeconds(10))
            .followRedirects(HttpClient.Redirect.NORMAL)
            .build();

        // GET 요청
        HttpRequest getReq = HttpRequest.newBuilder()
            .uri(URI.create("https://httpbin.org/get"))
            .header("Accept", "application/json")
            .timeout(Duration.ofSeconds(30))
            .GET()
            .build();

        HttpResponse<String> response = client.send(
            getReq, HttpResponse.BodyHandlers.ofString());
        System.out.println("상태: " + response.statusCode());
        System.out.println("본문: " + response.body().substring(0, 100));

        // POST 요청
        String json = "{\"name\":\"test\",\"value\":42}";
        HttpRequest postReq = HttpRequest.newBuilder()
            .uri(URI.create("https://httpbin.org/post"))
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(json))
            .build();

        // 비동기 요청
        client.sendAsync(postReq, HttpResponse.BodyHandlers.ofString())
            .thenApply(HttpResponse::body)
            .thenAccept(body -> System.out.println("비동기: " + body.length()))
            .join();
    }
}

<?php
$context = stream_context_create([
    'http' => [
        'method' => 'GET',
        'timeout' => 2,
        'header' => "Accept: application/json
",
    ],
]);

$body = @file_get_contents('https://example.com', false, $context);
echo $body === false ? 'failed' : 'ok';

// 요청 작업 감싸기
Promise.all([Promise.resolve("a"), Promise.resolve("b")]).then(console.log);

// 요청 작업 감싸기
Promise.all([Promise.resolve("a"), Promise.resolve("b")]).then(console.log);

// 요청 작업 감싸기
using System;
using System.Threading.Tasks;

var results = await Task.WhenAll(Task.FromResult("a"), Task.FromResult("b"));
Console.WriteLine(string.Join(",", results));

// 요청 작업 감싸기
#include <chrono>
#include <iostream>
#include <thread>

int main() {
    std::thread worker([] { std::this_thread::sleep_for(std::chrono::milliseconds(1)); });
    worker.join();
    std::cout << "done\n";
}

// 요청 작업 감싸기
use std::{thread, time::Duration};
fn main() {
    thread::sleep(Duration::from_millis(1));
    println!("done");
}