mybatisplus lamdba表达式获取属性名称

import com.baomidou.mybatisplus.core.toolkit.LambdaUtils;
import com.baomidou.mybatisplus.core.toolkit.support.SFunction;
import com.baomidou.mybatisplus.core.toolkit.support.SerializedLambda;
import lombok.Data;

public class MybatisLambdaTest {
    @Data
    class Account {
        private int accountNumber;
        private String address;
    }

    public static void main(String[] args) {
        String s = lN(Account::getAddress);
        String acc = lN(Account::getAccountNumber);
        System.out.println(s);//address
        System.out.println(acc);//accountNumber
    }

    private static <T> String lN(SFunction<T, ?> func) {
        SerializedLambda resolve = LambdaUtils.resolve(func);
        String get = resolve.getImplMethodName().replace("get", "");
        get = get.substring(0, 1).toLowerCase() + get.substring(1);
        return get;
    }
}

另一种 实现方式：

import lombok.Data;
import lombok.extern.slf4j.Slf4j;

import java.io.*;
import java.lang.invoke.SerializedLambda;
import java.lang.reflect.Method;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

@Slf4j
public class MybatisLambdaTest {


    public static void main(String[] args) {
        String s = convertToFieldName(BrandVo::getBrandId);
        String acc = convertToFieldName(BrandVo::getBrandName);

        String s1 = convertToFieldName(BrandVo::setBrandId);
        System.out.println(s1);
        System.out.println(s);//address
        System.out.println(acc);//accountNumber
    }

    @Data
    public class BrandVo {
        private Long brandId;
        private String brandName;
    }

    /**
     * SerializedLambda 反序列化缓存
     */
    private static Map<Class, SerializedLambda> CLASS_LAMBDA_CACHE = new ConcurrentHashMap<>();

    /***
     * 转换方法引用为属性名
     * @param fn
     * @return
     */
    public static <T> String convertToFieldName(IGetter<T> fn) {
        SerializedLambda lambda = getSerializedLambda(fn);
        String methodName = lambda.getImplMethodName();
        String prefix = null;
        if (methodName.startsWith("get")) {
            prefix = "get";
        } else if (methodName.startsWith("is")) {
            prefix = "is";
        }
        if (prefix == null) {
            log.warn("无效的getter方法: " + methodName);
        }
        // 截取get/is之后的字符串并转换首字母为小写（S为diboot项目的字符串工具类，可自行实现）
        return toLowerCaseFirstOne(methodName.replace(prefix, ""));
    }

    private static String toLowerCaseFirstOne(String replace) {
        return replace.substring(0, 1).toLowerCase() + replace.substring(1);
    }

    public static <T, U> String convertToFieldName(ISetter<T, U> fn) {
        SerializedLambda lambda = getSerializedLambda(fn);
        String methodName = lambda.getImplMethodName();
        if (!methodName.startsWith("set")) {
            log.warn("无效的setter方法：" + methodName);
        }
        return toLowerCaseFirstOne(methodName.replace("set", ""));
    }

    /**
     * 关键在于这个方法
     */
    public static SerializedLambda getSerializedLambda(Serializable fn) {
        SerializedLambda lambda = CLASS_LAMBDA_CACHE.get(fn.getClass());
        if (lambda == null) {
            try {
                Method method = fn.getClass().getDeclaredMethod("writeReplace");
                method.setAccessible(Boolean.TRUE);
                lambda = (SerializedLambda) method.invoke(fn);
                CLASS_LAMBDA_CACHE.put(fn.getClass(), lambda);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return lambda;
    }

}

@FunctionalInterface
interface IGetter<T> extends Serializable {
    Object get(T source);
}

@FunctionalInterface
interface ISetter<T, U> extends Serializable {
    void set(T t, U u);
}