Java中如何不使用反射动态获取模型字段的根到叶路径？

完全可以做到，以下是两种类型安全、无反射的实现方式：

方式一：通过方法引用解析路径 #

利用Java方法引用的字符串特征，结合自定义工具类解析出属性路径，全程编译期检查，无运行时反射开销。

步骤1：定义函数式接口与工具类 #

@FunctionalInterface
interface PropertyPath<T, R> {
    R get(T source);
}

class PropertyPathUtil {
    // 解析单层属性路径
    public static <T, R> String getPath(PropertyPath<T, R> pathFunc) {
        String funcStr = pathFunc.toString();
        String methodName = funcStr.split("::")[1];
        
        // 处理Getter方法（如getAddress → address）
        if (methodName.startsWith("get")) {
            methodName = methodName.substring(3);
            methodName = Character.toLowerCase(methodName.charAt(0)) + methodName.substring(1);
        }
        return methodName;
    }

    // 解析嵌套属性路径
    public static <T, U, R> String getNestedPath(PropertyPath<T, U> first, PropertyPath<U, R> second) {
        return getPath(first) + "." + getPath(second);
    }
}

步骤2：补充实体类的Getter方法 #

原代码中Student.address为私有属性，需添加Getter才能通过方法引用访问：

class Student {
    private Address address;
    private String name;

    public Address getAddress() {
        return address;
    }
}

class Address {
    String pin;
    String doorNo;

    public String getPin() {
        return pin;
    }

    public String getDoorNo() {
        return doorNo;
    }
}

步骤3：使用示例 #

public class Demo {
    public static void main(String[] args) {
        // 获取address路径
        PropertyPath<Student, Address> addressPath = Student::getAddress;
        System.out.println(PropertyPathUtil.getPath(addressPath)); // 输出: address

        // 获取address.pin路径
        PropertyPath<Address, String> pinPath = Address::getPin;
        System.out.println(PropertyPathUtil.getNestedPath(addressPath, pinPath)); // 输出: address.pin

        // 获取address.doorNo路径
        PropertyPath<Address, String> doorNoPath = Address::getDoorNo;
        System.out.println(PropertyPathUtil.getNestedPath(addressPath, doorNoPath)); // 输出: address.doorNo
    }
}

方式二：手动绑定路径字符串（更灵活） #

如果不想依赖方法引用的字符串解析，可以直接在定义属性路径时手动指定路径，同样保持类型安全：

步骤1：增强函数式接口 #

import java.util.function.Function;

@FunctionalInterface
interface PropertyPath<T, R> {
    R get(T source);

    // 静态方法：创建带路径的属性访问器
    static <T, R> PropertyPath<T, R> of(String path, Function<T, R> getter) {
        return new PropertyPath<T, R>() {
            @Override
            public R get(T source) {
                return getter.apply(source);
            }

            @Override
            public String toString() {
                return path;
            }
        };
    }
}

步骤2：使用示例 #

public class Demo {
    public static void main(String[] args) {
        PropertyPath<Student, Address> addressPath = PropertyPath.of("address", Student::getAddress);
        PropertyPath<Address, String> pinPath = PropertyPath.of("pin", Address::getPin);
        PropertyPath<Address, String> doorNoPath = PropertyPath.of("doorNo", Address::getDoorNo);

        System.out.println(addressPath + "." + pinPath); // 输出: address.pin
        System.out.println(addressPath + "." + doorNoPath); // 输出: address.doorNo
    }
}

方案优势 #

• 完全不使用反射，避免反射带来的性能问题与运行时风险；
• 所有属性访问在编译期完成校验，不存在“属性不存在”的运行时错误；
• 代码风格简洁，符合Java函数式编程规范。

内容的提问来源于stack exchange，提问作者Mudassarnazar Nagori