java - 对动态代理的调用应该转到动态类型的方法还是静态类型的方法？

Question

动态代理接收到的方法对象似乎是引用类型而不是对象类型，但只有在方法签名中涉及泛型时才如此。它应该那样工作吗？

例子:

public class ProxyTest implements InvocationHandler {

    public static interface A<T> {

        void test(T t);
    }

    public static interface B extends A<String> {

        @C
        @Override
        void test(String e);
    }

    @Retention(RetentionPolicy.RUNTIME)
    public static @interface C {}

    public static void main(String[] args) {
        Class<A> a = A.class;
        Class<? extends A<String>> bAsA = B.class;
        Class<B> b = B.class;

        A aProxy = ((A) Proxy.newProxyInstance(a.getClassLoader(), new Class[] {a}, new ProxyTest()));
        A bAsAProxy = ((A) Proxy.newProxyInstance(bAsA.getClassLoader(), new Class[] {bAsA}, new ProxyTest()));
        B bProxy = ((B) Proxy.newProxyInstance(b.getClassLoader(), new Class[] {b}, new ProxyTest()));
        A bProxyAssignedToA = bProxy;

        aProxy.test("");
        bAsAProxy.test("");
        bProxy.test("");
        bProxyAssignedToA.test("");
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) {
        System.out.println(method.getDeclaringClass().getSimpleName() + ": " + (method.getAnnotation(C.class) != null ? "C" : "null"));
        return null;
    }
}

我希望它打印:
答:空
乙:丙
乙:丙
乙:丙

但实际输出是
答:空
B: 空
乙:丙
B: 空

当我将 B 的泛型更改为 Object 或将其删除时，它会正确打印:
答:空
乙:丙
乙:丙
乙:丙

Answer 1

当我使用 Java 8 或更新版本编译并运行您的示例时，我得到了您期望的输出:

A: null
B: C
B: C
B: C

如果您将调用处理程序代码更改为

@Override
public Object invoke(Object proxy, Method method, Object[] args) {
    System.out.println(method.getDeclaringClass().getSimpleName()
        + "." + method.getName()
        + Arrays.toString(method.getParameterTypes())
        + ": " + (method.getAnnotation(C.class) != null ? "C" : "null"));
    return null;
}

你会得到

使用 Java 8 或更新版本编译:

A.test[class java.lang.Object]: null
B.test[class java.lang.Object]: C
B.test[class java.lang.String]: C
B.test[class java.lang.Object]: C

使用较旧的 Java 版本编译:

A.test[class java.lang.Object]: null
A.test[class java.lang.Object]: null
B.test[class java.lang.String]: C
A.test[class java.lang.Object]: null

为了进一步说明问题，将以下内容添加到您的main 方法

Class<?>[] classes = { A.class, B.class };
for(Class<?> c: classes) {
    System.out.println(c);
    for(Method m: c.getDeclaredMethods()) {
        for(Annotation a: m.getDeclaredAnnotations())
            System.out.print(a+" ");
        System.out.println(m);
    }
    System.out.println();
}

它会打印

interface ProxyTest$A
public abstract void ProxyTest$A.test(java.lang.Object)

interface ProxyTest$B
@ProxyTest$C() public abstract void ProxyTest$B.test(java.lang.String)

使用 8 之前的 Java 版本编译时。

由于类型删除，A 接口(interface)只声明了一个类型为 Object 的方法，当 test 被调用时，它总是会被调用编译时类型 A 的引用。接口(interface) B 声明了一个带有 String 参数类型的专用版本，仅当引用的编译时类型为 B 时才会调用该版本。

实现类必须实现这两个方法，您通常不会注意到，因为编译器会自动实现一个桥接方法，这里是test(Object)，用于你，它将转换参数并调用真正的实现方法，这里是 test(String)。但是您在生成代理时确实会注意到，该代理将为任一方法调用您的调用处理程序，而不是实现桥接逻辑。

当您在 Java 8 或更新版本下编译和运行代码时，它将打印

interface ProxyTest$A
public abstract void ProxyTest$A.test(java.lang.Object)

interface ProxyTest$B
@ProxyTest$C() public abstract void ProxyTest$B.test(java.lang.String)
@ProxyTest$C() public default void ProxyTest$B.test(java.lang.Object)

现在，接口(interface) B 有一个自己的桥接方法，这成为可能，因为 Java 现在支持接口(interface)中的非抽象 方法。由于参数类型，代理仍然覆盖两者，正如您可以注意到的那样，但是由于编译器将在实际接口(interface)方法中声明的所有注释复制到桥接方法，您将在调用处理程序中看到它们。此外，声明类现在是预期的类 B。

请注意，Proxy 的运行时行为没有改变，编译器有所不同。因此，您需要重新编译您的源代码，以便从新版本中获益(结果将无法在旧版本上运行)。