애노테이션으로 요청 경로 연결하기

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import java.lang.reflect.Method;
import java.util.List;

public final class RequestTimeAnnotationScanner {
    @Retention(RetentionPolicy.RUNTIME)
    @Target(ElementType.METHOD)
    @interface Mapping {
        String path();
    }

    static final class SiteController {
        @Mapping(path = "/hello")
        public String hello() {
            return "hello";
        }

        @Mapping(path = "/greet")
        public String greet(String name) {
            return "hello, " + name;
        }
    }

    static Object dispatch(String path, List<Object> controllers) throws Exception {
        for (Object controller : controllers) {
            for (Method method : controller.getClass().getDeclaredMethods()) {
                Mapping mapping = method.getAnnotation(Mapping.class);
                if (mapping != null && mapping.path().equals(path)) {
                    return method.invoke(controller);
                }
            }
        }
        throw new IllegalArgumentException("not found: " + path);
    }

    public static void main(String[] args) throws Exception {
        List<Object> controllers = List.of(new SiteController());
        System.out.println(dispatch("/hello", controllers));
        try {
            dispatch("/greet", controllers);
        } catch (IllegalArgumentException exception) {
            System.out.println("/greet failed: " + exception.getMessage());
        }
    }
}

hello
/greet failed: wrong number of arguments: 0 expected: 1

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;

public final class MappingRouteCompiler {
    @Retention(RetentionPolicy.RUNTIME)
    @Target(ElementType.METHOD)
    @interface Mapping {
        String method();

        String path();
    }

    record Request(String method, String path) {
    }

    static final class Response {
        private int status = 200;
        private final StringBuilder body = new StringBuilder();

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

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

        @Override
        public String toString() {
            return status + " " + body;
        }
    }

    record RouteKey(String method, String path) {
        static RouteKey of(String method, String path) {
            String normalizedMethod = method.trim().toUpperCase(Locale.ROOT);
            String normalizedPath = path.equals("/")
                    ? "/"
                    : path.replaceAll("/+$", "");
            if (!normalizedPath.startsWith("/")) {
                throw new IllegalArgumentException("path must start with slash: " + path);
            }
            return new RouteKey(normalizedMethod, normalizedPath);
        }

        @Override
        public String toString() {
            return method + " " + path;
        }
    }

    record HandlerPlan(Object target, Method method) {
        void invoke(Request request, Response response) {
            try {
                method.invoke(target, request, response);
            } catch (IllegalAccessException exception) {
                throw new IllegalStateException("cannot access " + describe(method), exception);
            } catch (InvocationTargetException exception) {
                Throwable cause = exception.getCause();
                if (cause instanceof RuntimeException runtime) {
                    throw runtime;
                }
                if (cause instanceof Error error) {
                    throw error;
                }
                throw new IllegalStateException("controller failure", cause);
            }
        }
    }

    static Map<RouteKey, HandlerPlan> compile(List<Object> controllers) {
        Map<RouteKey, HandlerPlan> plans = new LinkedHashMap<>();
        for (Object controller : controllers) {
            for (Method method : controller.getClass().getDeclaredMethods()) {
                Mapping mapping = method.getAnnotation(Mapping.class);
                if (mapping == null) {
                    continue;
                }
                validateSignature(method);
                RouteKey key = RouteKey.of(mapping.method(), mapping.path());
                HandlerPlan previous = plans.putIfAbsent(key, new HandlerPlan(controller, method));
                if (previous != null) {
                    throw new IllegalArgumentException("duplicate route " + key + ": "
                            + describe(previous.method()) + " and " + describe(method));
                }
            }
        }
        return Map.copyOf(plans);
    }

    private static void validateSignature(Method method) {
        if (!Modifier.isPublic(method.getModifiers())) {
            throw new IllegalArgumentException("route method must be public: " + describe(method));
        }
        if (method.getReturnType() != void.class) {
            throw new IllegalArgumentException("route method must return void: " + describe(method));
        }
        if (!List.of(method.getParameterTypes()).equals(List.of(Request.class, Response.class))) {
            throw new IllegalArgumentException(
                    "route parameters must be (Request, Response): " + describe(method));
        }
    }

