JSR 292 学习

JSR 292 学习

Add a new bytecode, invokedynamic ,
that supports efficient and flexible execution of method invocations in the absence of static type information.
添加一个字节码 invokedynamic 。用于提供在缺乏静态类型信息时高效和灵活的执行方法调用。
invokedynamic 是针对 JVM 的，用于更好的支持动态 JVM 语言的函数调用； JSR292 实现则提供在 Java 语言层面上的 invokedynamic 调用。

JSR292 实现于 JDK7，以下为实现方案的类。

└─java
    └─lang
        ├─invoke
        |   ├─CallSite
        |   ├─ConstantCallSite
        |   ├─MethodHandle
        |   ├─MethodHandleProxies
        |   ├─MethodHandles
        |   ├─MethodHandles.Lookup
        |   ├─MethodType
        |   ├─MutableCallSite
        |   ├─SwitchPoint
        |   └─VolatileCallSite
        ├─ClassValue
        └─BootstrapMethodError

API 使用

JSR292 API 提供了 invokedynamic 字节码的 API 支持。

使用基本思路

1. 创建 MethodType 对象，指定方法的签名
2. 在 MethodHandles.Lookup 中查找类型为 MethodType 的 MethodHandle
3. 传入方法参数并调用 MethodHandle.invoke 或者 MethodHandle.invokeExact 方法

MethodType

用于指定方法的类型，此处的方法类型与 Java 的方法判断有点区别，Java 的方法签名不包括 返回值 ，但是 MethodType 却是通过 返回值 和 参数类型 来确定。并且该类型不包含 方法名 。

// 快速创建一个 MethodType 。
MethodType methodType = MethodType.methodType(String.class, Object.class);

// 也可以通过 MethodHandle 实例获取它要调用的方法实例
// MethodHandle handle = ...
MethodType type = handle.type();

除了这两种获取 MethodType 的方法（实际上第二种不算，MethodHandle 对象的创建依赖于 MethodType）。下面还有两种，它也是 MethodType 的静态方法：

1. genericMethodType: 所有类型都是 Object 类型
2. fromMethodDescriptorString: 有两个参数，一个是方法描述符，该描述符是基于 字节码 层面的描述符。之后就是一个类加载器。

当然，创建完之后还可以修改返回值类型和参数类型如： changeParameterType 、 changeReturnType 等。

MethodHandles.Lookup

一个工厂类，用于创建 MethodHandle 类对象。它可通过普通的 findXxx() 方法得到相应的 MethodHandle 实例，也可以通过 反射类 来创建实例。如 lookup.unreflect(Method) 等方法。

MethodHandle

MethodHandle 可看成是方法引用，它使得 Java 拥有了类似函数指针或委托的方法别名工具。

注意几点：

1. 引用的方法必须和 MethodHandle 的 type 保持一致。
2. 这里提到的 type 包括 返回值 和 参数列表 。
3. MethodHandle 也是可执行及可以进行转换。

几个 MethodHandle 方法与字节码的对应：

MethodHandle方法	字节码	描述
findStatic	invokestatic	调用静态方法
findSpecial	invokespecial	调用实例构造方法，私有方法，父类方法。
findVirtual	invokevirtual	调用所有的虚方法
findVirtual	invokeinterface	调用接口方法，会在运行时再确定一个实现此接口的对象。

示例

public void example() throws Throwable {
    // MethodHandles.Lookup 类似于 MethodHandle 工厂类，用于创建 MethodHandle
    MethodHandles.Lookup lookup = MethodHandles.lookup();
    MethodHandle mh = lookup.findStatic(String.class, "valueOf", MethodType.methodType(String.class, int.class));

    String result = (String) mh.invoke(1);
    System.out.println("1".equals(result));
}

三种调用方式：

1. invokeExact: 调用此方法与直接调用底层方法一样，需要做到参数类型精确匹配
2. invoke: 参数类型松散匹配，通过asType自动适配
3. invokeWithArguments: 直接通过方法参数来调用

