HTTP/1.1 메시지 구조

GET /hello HTTP/1.1
Host: localhost:8080

HTTP/1.1 200 OK
Content-Type: text/plain; charset=UTF-8
Content-Length: 5

hello

import java.io.PrintWriter;

public final class CharacterLengthHttpResponse {
    static void write(PrintWriter writer, String body) {
        writer.print("HTTP/1.1 200 OK\r\n");
        writer.print("Content-Type: text/plain; charset=UTF-8\r\n");
        writer.print("Content-Length: " + body.length() + "\r\n");
        writer.print("\r\n");
        writer.print(body);
        writer.flush();
    }

    public static void main(String[] args) {
        System.out.println("compile-only byte length counterexample");
    }
}

import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;

public final class HttpRequestModel {
    record RequestLine(String method, String target, String version) {
        RequestLine {
            if (!method.matches("[A-Z]+")) {
                throw new IllegalArgumentException("invalid method");
            }
            if (!target.startsWith("/")) {
                throw new IllegalArgumentException("origin-form target required");
            }
            if (!version.equals("HTTP/1.1")) {
                throw new IllegalArgumentException("unsupported version");
            }
        }
    }

    record Request(RequestLine line, Map<String, List<String>> headers,
                   byte[] body) {
        Request {
            headers = Map.copyOf(headers);
            body = body.clone();
        }

        String firstHeader(String name) {
            return headers.getOrDefault(
                    name.toLowerCase(Locale.ROOT),
                    List.of()).stream().findFirst().orElse(null);
        }
    }

    static Request parse(List<String> headLines, byte[] body) {
        if (headLines.isEmpty()) {
            throw new IllegalArgumentException("request line missing");
        }
        String[] start = headLines.getFirst().split(" ", -1);
        if (start.length != 3) {
            throw new IllegalArgumentException("invalid request line");
        }
        RequestLine line = new RequestLine(start[0], start[1], start[2]);

        Map<String, List<String>> headers = new LinkedHashMap<>();
        for (String raw : headLines.subList(1, headLines.size())) {
            int colon = raw.indexOf(':');
            if (colon <= 0) {
                throw new IllegalArgumentException("invalid header: " + raw);
            }
            String name = raw.substring(0, colon)
                    .trim().toLowerCase(Locale.ROOT);
            String value = raw.substring(colon + 1).trim();
            headers.computeIfAbsent(name, ignored -> new ArrayList<>())
                    .add(value);
        }
        return new Request(line, headers, body);
    }

    public static void main(String[] args) {
        Request request = parse(
                List.of(
                        "POST /notes?q=java HTTP/1.1",
                        "Host: localhost:8080",
                        "Content-Type: text/plain; charset=UTF-8",
                        "X-Trace: stage:parse"),
                "한글".getBytes(StandardCharsets.UTF_8));

        System.out.println(request.line());
        System.out.println(request.firstHeader("CONTENT-TYPE"));
        System.out.println("bodyBytes=" + request.body().length);
    }
}

import java.util.EnumMap;
import java.util.Map;

public final class HttpMethodSemantics {
    enum Method {
        GET,
        HEAD,
        POST,
        PUT,
        DELETE,
        PATCH,
        OPTIONS
    }

    record Facts(boolean safe, boolean idempotent,
                 boolean requestBodyCommon) {
    }

    private static final Map<Method, Facts> FACTS = facts();

    static Facts describe(Method method) {
        return FACTS.get(method);
    }

    static boolean automaticRetryCandidate(Method method) {
        return describe(method).idempotent();
    }

    private static Map<Method, Facts> facts() {
        Map<Method, Facts> values = new EnumMap<>(Method.class);
        values.put(Method.GET, new Facts(true, true, false));
        values.put(Method.HEAD, new Facts(true, true, false));
        values.put(Method.POST, new Facts(false, false, true));
        values.put(Method.PUT, new Facts(false, true, true));
        values.put(Method.DELETE, new Facts(false, true, false));
        values.put(Method.PATCH, new Facts(false, false, true));
        values.put(Method.OPTIONS, new Facts(true, true, false));
        return Map.copyOf(values);
    }

    public static void main(String[] args) {
        for (Method method : Method.values()) {
            Facts facts = describe(method);
            System.out.printf(
                    "%s safe=%s idempotent=%s retryCandidate=%s%n",
                    method,
                    facts.safe(),
                    facts.idempotent(),
                    automaticRetryCandidate(method));
        }
    }
}