介绍
- 在java中，利用反射的时候，有时候会传过去属性的名称字符串，然后根据字符串来获取字段Field对象，但是这种不是很优雅，需要传字符串过去。比如在mybatis-plus 2的版本中，构建查询wapper时，查询某个字段，需要将字段对应的列名称的字符串，传递过去，就看着十分不优雅。
- 但是在mybatis-plus 3中，就可以用lambda将字段的get方法传过去，它会自动知道查询的是哪个字段，这就有点神奇了。最终查询肯定是需要知道列的名称，而列名称是在属性上通过@TableField注解来定义的，它是怎么通过方法的lambda引用，来读取字段属性Field的了？
- 经过搜索，发现了 SerializedLambda 这个类，原来是基于这个类来实现，通过方法引用，来获取引用的方法的一些信息，包括实现方法的名称，和包含实现方法的类的名称等，下面来看看。
SerializedLambda
在java 8中，如果函数式接口实现了Serializable，那这个函数式接口用lambda表达式实现时，运行时会生成一个这个函数式接口的实现类，会有一个私有的“writeReplace”方法，返回 SerializedLambda 对象。而 SerializedLambda 这个类，就是来描述lambda表达式的，包含了函数式接口和实现方法等的信息。
注： Lambda表达式的实现原理，jvm中是利用invokedynamic指令（jdk7新增的），来实现调用动态方法，在运行期间通过生成字节码技术，生成一个内部类来实现接口，再来调用待执行的一个内部静态方法（lambda表达式中真正待执行的代码），从而执行真正的代码逻辑。Lambda的实现原理，本文不再详细说明。
SerializedLambda 在本文中用到的方法：
- serializedLambda.getImplMethodName()，获取实现方法的名称。如果是直接传递的方法引用，则获取的就是引用的方法的名称。
- serializedLambda.getImplClass()，获取实现方法所在的类的全限定名，用过“/”连接的字符串。如果是直接传递的方法引用，就能获取引用的方法所在类的名称。
代码实现
1、函数式接口
首先自定义一个函数式接口，实现Serializable，因为jdk中自带几个函数式接口，没有实现Serializable。
import java.io.Serializable;
import java.util.function.Function;
/**
* SFunction代替Function，获取序列化能力
*/
@FunctionalInterface
public interface SFunction<T, R> extends Function<T, R>, Serializable {
}
2、获取属性工具类方法
首先利用反射，获取SFunction接口的实现类中的 writeReplace 方法，然后用反射执行该方法，得到 SerializedLambda 对象，再通过 SerializedLambda 对象，获取引用的方法的名称，根据 java bean get 方法规范，获取 get 方法对应的属性名称。再获取引用的方法所在的类，然后再通过反射，获取该类中该属性的Field对象。
import java.lang.invoke.SerializedLambda;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
/**
* bean属性获取工具类
*/
public class FieldUtil {
/**
* 将bean的属性的get方法，作为lambda表达式传入时，获取get方法对应的属性Field
*
* @param fn lambda表达式，bean的属性的get方法
* @param <T> 泛型
* @return 属性对象
*/
public static <T> Field getField(SFunction<T, ?> fn) {
// 从function取出序列化方法
Method writeReplaceMethod;
try {
writeReplaceMethod = fn.getClass().getDeclaredMethod("writeReplace");
} catch (NoSuchMethodException e) {
throw new RuntimeException(e);
}
// 从序列化方法取出序列化的lambda信息
boolean isAccessible = writeReplaceMethod.isAccessible();
writeReplaceMethod.setAccessible(true);
SerializedLambda serializedLambda;
try {
serializedLambda = (SerializedLambda) writeReplaceMethod.invoke(fn);
} catch (IllegalAccessException | InvocationTargetException e) {
throw new RuntimeException(e);
}
writeReplaceMethod.setAccessible(isAccessible);
// 从lambda信息取出method、field、class等
String implMethodName = serializedLambda.getImplMethodName();
// 确保方法是符合规范的get方法，boolean类型是is开头
if (!implMethodName.startsWith("is") && !implMethodName.startsWith("get")) {
throw new RuntimeException("get方法名称: " + implMethodName + ", 不符合java bean规范");
}
// get方法开头为 is 或者 get，将方法名 去除is或者get，然后首字母小写，就是属性名
int prefixLen = implMethodName.startsWith("is") ? 2 : 3;
String fieldName = implMethodName.substring(prefixLen);
String firstChar = fieldName.substring(0, 1);
fieldName = fieldName.replaceFirst(firstChar, firstChar.toLowerCase());
Field field;
try {
field = Class.forName(serializedLambda.getImplClass().replace("/", ".")).getDeclaredField(fieldName);
} catch (ClassNotFoundException | NoSuchFieldException e) {
throw new RuntimeException(e);
}
return field;
}
}
3、测试
先对定义一个bean对象，Uesr，有个属性name。
public class User {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
然后通过 User::getName，方法的引用，来获取该字段属性对象，从而就能获取属性的名称、类型、拥有的注解等信息了，就能做很多的操作了，想象空间很大哦。
public static void main(String[] args) {
Field field = getField(User::getName);
System.out.println(field);
// 字段名称
String fieldName = field.getName();
System.out.println(fieldName);
// 字段上面的注解
Annotation[] annotations = field.getAnnotations();
for (Annotation annotation : annotations) {
System.out.println(annotation);
}
// 字段的类型
Class<?> type = field.getType();
System.out.println(type);
}
