인수 해석기로 컨트롤러 매개변수 채우기

import java.lang.reflect.Method;

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

    static final class Response {
    }

    static Object invoke(Object controller, Method method, Request request, Response response)
            throws Exception {
        if (method.getParameterCount() == 0) {
            return method.invoke(controller);
        }
        if (method.getParameterCount() == 1) {
            return method.invoke(controller, request);
        }
        return method.invoke(controller, request, response);
    }

    static final class MemberController {
        public String list(Request request, Response response) {
            return "list " + request.path();
        }

        public String show(Response response, Request request) {
            return "show " + request.path();
        }
    }

    public static void main(String[] args) throws Exception {
        MemberController controller = new MemberController();
        Request request = new Request("/members");
        Response response = new Response();

        Method list = MemberController.class.getMethod("list", Request.class, Response.class);
        System.out.println(invoke(controller, list, request, response));

        Method show = MemberController.class.getMethod("show", Response.class, Request.class);
        try {
            invoke(controller, show, request, response);
        } catch (IllegalArgumentException exception) {
            System.out.println("show failed: " + exception.getMessage());
        }
    }
}

list /members
show failed: argument type mismatch

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.Parameter;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

public final class ArgumentResolverDispatcher {
    @Retention(RetentionPolicy.RUNTIME)
    @Target(ElementType.PARAMETER)
    @interface Query {
        String value();

        boolean required() default true;
    }

    record Request(String path, Map<String, String> query) {
    }

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

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

        String body() {
            return body.toString();
        }
    }

    record RequestContext(Request request, Response response) {
    }

    interface ArgumentResolver {
        boolean supports(Parameter parameter);

        Object resolve(Parameter parameter, RequestContext context);
    }

    static final class RequestResolver implements ArgumentResolver {
        @Override
        public boolean supports(Parameter parameter) {
            return parameter.getType() == Request.class;
        }

        @Override
        public Object resolve(Parameter parameter, RequestContext context) {
            return context.request();
        }
    }

    static final class ResponseResolver implements ArgumentResolver {
        @Override
        public boolean supports(Parameter parameter) {
            return parameter.getType() == Response.class;
        }

        @Override
        public Object resolve(Parameter parameter, RequestContext context) {
            return context.response();
        }
    }

    static final class QueryResolver implements ArgumentResolver {
        @Override
        public boolean supports(Parameter parameter) {
            return parameter.getType() == String.class
                    && parameter.isAnnotationPresent(Query.class);
        }

        @Override
        public Object resolve(Parameter parameter, RequestContext context) {
            Query query = parameter.getAnnotation(Query.class);
            String value = context.request().query().get(query.value());
            if (value == null && query.required()) {
                throw new BindingException("missing query parameter: " + query.value());
            }
            return value;
        }
    }

    static final class BindingException extends RuntimeException {
        BindingException(String message) {
            super(message);
        }
    }

    record ArgumentPlan(Parameter parameter, ArgumentResolver resolver) {
        Object resolve(RequestContext context) {
            return resolver.resolve(parameter, context);
        }
    }

    record HandlerPlan(Object target, Method method, List<ArgumentPlan> arguments) {
        HandlerPlan {
            arguments = List.copyOf(arguments);
        }

        Object invoke(RequestContext context) {
            Object[] values = arguments.stream()
                    .map(argument -> argument.resolve(context))
                    .toArray();
            try {
                return method.invoke(target, values);
            } catch (IllegalAccessException exception) {
                throw new IllegalStateException("handler is inaccessible", exception);
            } catch (InvocationTargetException exception) {
                Throwable cause = exception.getCause();
                if (cause instanceof RuntimeException runtime) {
                    throw runtime;
                }
                throw new IllegalStateException("checked handler failure", cause);
            }
        }
    }

    static HandlerPlan compile(Object target, String methodName) throws NoSuchMethodException {
        Method method = List.of(target.getClass().getDeclaredMethods()).stream()
                .filter(candidate -> candidate.getName().equals(methodName))
                .findFirst()
                .orElseThrow(() -> new NoSuchMethodException(methodName));
        List<ArgumentResolver> resolvers = List.of(
                new RequestResolver(),
                new ResponseResolver(),
                new QueryResolver());
        List<ArgumentPlan> arguments = new ArrayList<>();
        for (Parameter parameter : method.getParameters()) {
            List<ArgumentResolver> matches = resolvers.stream()
                    .filter(resolver -> resolver.supports(parameter))
                    .toList();
            if (matches.size() != 1) {
                throw new IllegalArgumentException(
                        "expected one resolver for " + parameter + ", got " + matches.size());
            }
            arguments.add(new ArgumentPlan(parameter, matches.getFirst()));
        }
        return new HandlerPlan(target, method, arguments);
    }

    static final class SearchController {
        public void search(@Query("q") String keyword, Response response, Request request) {
            response.write(request.path() + " result=" + keyword);
        }
    }

    static final class PageController {
        public void page(int number, Response response) {
            response.write("page=" + number);
        }
    }

    public static void main(String[] args) throws Exception {
        HandlerPlan plan = compile(new SearchController(), "search");
        System.out.println(plan.arguments().stream()
                .map(argument -> argument.resolver().getClass().getSimpleName())
                .toList());

        Response response = new Response();
        plan.invoke(new RequestContext(
                new Request("/search", Map.of("q", "reflection")),
                response));
        System.out.println(response.body());

        try {
            compile(new PageController(), "page");
        } catch (IllegalArgumentException exception) {
            System.out.println("startup failed: " + exception.getMessage());
        }
    }
}

