5

我有两个类A，并且B都定义foo()了具有共同签名的方法（不接受任何内容，返回无效）。它们没有声明此方法的通用基类（或接口）。我想在 As 或 B 上调用这个方法，只要他们能响应这个调用。这种方法称为Duck Typing。

我知道有一条指令叫做invokedynamic：

invokedynamic 指令的每个实例称为动态调用站点。动态调用站点最初处于未链接状态，这意味着没有指定调用站点调用的方法。如前所述，动态调用站点通过引导方法链接到方法。动态调用站点的引导方法是编译器为动态类型语言指定的方法，JVM 调用一次以链接站点。从引导方法返回的对象永久确定调用站点的行为。

所以我尝试使用MethodHandles来实现这一点。这是示例：

public static class A {
    public void foo() {
    }
}

public static class B {
    public void foo() {
    }
}

public static void main(String[] args) throws Throwable {
    final MethodHandle foo = MethodHandles.lookup()
            .findVirtual(A.class, "foo", MethodType.methodType(void.class));

    foo.invoke(new B());
}

当然，我有：

Exception in thread "main" java.lang.ClassCastException: Cannot cast Main$B to Main$A
    at sun.invoke.util.ValueConversions.newClassCastException(ValueConversions.java:461)
    at sun.invoke.util.ValueConversions.castReference(ValueConversions.java:456)
    at Main.main(Main.java:30)

invokedynamic我清楚地看到和之间的区别MethodHanle。我看到问题在于fooMethodHandle 绑定到class A，而不是class B. invokedynamic但我有可能在这种特殊情况下以某种方式利用吗？

为什么我需要这个？这是我的小型研究项目的一部分。我正在尝试深入了解方法句柄，并且我想在从字段和方法中检索到的注释实例上调用常用方法。我无法在 Java 中为注释定义基类，因此不是使用实例化链和类强制转换或使用违反访问权限的反射检索这些值，如果可能的话，我想实现这种鸭子类型。

谢谢。

4

1 回答 1

7

当虚拟机第一次遇到invokedynamic指令时，它调用工厂方法或“引导”方法，该方法返回一个CallSite目标实现实际功能的对象。您可以使用MutableCallSite在第一次调用时查找您的目标方法然后将其自己的目标设置为查找的方法来实现它自己。

但是，这还不足以满足您的目的。当您遇到新的接收方类型时，您希望重新链接呼叫站点。

这是一个示例（目前仅支持findVirtual）：

class DuckTypingCallSite extends MutableCallSite {

    private static final MethodHandle MH_relink;
    private static final MethodHandle MH_isInstance;

    static {
        try {
            MH_relink = lookup().findVirtual(DuckTypingCallSite.class, "link", methodType(Object.class, Object[].class));
            MH_isInstance = lookup().findVirtual(Class.class, "isInstance", methodType(boolean.class, Object.class));
        } catch (ReflectiveOperationException e) {
            throw new InternalError(e);
        }
    }

    private final MethodHandles.Lookup lookup;
    private final String methodName;
    private final MethodType lookupType;

    private DuckTypingCallSite(MethodHandles.Lookup lookup, String methodName, MethodType lookupType) {
        super(lookupType.insertParameterTypes(0, Object.class)); // insert receiver
        this.lookup = lookup;
        this.methodName = methodName;
        this.lookupType = lookupType;
    }

    public static DuckTypingCallSite make(MethodHandles.Lookup lookup, String methodName, MethodType lookupType) {
        DuckTypingCallSite cs = new DuckTypingCallSite(lookup, methodName, lookupType);
        cs.setTarget(MH_relink.bindTo(cs).asCollector(Object[].class, cs.type().parameterCount()).asType(cs.type()));
        return cs;
    }

    public Object link(Object[] args) throws Throwable {
        Object receiver = args[0];
        Class<?> holder = receiver.getClass();
        MethodHandle target = lookup.findVirtual(holder, methodName, lookupType).asType(type());

        MethodHandle test = MH_isInstance.bindTo(holder);
        MethodHandle newTarget = guardWithTest(test, target, getTarget());
        setTarget(newTarget);

        return target.invokeWithArguments(args);
    }

}

在第一次调用之前，调用调用站点的动态调用程序将直接跳转到link方法中，该方法将查找目标方法然后调用它，以及重新链接 DuckTypingCallSite 以基本上缓存查找到的 MethodHandle，由类型检查保护.

在第一次调用之后，这实际上创建了一个 if/else，如下所示：

if (A.class.isInstance(receiver)) {
    // invoke A.foo
} else {
    // re-link
}

然后当遇到第二种类型时，它会变为：

if (B.class.isInstance(receiver)) {
    // invoke B.foo
} else if (A.class.isInstance(receiver)) {
    // invoke A.foo
} else {
    // re-link
}

等等

这是一个示例用法：

public class DuckTyping {

    private static final MethodHandle MH_foo = DuckTypingCallSite.make(lookup(), "foo", methodType(void.class)).dynamicInvoker();

    private static void foo(Object receiver) {
        try {
            MH_foo.invokeExact(receiver);
        } catch (Throwable throwable) {
            throw new IllegalStateException(throwable);
        }
    }

    public static void main(String[] args) {
        foo(new A()); // prints "A.foo"
        foo(new B()); // prints "B.foo"
    }
}

class A {
    public void foo() {
        System.out.println("A.foo");
    }
}

class B {
    public void foo() {
        System.out.println("B.foo");
    }
}
于 2020-06-11T11:50:54.413 回答