秒懂Java之方法句柄(MethodHandle)

ShuSheng007

5785人浏览 · 2020-07-02 23:08:40

ShuSheng007 · 2020-07-02 23:08:40 发布

【版权申明】非商业目的注明出处可自由转载
博文地址：https://blog.csdn.net/ShuSheng0007/article/details/107066856
出自：shusheng007

文章目录

概述
关键概念
如何使用
实际使用
总结
抒情

概述

众所周知，Java从最初发布时就支持反射，通过反射可以在运行时获取类型信息，但其有个缺点就是执行速度较慢。于是从Java 7开始提供了另一套API MethodHandle 。其与反射的作用类似，可以在运行时访问类型信息，但是据说其执行效率比反射更高，也被称为Java的 现代化反射。

官方对其定义如下：

A method handle is a typed, directly executable reference to an underlying method, constructor, field, or similar low-level operation, with optional transformations of arguments or return values.

在《深入理解Java虚拟机》第三版中，作者也提到了MethodHandle, 但作者更多是从JVM的层面理解它，认为其主要目的是为JVM设计的一套API，以支持其他JVM语言的反射能力，例如Groovy 、Scale、Kotlin 等。

本文主要从Java编程语言的角度来看一下如何使用这套API，至于其运行效率是不是真的比反射高，以及高多少都不会涉及，有兴趣的可以自行研究。

关键概念

Lookup
MethodHandle 的创建工厂，通过它可以创建MethodHandle，值得注意的是检查工作是在创建时处理的，而不是在调用时处理。
MethodType
顾名思义，就是代表方法的签名。一个方法的返回值类型是什么，有几个参数，每个参数的类型什么？
MethodHandle
方法句柄，通过它我们就可以动态访问类型信息了。

如何使用

当理解了上面几个关键概念后使用起来就比较简单了，总的来说只需要4步：

创建Lookup
创建MethodType
基于Lookup与MethodType获得MethodHandle
调用MethodHandle

那我们接下来就按照上面4个步骤通过方法句柄来访问一下某个类里面的方法以及属性等。

首先提供一个目标类

public class HandleTarget {
    private String name = "hello world";

    public HandleTarget() {
    }

    public HandleTarget(String name) {
        this.name = name;
    }

    public void connectName(String name) {
        this.name = this.name + " " + name;
    }

    public String getName() {
        return name;
    }

    private void learnPrograming(String lang) {
        System.out.println(String.format("I am learning %s ", lang));
    }

    public static String declaration(String author) {
        return author + ": " + "吾生也有涯，而知也无涯。以有涯随无涯，殆己";
    }

    @Override
    public String toString() {
        return "HandleTarget{" +
                "name='" + name + '\'' +
                '}';
    }
}

这个类里面有两个构造函数（一个无参，一个有参），一个private Field, 两个public实例方法，一个public static方法以及一个private实例方法。接下来我们就具体看一下如何访问这些元素。

创建Lookup

使用如下代码创建一个lookup，以这种方式得到的lookup很强大，凡是调用类支持的字节码操作，它都支持。

 MethodHandles.Lookup lookup = MethodHandles.lookup();

我们还可以使用如下代码创建，但是以此种方式创建的lookup能力是受限的，其只能访问类中public的成员。

MethodHandles.Lookup publicLookup=MethodHandles.publicLookup();

创建MethodType

MethodType使用其静态方法创建

public static   MethodType methodType(Class<?> rtype, Class<?>[] ptypes)

第一个参数是方法的返回类型，第二参数是方法的入参

其有很多非常方便的重载，基本满足了一般的使用场景

创建MethodHandle

主要通过lookup里面的方法来寻找

创建构造函数MethodHandle

public MethodHandle findConstructor(Class<?> refc, MethodType type)

refc: 要检索的类
type: 对应的构造函数的MethodType

创建实例方法MethodHandle

 public MethodHandle findVirtual(Class<?> refc, String name, MethodType type)

name: 方法名称

创建类方法的MethodHandle

public   MethodHandle findStatic(Class<?> refc, String name, MethodType type)

创建非private的Field的访问MethodHandle 。

注意这个不是获取field的javabean Setter方法，与其毫无关系。通过这个setter 方法句柄我们就可以访问到这个属性了。

public MethodHandle findGetter(Class<?> refc, String name, Class<?> type)

对应的如果要设置此属性的值，使用Setter方法句柄

public MethodHandle findSetter(Class<?> refc, String name, Class<?> type)

调用MethodHandle

使用MethodHandle的invoke家族方法

public final native @PolymorphicSignature Object invoke(Object... args) throws Throwable;
public final native @PolymorphicSignature Object invokeExact(Object... args) throws Throwable;
...

实际使用

首先创建一个lookup

MethodHandles.Lookup lookup = MethodHandles.lookup();

访问构造函数

//无参数构造器
MethodType con1Mt = MethodType.methodType(void.class);
MethodHandle con1Mh = lookup.findConstructor(HandleTarget.class, con1Mt);
Object target1 = con1Mh.invoke();
//有参数构造器
MethodType con2Mt = MethodType.methodType(void.class, String.class);
MethodHandle con2Mh = lookup.findConstructor(HandleTarget.class, con2Mt);
Object target2 = con2Mh.invoke("ErGouWang");

访问非private实例方法

//调用非private实例方法
MethodType getterMt = MethodType.methodType(String.class);
MethodHandle getterMh = lookup.findVirtual(HandleTarget.class, "getName", getterMt);
String name = (String) getterMh.invoke(target2);
System.out.println(name);

访问private实例方法

//访问private方法
Method learnMethod = HandleTarget.class.getDeclaredMethod("learnPrograming", String.class);
learnMethod.setAccessible(true);
MethodHandle learnProMh = lookup.unreflect(learnMethod);
learnProMh.invoke(target1, "Java");

访问非private类方法

//调用静态方法
MethodType decMt = MethodType.methodType(String.class, String.class);
MethodHandle decMh = lookup.findStatic(HandleTarget.class, "declaration", decMt);
String dec = (String) decMh.invoke("庄子");
System.out.println(dec);

访问非private属性

//访问非private属性
MethodHandle nameMh= lookup.findGetter(HandleTarget.class,"name", String.class);
System.out.println((String) nameMh.invoke(con1Mh.invoke()));

访问private属性

//访问private的属性，需要借助反射
Field nameField = HandleTarget.class.getDeclaredField("name");
nameField.setAccessible(true);
MethodHandle nameFromRefMh = lookup.unreflectGetter(nameField);
System.out.println((String) nameFromRefMh.invoke(target1));

增强MethodHandle

//增强MethodHandle
MethodType setterMt = MethodType.methodType(void.class, String.class);
MethodHandle setterMh = lookup.findVirtual(HandleTarget.class, "connectName", setterMt);
MethodHandle bindedSetterMh = setterMh.bindTo(target2);
bindedSetterMh.invoke("love CuiHuaNiu");
System.out.println((String) getterMh.invoke(target2));

当我们创建了"connectName"方法的MethodHandle，可以不立即调用而是将其绑定到某个对象上，这个对象的类型必须是HandleTarget及其子类，那么调用重新获得MethodHandle时，其会调用到新绑定对象里面的那个方法上。