런타임 애노테이션 만들고 리플렉션으로 읽기

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

public final class StringRouteConfiguration {
    record Target(String className, String methodName) {
    }

    static Map<String, Target> routes() {
        Map<String, Target> routes = new HashMap<>();
        routes.put("GET /site1", new Target(
                "example.SiteController",
                "siet1"));
        routes.put("GET /site1", new Target(
                "example.OtherController",
                "site1"));
        return routes;
    }

    public static void main(String[] args) {
        Map<String, Target> routes = routes();
        System.out.println("route count = " + routes.size());
        System.out.println(routes);
    }
}

route count = 1
{GET /site1=Target[className=example.OtherController, methodName=site1]}

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
@interface Route {
    String method();

    String path();
}

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.reflect.Method;

public final class RetentionProbe {
    @Retention(RetentionPolicy.RUNTIME)
    @interface Visible {
    }

    @interface Invisible {
    }

    static final class Controller {
        @Visible
        @Invisible
        public void handle() {
        }
    }

    public static void main(String[] args) throws Exception {
        Method handle = Controller.class.getMethod("handle");
        System.out.println("Visible   = " + handle.getAnnotation(Visible.class));
        System.out.println("Invisible = " + handle.getAnnotation(Invisible.class));
    }
}

Visible   = @RetentionProbe.Visible()
Invisible = null

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

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

        String path();
    }

    @Route(method = "GET", path = "/name")
    private String name;

    @Route(method = "GET")
    public String search() {
        return "search";
    }

    @Route(method = "GET", path = 404)
    public String missing() {
        return "missing";
    }
}

RouteMisuse.java:23: error: incompatible types: int cannot be converted to String
    @Route(method = "GET", path = 404)
                                  ^
RouteMisuse.java:15: error: annotation interface not applicable to this kind of declaration
    @Route(method = "GET", path = "/name")
    ^
RouteMisuse.java:18: error: annotation @Route is missing a default value for the element 'path'
    @Route(method = "GET")
    ^
3 errors

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.Comparator;
import java.util.LinkedHashMap;
import java.util.Locale;
import java.util.Map;

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

        String path();
    }

    static final class SiteController {
        @Route(method = "GET", path = "/site1")
        public String siteOne() {
            return "site1";
        }

        @Route(method = "GET", path = "/search")
        public String search() {
            return "search";
        }

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

    record RouteKey(String method, String path) {
        RouteKey {
            method = method.toUpperCase(Locale.ROOT);
            if (!method.matches("[A-Z]+")) {
                throw new IllegalArgumentException("invalid HTTP method");
            }
            if (!path.startsWith("/")) {
                throw new IllegalArgumentException("invalid route path");
            }
        }
    }

    record Handler(Object target, Method method) {
        String invoke() {
            try {
                return (String) method.invoke(target);
            } catch (InvocationTargetException wrapper) {
                Throwable cause = wrapper.getCause();
                throw new IllegalStateException(
                        "route failed: " + cause.getClass().getSimpleName(),
                        cause);
            } catch (ReflectiveOperationException error) {
                throw new IllegalStateException("route inaccessible", error);
            }
        }
    }

    static Map<RouteKey, Handler> discover(Object controller) {
        Map<RouteKey, Handler> handlers = new LinkedHashMap<>();
        for (Method method : controller.getClass().getDeclaredMethods()) {
            Route route = method.getAnnotation(Route.class);
            if (route == null) {
                continue;
            }
            validateSignature(method);
            RouteKey key = new RouteKey(route.method(), route.path());
            Handler previous = handlers.putIfAbsent(
                    key,
                    new Handler(controller, method));
            if (previous != null) {
                throw new IllegalStateException("duplicate route: " + key);
            }
        }
        return Map.copyOf(handlers);
    }

    private static void validateSignature(Method method) {
        if (!Modifier.isPublic(method.getModifiers())) {
            throw new IllegalStateException("route method must be public");
        }
        if (method.getParameterCount() != 0
                || method.getReturnType() != String.class) {
            throw new IllegalStateException(
                    "route signature must be () -> String");
        }
    }

    public static void main(String[] args) {
        Map<RouteKey, Handler> routes = discover(new SiteController());
        routes.entrySet().stream()
                .sorted(Map.Entry.comparingByKey(
                        Comparator.comparing(RouteKey::path)))
                .forEach(entry -> System.out.println(
                        entry.getKey() + " -> " + entry.getValue().invoke()));
        System.out.println("routeCount=" + routes.size());
    }
}

RouteKey[method=GET, path=/search] -> search
RouteKey[method=GET, path=/site1] -> site1
routeCount=2

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

public final class AnnotationPolicyProbe {
    enum Level {
        BASIC,
        SENSITIVE
    }

    @Retention(RetentionPolicy.RUNTIME)
    @Target(ElementType.METHOD)
    @interface Audited {
        Level level() default Level.BASIC;

        String event();
    }

    @Retention(RetentionPolicy.RUNTIME)
    @Target(ElementType.METHOD)
    @interface InternalOnly {
    }

    static final class AccountService {
        @Audited(event = "account.view")
        public void view() {
        }

        @Audited(event = "account.delete", level = Level.SENSITIVE)
        @InternalOnly
        public void delete() {
        }

        public void health() {
        }
    }

    record MethodPolicy(String method, String event,
                        Level level, boolean internal) {
    }

    static List<MethodPolicy> policies(Class<?> type) {
        List<MethodPolicy> result = new ArrayList<>();
        for (Method method : type.getDeclaredMethods()) {
            Audited audited = method.getAnnotation(Audited.class);
            if (audited == null) {
                continue;
            }
            result.add(new MethodPolicy(
                    method.getName(),
                    audited.event(),
                    audited.level(),
                    method.isAnnotationPresent(InternalOnly.class)));
        }
        return result.stream()
                .sorted(Comparator.comparing(MethodPolicy::method))
                .toList();
    }

    public static void main(String[] args) {
        policies(AccountService.class).forEach(System.out::println);
    }
}

MethodPolicy[method=delete, event=account.delete, level=SENSITIVE, internal=true]
MethodPolicy[method=view, event=account.view, level=BASIC, internal=false]