CallSite

当 JVM 执行 invokedynamic 指令时，首先需要链接其对应的 动态调用点 。在链接的时候，JVM会先调用一个启动方法（bootstrap method）。这个启动方法的返回值是 java.lang.invoke.CallSite 类的对象。

在通过启动方法得到了 CallSite 之后，通过这个 CallSite 对象的 getTarget() 可以获取到实际要调用的目标方法句柄。
有了方法句柄之后，对这个 动态调用点 的调用，实际上是代理给方法句柄来完成的。
也就是说，对 invokedynamic 指令的调用实际上就等价于对方法句柄的调用，具体来说是被转换成对方法句柄的invoke方法的调用。

JDK7 中提供了三种类型的动态调用点CallSite的实现：java.lang.invoke.ConstantCallSite、java.lang.invoke.MutableCallSite和 java.lang.invoke.VolatileCallSite。

ConstantCallSite

表示的调用点绑定的是一个固定的方法句柄，一旦链接之后，就无法修改。示例如下：

public void constantCallSite() throws Throwable {
    MethodType type = MethodType.methodType(String.class, int.class, int.class);

    MethodHandles.Lookup lookup = MethodHandles.lookup();
    MethodHandle handle = lookup.findVirtual(String.class, "substring", type);

    ConstantCallSite callSite = new ConstantCallSite(handle);
    MethodHandle invoker = callSite.dynamicInvoker();
    String result = (String) invoker.invoke("Hello", 2, 3);
    System.out.println(result);
}

MutableCallSite

表示的调用点则允许在运行时动态修改其目标方法句柄，即可以重新链接到新的方法句柄上。示例如下：

/**
 * MutableCallSite 允许对其所关联的目标方法句柄通过setTarget方法来进行修改。
 * 以下为 创建一个 MutableCallSite，指定了方法句柄的类型，则设置的其他方法也必须是这种类型。
 */
public void useMutableCallSite() throws Throwable {
    MethodType type = MethodType.methodType(int.class, int.class, int.class);
    MutableCallSite callSite = new MutableCallSite(type);
    MethodHandle invoker = callSite.dynamicInvoker();

    MethodHandles.Lookup lookup = MethodHandles.lookup();
    MethodHandle maxHandle = lookup.findStatic(Math.class, "max", type);
    callSite.setTarget(maxHandle);
    int result = (int) invoker.invoke(3, 5);
    System.out.println(result == 5);

    MethodHandle minHandle = lookup.findStatic(Math.class, "min", type);
    callSite.setTarget(minHandle);
    result = (int) invoker.invoke(3, 5);
    System.out.println(result == 3);
}

MutableCallSite.syncAll() 提供了方法来强制要求各个线程中 MutableCallSite 的使用者立即获取最新的目标方法句柄。
但这个时候也可以选择使用 VolatileCallSite。

VolatileCallSite

作用与 MutableCallSite 类似，不同的是它适用于多线程情况，用来保证对于目标方法句柄所做的修改能够被其他线程看到。
此处便不再提供示例，可参考 MutableCallSite。

MethodHandle 与 Method 区别

1. MethodHandle 在模拟 字节码 层次的方法调用，因而可适用于所有 JVM 语言 ；Reflection 在模拟 Java 层次的方法调用，仅可适用于 Java。
2. MethodHandle 可进行 JVM 的内联优化，Reflection 屏蔽了 JVM ，所以完全没有相应的优化。
3. MethodHandle 从 JVM 层次支持调用，只需要包含方法必要的信息，所以说是轻量级的，而 Reflection 是 Java Api 层次的反射调用，包含了方法的签名、描述符以及方法属性表中各种属性的Java端表示方式，还包含有执行权限等的运行期信息，所以说是重量级的。
4. MethodHandle 方法调用需要考虑到 字节码，而 Reflection 则不用考虑这些。

---

参考

1. JDK1.8下关于MethodHandle问题
2. Invokedynamic 和 MethodHandle的缘由
3. MethodHandle与反射Method区别