Servlet 라우터와 오류 경계

public final class PathConditionalHttpService {
    static String handle(String path, String query) {
        if (path.equals("/")) {
            return "<h1>home</h1>";
        } else if (path.equals("/site1")) {
            return "<h1>site1</h1>";
        } else if (path.equals("/search")) {
            return "<h1>" + query + "</h1>";
        } else {
            return "<h1>not found</h1>";
        }
    }

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

import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Objects;

public final class ServletRouter {
    record Route(String method, String path) {
        Route {
            method = method.toUpperCase(java.util.Locale.ROOT);
            if (!path.startsWith("/")) {
                throw new IllegalArgumentException("path must start with slash");
            }
        }
    }

    record Request(String method, String path, Map<String, String> query) {
        Request {
            query = Map.copyOf(query);
        }
    }

    static final class Response {
        private int status = 200;
        private String contentType = "text/plain; charset=UTF-8";
        private final StringBuilder body = new StringBuilder();

        void status(int value) {
            status = value;
        }

        void contentType(String value) {
            contentType = Objects.requireNonNull(value);
        }

        void write(String value) {
            body.append(value);
        }

        String summary() {
            return status + " " + contentType + " " + body;
        }
    }

    @FunctionalInterface
    interface Servlet {
        void service(Request request, Response response) throws Exception;
    }

    private final Map<Route, Servlet> routes;
    private final Servlet notFound;

    ServletRouter(Map<Route, Servlet> routes) {
        this.routes = Map.copyOf(routes);
        this.notFound = (request, response) -> {
            response.status(404);
            response.write("route not found: " + request.path());
        };
    }

    void execute(Request request, Response response) throws Exception {
        Route route = new Route(request.method(), request.path());
        routes.getOrDefault(route, notFound).service(request, response);
    }

    static ServletRouter standard() {
        Map<Route, Servlet> routes = new LinkedHashMap<>();
        routes.put(new Route("GET", "/"), (request, response) -> {
            response.contentType("text/html; charset=UTF-8");
            response.write("<h1>home</h1>");
        });
        routes.put(new Route("GET", "/search"), (request, response) -> {
            String value = request.query().getOrDefault("q", "");
            response.write("query=" + value);
        });
        routes.put(new Route("POST", "/notes"), (request, response) -> {
            response.status(201);
            response.write("created");
        });
        return new ServletRouter(routes);
    }

    public static void main(String[] args) throws Exception {
        var router = standard();
        for (Request request : java.util.List.of(
                new Request("GET", "/", Map.of()),
                new Request("GET", "/search", Map.of("q", "java")),
                new Request("DELETE", "/missing", Map.of()))) {
            var response = new Response();
            router.execute(request, response);
            System.out.println(response.summary());
        }
    }
}

import java.util.HashMap;
import java.util.Map;
import java.util.UUID;

public final class HttpErrorBoundary {
    record Request(String path) {
    }

    static final class Response {
        int status = 200;
        final Map<String, String> headers = new HashMap<>();
        String body = "";

        boolean successful() {
            return status >= 200 && status < 400;
        }
    }

    static final class PageNotFoundException extends RuntimeException {
        PageNotFoundException(String path) {
            super(path);
        }
    }

    @FunctionalInterface
    interface Application {
        void handle(Request request, Response response) throws Exception;
    }

    record Execution(Response response, String errorId,
                     String loggedType) {
    }

    static Execution execute(Application application, Request request) {
        var response = new Response();
        try {
            application.handle(request, response);
            return new Execution(response, null, null);
        } catch (PageNotFoundException error) {
            response.status = 404;
            response.body = "page not found";
            return new Execution(response, null, error.getClass().getSimpleName());
        } catch (Exception error) {
            String errorId = UUID.randomUUID().toString();
            response.status = 500;
            response.body = "internal error id=" + errorId;
            response.headers.put("Cache-Control", "no-store");
            return new Execution(
                    response,
                    errorId,
                    error.getClass().getSimpleName());
        }
    }

    public static void main(String[] args) {
        Application application = (request, response) -> {
            switch (request.path()) {
                case "/ok" -> response.body = "ok";
                case "/missing" -> throw new PageNotFoundException(request.path());
                default -> throw new IllegalStateException("database unavailable");
            }
        };

        for (String path : java.util.List.of("/ok", "/missing", "/boom")) {
            Execution execution = execute(application, new Request(path));
            System.out.println(path
                    + " status=" + execution.response().status
                    + " success=" + execution.response().successful()
                    + " logged=" + execution.loggedType());
        }
    }
}