论坛 › Java › 通过Lambda函数的方式获取属性名称

种地 发表于 2023-11-9 22:54:22

通过Lambda函数的方式获取属性名称

前言:
最近在使用mybatis-plus框架, 常常会使用lambda的方法引用获取实体属性, 避免出现大量的魔法值.
public List<User> listBySex() {
LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();
// lambda方法引用
queryWrapper.eq(User::getSex, "男");
return userServer.list(wrapper);
}那么在我们平时的开发过程中, 常常需要用到java bean的属性名, 直接写死属性名字符串的形式容易产生bug, 比如属性名变化, 编译时并不会报错, 只有在运行时才会报错该对象没有指定的属性名称. 而lambda的方式不仅可以简化代码, 而且可以通过getter方法引用拿到属性名, 避免潜在bug.
期望的效果

String userName = BeanUtils.getFieldName(User::getName);
System.out.println(userName);
// 输出: name实现步骤


[*]定义一个函数式接口, 用来接收lambda方法引用
注意: 函数式接口必须继承Serializable接口才能获取方法信息
@FunctionalInterface
public interface SFunction<T> extends Serializable {
Object apply(T t);
}
[*]定义一个工具类, 用来解析获取属性名称
import lombok.extern.slf4j.Slf4j;
import org.springframework.util.ClassUtils;
import org.springframework.util.ReflectionUtils;

import java.beans.Introspector;
import java.lang.invoke.SerializedLambda;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

@Slf4j
public class BeanUtils {
    private static final Map<SFunction<?>, Field> FUNCTION_CACHE = new ConcurrentHashMap<>();

    public static <T> String getFieldName(SFunction<T> function) {
      Field field = BeanUtils.getField(function);
      return field.getName();
    }

    public static <T> Field getField(SFunction<T> function) {
      return FUNCTION_CACHE.computeIfAbsent(function, BeanUtils::findField);
    }

    public static <T> Field findField(SFunction<T> function) {
      // 第1步 获取SerializedLambda
      final SerializedLambda serializedLambda = getSerializedLambda(function);
      // 第2步 implMethodName 即为Field对应的Getter方法名
      final String implClass = serializedLambda.getImplClass();
      final String implMethodName = serializedLambda.getImplMethodName();
      final String fieldName = convertToFieldName(implMethodName);
      // 第3步Spring 中的反射工具类获取Class中定义的Field
      final Field field = getField(fieldName, serializedLambda);

      // 第4步 如果没有找到对应的字段应该抛出异常
      if (field == null) {
            throw new RuntimeException("No such class 「"+ implClass +"」 field 「" + fieldName + "」.");
      }

      return field;
    }

    static Field getField(String fieldName, SerializedLambda serializedLambda) {
      try {
            // 获取的Class是字符串，并且包名是“/”分割，需要替换成“.”，才能获取到对应的Class对象
            String declaredClass = serializedLambda.getImplClass().replace("/", ".");
            Class<?>aClass = Class.forName(declaredClass, false, ClassUtils.getDefaultClassLoader());
            return ReflectionUtils.findField(aClass, fieldName);
      }
      catch (ClassNotFoundException e) {
            throw new RuntimeException("get class field exception.", e);
      }
    }

    static String convertToFieldName(String getterMethodName) {
      // 获取方法名
      String prefix = null;
      if (getterMethodName.startsWith("get")) {
            prefix = "get";
      }
      else if (getterMethodName.startsWith("is")) {
            prefix = "is";
      }

      if (prefix == null) {
            throw new IllegalArgumentException("invalid getter method: " + getterMethodName);
      }

      // 截取get/is之后的字符串并转换首字母为小写
      return Introspector.decapitalize(getterMethodName.replace(prefix, ""));
    }

    static <T> SerializedLambda getSerializedLambda(SFunction<T> function) {
      try {
            Method method = function.getClass().getDeclaredMethod("writeReplace");
            method.setAccessible(Boolean.TRUE);
            return (SerializedLambda) method.invoke(function);
      }
      catch (Exception e) {
            throw new RuntimeException("get SerializedLambda exception.", e);
      }
    }
}
测试

public class Test {
    public static void main(String[] args) {
      SFunction<User> user = User::getName;
      final String fieldName = BeanUtils.getFieldName(user);
      System.out.println(fieldName);
    }

    @Data
    static class User {
      private String name;

      private int age;
    }
}执行测试 输出结果
https://img2023.cnblogs.com/blog/1759273/202310/1759273-20231019180714770-309706339.png
原理剖析

为什么SFunction必须继承Serializable