[QueryResolver, ResponseResolver, RequestResolver]
/search result=reflection
startup failed: expected one resolver for int arg0, got 0

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.util.HashMap;
import java.util.Map;

public final class PrecompiledRouteRuntime {
    @Retention(RetentionPolicy.RUNTIME)
    @Target(ElementType.METHOD)
    @interface Get {
        String value();
    }

    static final class Controller {
        @Get("/search")
        public String search(String keyword) {
            return "found:" + keyword;
        }

        public String helper() {
            return "helper";
        }
    }

    static int inspectedMethods = 0;

    static String call(Object target, Method method, String argument) {
        try {
            return (String) method.invoke(target, argument);
        } catch (IllegalAccessException exception) {
            throw new IllegalStateException(exception);
        } catch (InvocationTargetException exception) {
            throw new IllegalStateException(exception.getCause());
        }
    }

    // 방식 1: 요청이 올 때마다 메서드를 끝까지 훑는다
    static String scanAndCall(Object controller, String path, String argument) {
        Method found = null;
        for (Method method : controller.getClass().getDeclaredMethods()) {
            inspectedMethods++;
            Get get = method.getAnnotation(Get.class);
            if (get != null && get.value().equals(path)) {
                if (found != null) {
                    throw new IllegalStateException("duplicate route: " + path);
                }
                found = method;
            }
        }
        if (found == null) {
            throw new IllegalArgumentException("not found: " + path);
        }
        return call(controller, found, argument);
    }

    // 방식 2: 시작할 때 한 번만 훑어 경로별 표를 만든다
    static Map<String, Method> compile(Object controller) {
        Map<String, Method> routes = new HashMap<>();
        for (Method method : controller.getClass().getDeclaredMethods()) {
            inspectedMethods++;
            Get get = method.getAnnotation(Get.class);
            if (get != null) {
                routes.put(get.value(), method);
            }
        }
        return Map.copyOf(routes);
    }

    public static void main(String[] args) {
        Controller controller = new Controller();
        int requests = 1_000;
        String result = null;

        for (int i = 0; i < requests; i++) {
            result = scanAndCall(controller, "/search", "java");
        }
        System.out.println("scan per request: " + result + ", inspected=" + inspectedMethods);

        inspectedMethods = 0;
        Map<String, Method> routes = compile(controller);
        for (int i = 0; i < requests; i++) {
            result = call(controller, routes.get("/search"), "java");
        }
        System.out.println("compile once:     " + result + ", inspected=" + inspectedMethods);
    }
}

scan per request: found:java, inspected=2000
compile once:     found:java, inspected=2