奥丁9

后端
- 数据库
  - redis
  - mysql
  - mongoDB
  - 达梦
- php
  - laravel
    - laravel-admin
    - dcat
      - 表单
      - 表格
- java
  - spring
- python
- go
- c
- c++
前端
- vue
- nodejs
- sass/less
- html/css
- 前端框架
- javascript
- 微信生态
  - 公众号
  - 小程序
- uniapp
- typescript
其他
- AI
- 数据结构
- 安全
- linux
- seo
- git
- 健身
- 算法
- 正则表达式
- docker
待分类

后端 / java / spring

使用LambdaQuery()有感-通过函数式接口获取字段名称

5个月前 aoding9 16

原文：https://blog.csdn.net/Mr1ght/article/details/124815342
# 背景
在平时使用mybatis-plus的时候，通常会使用下面两种方式

1.lambdaQuery()方式：
```java
List<Person> persons = lambdaQuery()
    .eq(Person::getName,"zhangsan")
    .eq(Person::getAge,11)
    .list();
```
2.普通QueryWrapper的方式
```java
List<Person> persons = baseMapper.selectList(new QueryWrapper<Person>()
                                               .eq("name","zhangsan")
                                               .eq("age",11));
```
这两种方式对比我可能更喜欢使用lambdaQuery()那种方式，因为如果实体类里面的字段有更改的话，不需要单独取维护分布在各个地方的字符串，只需要字段本身就可以。那么就想到去定义一个工具类，让这种函数式接口方式取代很多直接定义字符串名称的场景。
# 工具类定义
定义一个实现Serializable的函数式接口（不实现Serializable的话，后面getDeclaredMethod("writeReplace")会获取不到）
```java
import net.oschina.j2cache.util.Serializer;

import java.io.Serializable;
import java.util.function.Function;

/**
 * 序列化的function函数式接口
 *
 */
@FunctionalInterface
public interface SerializedFunction<T, R> extends Function<T, R>, Serializable {
}
```
定义LambdaUtil
```java
import java.beans.Introspector;
import java.lang.invoke.SerializedLambda;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Locale;

/**
 * lambda工具类
 *
 */
public class LambdaUtil {

/**
     * 传入lambda表达式获取其字段名称
     * <pre>
     *     例如传入Person::getName 返回：name
     *        传入Person::getAge 返回: age
     * </pre>
     *
     * @param sFunction
     * @param <T>
     * @return
     */
    public static <T> String getFiledName(SerializedFunction<T, ?> sFunction) {
        try {
            Method method = sFunction.getClass().getDeclaredMethod("writeReplace");
            method.setAccessible(Boolean.TRUE);
            //调用writeReplace()方法，返回一个SerializedLambda对象
            SerializedLambda serializedLambda = (SerializedLambda) method.invoke(sFunction);
            //得到lambda表达式中调用的方法名，如 "User::getSex"，则得到的是"getSex"
            String getterMethod = serializedLambda.getImplMethodName();
            //去掉”get"前缀，最终得到字段名“sex"
            return Introspector.decapitalize(methodToProperty(getterMethod));
        } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) {
            throw new IllegalArgumentException("Cannot get filedName by function", e);
        }
    }

/**
     * 通过readMethod名称获取字段名称
     *
     * @param fieldName
     * @return
     */
    public static String methodToProperty(String fieldName) {
        if (fieldName.startsWith("is")) {
            fieldName = fieldName.substring(2);
        } else if (fieldName.startsWith("get") || fieldName.startsWith("set")) {
            fieldName = fieldName.substring(3);
        } else {
            throw new IllegalArgumentException("Error parsing property name '" + fieldName + "'.  Didn't start with 'is', 'get' or 'set'.");
        }

if (fieldName.length() == 1 || (fieldName.length() > 1 && !Character.isUpperCase(fieldName.charAt(1)))) {
            fieldName = fieldName.substring(0, 1).toLowerCase(Locale.ENGLISH) + fieldName.substring(1);
        }

return fieldName;
    }
}
```

# 测试
```java
import lombok.Data;

/**
 * 用户类
 */
@Data
public class Person {
    private String name;
    private Integer age;
    private String alias;
}
```
定义main方法运行
```java
    public static void main(String[] args) {
        System.out.println(LambdaUtil.getFiledName(Person::getName));
        System.out.println(LambdaUtil.getFiledName(Person::getAge));
        System.out.println(LambdaUtil.getFiledName(Person::getAlias));
    }
```
运行结果如下
![](https://aoding9.0736tw.com/uploads/images/2024-10-22/08bb83bfa2fd364bd78566e5c0d01d1767179258c5fae.png)

本作品采用《CC 协议》，转载必须注明作者和本文链接