首先简单了解一下java.io.Serializable接口，该接口很常见，我们在持久化一个对象或者在RPC框架之间通信使用JDK序列化时都会让传输的实体类实现该接口，该接口是一个标记接口没有定义任何方法，但是该接口文档中有这么一段描述：
https://img2023.cnblogs.com/blog/1759273/202310/1759273-20231019180731057-1420043169.png
概要意思就是说，如果想在序列化时改变序列化的对象，可以通过在实体类中定义任意访问权限的Object writeReplace()来改变默认序列化的对象。
代码中SFunction只是一个接口, 但是其在最后必定也是一个实现类的实例对象，而方法引用其实是在运行时动态创建的，当代码执行到方法引用时,如User::getName，最后会经过
java.lang.invoke.LambdaMetafactory
java.lang.invoke.InnerClassLambdaMetafactory去动态的创建实现类。而在动态创建实现类时则会判断函数式接口是否实现了Serializable，如果实现了，则添加writeReplace方法
https://img2023.cnblogs.com/blog/1759273/202310/1759273-20231019180749934-328095641.png
https://img2023.cnblogs.com/blog/1759273/202310/1759273-20231019180805884-1122031244.png
https://img2023.cnblogs.com/blog/1759273/202310/1759273-20231019180817763-152733481.png
也就是说我们代码BeanUtils#getSerializedLambda方法中反射调用的writeReplace方法是在生成函数式接口实现类时添加进去的.
SFunction Class中的writeReplace方法

从上文中我们得知 当SFunction继承Serializable时, 底层在动态生成SFunction的实现类时添加了writeReplace方法, 那这个方法有什么用?
首先 我们将动态生成的类保存到磁盘上看一下
我们可以通过如下属性配置将 动态生成的Class保存到 磁盘上
java8中可以通过硬编码
System.setProperty("jdk.internal.lambda.dumpProxyClasses", ".");例如:
https://img2023.cnblogs.com/blog/1759273/202310/1759273-20231019180831003-16267359.png
jdk11 中只能使用jvm参数指定,硬编码无效,原因是模块化导致的
-Djdk.internal.lambda.dumpProxyClasses=.例如:
https://img2023.cnblogs.com/blog/1759273/202310/1759273-20231019180852604-813407436.png
执行方法后输出文件如下:
https://img2023.cnblogs.com/blog/1759273/202310/1759273-20231019180903034-174230495.png
其中实现类的类名是有具体含义的
https://img2023.cnblogs.com/blog/1759273/202310/1759273-20231019180932721-1570392238.png
其中Test$Lambda$15.class信息如下:
//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by FernFlower decompiler)
//

package test.java8.lambdaimpl;

import java.lang.invoke.SerializedLambda;
import java.lang.invoke.LambdaForm.Hidden;
import test.java8.lambdaimpl.Test.User;

// $FF: synthetic class
final class Test$$Lambda$15 implements SFunction {
    private Test$$Lambda$15() {
    }

    @Hidden
    public Object apply(Object var1) {
      return ((User)var1).getName();
    }

    private final Object writeReplace() {
      return new SerializedLambda(Test.class, "test/java8/lambdaimpl/SFunction", "apply", "(Ljava/lang/Object;)Ljava/lang/Object;", 5, "test/java8/lambdaimpl/Test$User", "getName", "()Ljava/lang/String;", "(Ltest/java8/lambdaimpl/Test$User;)Ljava/lang/Object;", new Object);
    }
}通过源码得知 调用writeReplace方法是为了获取到方法返回的SerializedLambda对象
SerializedLambda:是Java8中提供，主要就是用于封装方法引用所对应的信息，主要的就是方法名、定义方法的类名、创建方法引用所在类。拿到这些信息后，便可以通过反射获取对应的Field。
值得注意的是，代码中多次编写的同一个方法引用，他们创建的是不同Function实现类，即他们的Function实例对象也并不是同一个。
https://img2023.cnblogs.com/blog/1759273/202310/1759273-20231019180947018-821517958.png
一个方法引用创建一个实现类，他们是不同的对象，那么BeanUtils中将SFunction作为缓存key还有意义吗？
答案是肯定有意义的！！！因为同一方法中的定义的Function只会动态的创建一次实现类并只实例化一次，当该方法被多次调用时即可走缓存中查询该方法引用对应的Field。
通过内部类实现类的类名规则我们也能大致推断出来, 只要申明lambda的相对位置不变, 那么对应的Function实现类包括对象都不会变。
通过在刚才的示例代码中添加一行, 就能说明该问题, 之前15号对应的是getName, 而此时的15号class对应的是getAge这个函数引用
https://img2023.cnblogs.com/blog/1759273/202310/1759273-20231019181002306-328194482.png
https://img2023.cnblogs.com/blog/1759273/202310/1759273-20231019181013766-580081870.png
我们再通过代码验证一下 刚才的猜想
https://img2023.cnblogs.com/blog/1759273/202310/1759273-20231019181023139-712806412.png
参考:
https://blog.csdn.net/u013202238/article/details/105779686
https://blog.csdn.net/qq_39809458/article/details/101423610

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！

查看完整版本: 通过Lambda函数的方式获取属性名称