    private static String describe(Method method) {
        return method.getDeclaringClass().getSimpleName() + "." + method.getName();
    }

    static final class SiteController {
        @Mapping(method = "GET", path = "/")
        public void home(Request request, Response response) {
            response.write("home from " + request.path());
        }

        @Mapping(method = "GET", path = "/site-one/")
        public void siteOne(Request request, Response response) {
            response.write("site one");
        }
    }

    static final class LegacyController {
        @Mapping(method = "get", path = "/site-one")
        public void oldSiteOne(Request request, Response response) {
            response.write("old site one");
        }
    }

    public static void main(String[] args) {
        Map<RouteKey, HandlerPlan> routes = compile(List.of(new SiteController()));
        List<String> keys = routes.keySet().stream().map(RouteKey::toString).sorted().toList();
        System.out.println("routes: " + keys);

        Response response = new Response();
        routes.get(RouteKey.of("get", "/site-one"))
                .invoke(new Request("GET", "/site-one"), response);
        System.out.println(response);

        try {
            compile(List.of(new SiteController(), new LegacyController()));
        } catch (IllegalArgumentException exception) {
            System.out.println("startup failed: " + exception.getMessage());
        }
    }
}

routes: [GET /, GET /site-one]
200 site one
startup failed: duplicate route GET /site-one: SiteController.siteOne and LegacyController.oldSiteOne

import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.Locale;
import java.util.Map;
import java.util.Set;
import java.util.TreeSet;

public final class RouteLookup {
    record RouteKey(String method, String path) {
        RouteKey {
            method = method.toUpperCase(Locale.ROOT);
        }
    }

    sealed interface Lookup permits Found, MethodNotAllowed, NotFound {
    }

    record Found(String handler) implements Lookup {
    }

    record MethodNotAllowed(Set<String> allowed) implements Lookup {
        MethodNotAllowed {
            allowed = Set.copyOf(allowed);
        }
    }

    record NotFound(String path) implements Lookup {
    }

    static final class RouteTable {
        private final Map<RouteKey, String> routes;

        RouteTable(Map<RouteKey, String> routes) {
            this.routes = Map.copyOf(routes);
        }

        Lookup lookup(String method, String path) {
            String handler = routes.get(new RouteKey(method, path));
            if (handler != null) {
                return new Found(handler);
            }
            Set<String> allowed = new HashSet<>();
            for (RouteKey key : routes.keySet()) {
                if (key.path().equals(path)) {
                    allowed.add(key.method());
                }
            }
            return allowed.isEmpty()
                    ? new NotFound(path)
                    : new MethodNotAllowed(allowed);
        }
    }

    static String respond(Lookup lookup) {
        return switch (lookup) {
            case Found found -> "200 call " + found.handler();
            case MethodNotAllowed notAllowed ->
                    "405 Allow: " + String.join(", ", new TreeSet<>(notAllowed.allowed()));
            case NotFound notFound -> "404 no route for " + notFound.path();
        };
    }

    public static void main(String[] args) {
        Map<RouteKey, String> routes = new LinkedHashMap<>();
        routes.put(new RouteKey("GET", "/members"), "listMembers");
        routes.put(new RouteKey("POST", "/members"), "createMember");
        RouteTable table = new RouteTable(routes);

        System.out.println(respond(table.lookup("get", "/members")));
        System.out.println(respond(table.lookup("DELETE", "/members")));
        System.out.println(respond(table.lookup("GET", "/missing")));
    }
}

200 call listMembers
405 Allow: GET, POST
404 no route for /missing

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public final class InvocationUnwrapDemo {
    static final class MemberController {
        public void find(String id) {
            throw new IllegalArgumentException("unknown member: " + id);
        }
    }

    public static void main(String[] args) throws Exception {
        Method method = MemberController.class.getMethod("find", String.class);
        try {
            method.invoke(new MemberController(), "42");
        } catch (InvocationTargetException exception) {
            System.out.println("caught: " + exception);
            System.out.println("message: " + exception.getMessage());
            System.out.println("cause: " + exception.getCause());
        }
    }
}

caught: java.lang.reflect.InvocationTargetException
message: null
cause: java.lang.IllegalArgumentException: unknown member: 42