使用 java MethodHandles 实现鸭子类型

Question

我有两个类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 之间的区别。我看到问题在于foo MethodHandle 绑定到class A，而不是class B。但是在这种特殊情况下，我有可能以某种方式利用invokedynamic 吗？

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

谢谢。

Answer 1

当 VM 第一次遇到 invokedynamic 指令时，它会调用工厂方法或“引导”方法，该方法会返回一个目标是实现实际功能的 CallSite 对象。您可以使用MutableCallSite 自己实现它，该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");
    }
}