JVM方法句柄

方法句柄是一个强类型的，能够被直接执行的引用。该引用可以指向常规的静态方法或者实例方法，也可以指向构造器或者字段。当指向字段时，方法句柄实则指向包含字段访问字节码的虚构方法，语义上等价于目标字段的 getter 或者 setter 方法

方法句柄的类型（MethodType）是由所指向方法的参数类型以及返回类型组成的。它是用来确认方法句柄是否适配的唯一关键。当使用方法句柄时，我们其实并不关心方法句柄所指向方法的类名或者方法名

方法句柄的创建是通过 MethodHandles.Lookup 类来完成的。它提供了多个 API，既可以使用反射 API 中的 Method 来查找，也可以根据类、方法名以及方法句柄类型来查找

当使用后者这种查找方式时（方法句柄类型），用户需要区分具体的调用类型，比如说对于用 invokestatic 调用的静态方法，我们需要使用 Lookup.findStatic 方法；对于用 invokevirutal 调用的实例方法，以及用 invokeinterface 调用的接口方法，我们需要使用 findVirtual 方法；对于用 invokespecial 调用的实例方法，我们则需要使用 findSpecial 方法。

具体操作

方法类型

一个 Java 方法可以视为由四个基本内容所构成：

• 名称

• 签名（包含返回类型）

• 定义它的类

• 实现方法的字节码

方法句柄首先需要的一个构建块就是表达方法签名的方式，以便于查找。在 Java 7 引入的 Method Handles API 中，这个角色是由 java.lang.invoke.MethodType 类来完成的，它使用一个不可变的实例来代表签名。要获取 MethodType，我们可以使用 methodType() 工厂方法。这是一个参数可变（variadic）的方法，以 class 对象作为参数。

第一个参数所使用的 class 对象，对应着签名的返回类型；剩余参数中所使用的 class 对象，对应着签名中方法参数的类型。例如：

//toString() 的签名 
MethodType mtToString = MethodType.methodType(String.class);

// setter 方法的签名 
MethodType mtSetter = MethodType.methodType(void.class, Object.class);

// Comparator 中 compare() 方法的签名 
MethodType mtStringComparator = MethodType.methodType(int.class, String.class)

现在可以使用 MethodType，再组合方法名称以及定义方法的类来查找方法句柄。要实现这一点，我们需要调用静态的 MethodHandles.lookup() 方法。这样的话，会给我们一个“查找上下文（lookup context）”，这个上下文基于当前正在执行的方法（也就是调用 lookup() 的方法）的访问权限。

查找上下文对象有一些以“find”开头的方法，例如，findVirtual()、findConstructor()、findStatic() 等。这些方法将会返回实际的方法句柄，需要注意的是，只有在创建查找上下文的方法能够访问（调用）被请求方法的情况下，才会返回句柄。这与反射不同，我们没有办法绕过访问控制。换句话说，方法句柄中并没有与 setAccessible() 对应的方法。

通过MethodHandle进行方法调用一般需要以下几步：

• （1）创建MethodType对象，指定方法的签名；

• （2）在MethodHandles.Lookup中查找类型为MethodType的MethodHandle；

• （3）传入方法参数并调用MethodHandle.invoke或者MethodHandle.invokeExact方法。

MethodType

可以通过MethodHandle类的type方法查看其类型，返回值是MethodType类的对象。也可以在得到MethodType对象之后，调用MethodHandle.asType(mt)方法适配得到MethodHandle对象。可以通过调用MethodType的静态方法创建MethodType实例，有三种创建方式：

• （1）methodType及其重载方法：需要指定返回值类型以及0到多个参数；

• （2）genericMethodType：需要指定参数的个数，类型都为Object；

• （3）fromMethodDescriptorString：通过方法描述来创建。

Lookup

MethodHandle.Lookup相当于MethodHandle工厂类，通过findxxx方法可以得到相应的MethodHandle

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

• findStatic
  对应字节码:invokestatic
  调用静态方法

