反射、注解与动态代理如何连起来

import java.lang.annotation.*;
import java.lang.reflect.*;
import java.util.HashMap;
import java.util.Map;
public class Main {
    @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.METHOD)
    @interface Route { String value(); }
    static final class Registry {
        private final Object target;
        private final Map<String,Method> routes;
        Registry(Object target) {
            if (target == null) throw new IllegalArgumentException("target");
            this.target = target;
            Map<String,Method> found = new HashMap<>();
            for (Method method : target.getClass().getDeclaredMethods()) {
                Route route = method.getAnnotation(Route.class);
                if (route == null) continue;
                int flags = method.getModifiers();
                // 只注册公开、非静态且精确签名的方法，不开启私有访问。
                if (!Modifier.isPublic(flags) || Modifier.isStatic(flags)
                        || method.getReturnType() != String.class
                        || method.getParameterCount() != 1
                        || method.getParameterTypes()[0] != String.class
                        || !route.value().matches("[a-z]+"))
                    throw new IllegalArgumentException("invalid route");
                if (found.putIfAbsent(route.value(),method) != null)
                    throw new IllegalArgumentException("duplicate route");
            }
            routes = Map.copyOf(found);
        }
        String call(String name, String input) {
            Method method = routes.get(name);
            if (method == null) throw new IllegalArgumentException("unknown route");
            try { return (String) method.invoke(target,input); }
            catch (InvocationTargetException e) {
                throw new IllegalStateException("handler failed",e.getCause());
            } catch (ReflectiveOperationException e) {
                throw new IllegalStateException("reflection configuration",e);
            }
        }
    }
    public static final class Handler {
        @Route("up") public String up(String s) { return s.toUpperCase(java.util.Locale.ROOT); }
        @Route("fail") public String fail(String s) { throw new IllegalArgumentException("business"); }
    }
    public static final class Duplicate {
        @Route("dup") public String a(String s) { return s; }
        @Route("dup") public String b(String s) { return s; }
    }
    public static final class Hidden {
        @Route("hidden") private String secret(String s) { return s; }
    }
    static void reject(Runnable action) {
        try { action.run(); } catch (IllegalArgumentException e) { return; }
        throw new AssertionError("must reject");
    }
    public static void main(String[] args) {
        Registry registry = new Registry(new Handler());
        if (!registry.call("up","ab").equals("AB")) throw new AssertionError();
        // 未知、重复和私有路由分别在应有边界失败。
        reject(() -> registry.call("missing","x"));
        reject(() -> new Registry(new Duplicate()));
        reject(() -> new Registry(new Hidden()));
        reject(() -> new Registry(new Object()).call("up","x"));
        // 目标异常原因必须保留，不能只剩反射包装层。
        boolean preserved = false;
        try { registry.call("fail","x"); }
        catch (IllegalStateException e) { preserved = e.getCause() instanceof IllegalArgumentException; }
        if (!preserved) throw new AssertionError("cause");
        System.out.println("PASS 6");
    }
}