public List<User> listBySex() {
  LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();
  // lambda方法引用
  queryWrapper.eq(User::getSex, "男");
  return userServer.list(wrapper);
}

@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對(duì)應(yīng)的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步 如果沒有找到對(duì)應(yīng)的字段應(yīng)該拋出異常
        if (field == null) {
            throw new RuntimeException("No such class 「"+ implClass +"」 field 「" + fieldName + "」.");
        }

        return field;
    }

    static Field getField(String fieldName, SerializedLambda serializedLambda) {
        try {
            // 獲取的Class是字符串，并且包名是“/”分割，需要替換成“.”，才能獲取到對(duì)應(yīng)的Class對(duì)象
            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之后的字符串并轉(zhuǎn)換首字母為小寫
        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;
    }
}

java.lang.invoke.LambdaMetafactory
java.lang.invoke.InnerClassLambdaMetafactory

 System.setProperty("jdk.internal.lambda.dumpProxyClasses", ".");

-Djdk.internal.lambda.dumpProxyClasses=.