• findSpecial
  对应字节码:invokespecial
  调用实例构造方法，私有方法，父类方法

• findVirtual
  对应字节码:invokevirtual
  调用所有的虚方法

• findVirtual
  对应字节码:invokeinterface
  调用接口方法，会在运行时再确定一个实现此接口的对象

invoke

在得到MethodHandle后就可以进行方法调用了，有三种调用形式：

• （1）invokeExact:调用此方法与直接调用底层方法一样，需要做到参数类型精确匹配；

• （2）invoke:参数类型松散匹配，通过asType自动适配；

• （3）invokeWithArguments:直接通过方法参数来调用。其实现是先通genericMethodType方法得到MethodType，再通过MethodHandle的asType转换后得到一个新的MethodHandle，最后通过新MethodHandle的invokeExact方法来完成调用。

官方文档例子

public class examples {

    public static void main(String[] args) throws Throwable {


        Object x, y; String s; int i;
        MethodType mt; MethodHandle mh;
        MethodHandles.Lookup lookup = MethodHandles.lookup();

// mt is (char,char)String
        mt = MethodType.methodType(String.class, char.class, char.class);
        mh = lookup.findVirtual(String.class, "replace", mt);
        s = (String) mh.invokeExact("daddy",'d','n');


// invokeExact(Ljava/lang/String;CC)Ljava/lang/String;
//        assertEquals(s, "nanny");
        System.out.println(s);
        System.out.println("-----------------------------");



// weakly typed invocation (using MHs.invoke)
        s = (String) mh.invokeWithArguments("sappy", 'p', 'v');
//        assertEquals(s, "savvy");
        System.out.println(s);
        System.out.println("-----------------------------");



// mt is (Object[])List
        mt = MethodType.methodType(java.util.List.class, Object[].class);
        mh = lookup.findStatic(java.util.Arrays.class, "asList", mt);
        assert(mh.isVarargsCollector());
        x = mh.invoke("one", "two");


// invoke(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/Object;
//        assertEquals(x, java.util.Arrays.asList("one","two"));
        System.out.println(x);
        System.out.println("-----------------------------");


// mt is (Object,Object,Object)Object
        mt = MethodType.genericMethodType(3);
        mh = mh.asType(mt);
        x = mh.invokeExact((Object)1, (Object)2, (Object)3);


// invokeExact(Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;


//        assertEquals(x, java.util.Arrays.asList(1,2,3));
        System.out.println(x);
        System.out.println("-----------------------------");



// mt is ()int
        mt = MethodType.methodType(int.class);
        mh = lookup.findVirtual(java.util.List.class, "size", mt);
        i = (int) mh.invokeExact(java.util.Arrays.asList(1,2,3));



// invokeExact(Ljava/util/List;)I
        assert(i == 3);
        mt = MethodType.methodType(void.class, String.class);
        mh = lookup.findVirtual(java.io.PrintStream.class, "println", mt);
        mh.invokeExact(System.out, "Hello, world.");


// invokeExact(Ljava/io/PrintStream;Ljava/lang/String;)V

    }
}

MethodHandle 与 Method 区别

• MethodHandle 在模拟 字节码 层次的方法调用，因而可适用于所有 JVM 语言 ；

• Reflection 在模拟 Java 层次的方法调用，仅可适用于 Java。

• MethodHandle 可进行 JVM 的内联优化，Reflection 屏蔽了 JVM ，所以完全没有相应的优化。

• MethodHandle 从 JVM 层次支持调用，只需要包含方法必要的信息，所以说是轻量级的，而 Reflection 是 Java Api 层次的反射调用，包含了方法的签名、描述符以及方法属性表中各种属性的Java端表示方式，还包含有执行权限等的运行期信息，所以说是重量级的。

• MethodHandle 方法调用需要考虑到 字节码，而 Reflection 则不用考虑这些。

参考文章

https://www.infoq.cn/article/Invokedynamic-Javas-secret-weapon

https://segmentfault.com/a/1190000017208820

https://www.zhihu.com/question/40427344/answer/252825611