使用 java MethodHandles 实现鸭子类型

Question

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

我知道有一个指令叫做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 中为注释定义基类，因此，如果可能，我想实现这种鸭子类型，而不是使用实例化链和类转换或使用违反访问权限的反射来检索这些值。

谢谢。

Answer 1

当 VMinvokedynamic第一次遇到指令时，它会调用工厂方法或“bootstrap”方法，该方法返回CallSite目标实现实际功能的对象。您可以使用MutableCallSite在第一次调用时查找目标方法的a 自己实现，然后将它自己的目标设置为查找的方法。

但是，这对于您的目的来说还不够。您想在遇到新的接收器类型时重新链接呼叫站点。

这是一个示例（目前仅支持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");
    }
}