如何通过反射获取组合关系类中嵌套类的字段名称？

当然有可行的方案！这种需要展开嵌套组合类字段的场景，核心思路就是递归遍历类的反射结构，把嵌套属性扁平化（比如author.name这种格式）。下面给你几种实用的实现方式：

1. 手动实现递归反射工具类 #

这是最灵活的方案，完全自定义逻辑，不需要依赖第三方库。关键是处理递归遍历和循环引用的问题：

import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.List;
import java.util.Set;
import java.util.HashSet;

public class FlattenedFieldUtils {
    // 记录已处理的类，防止循环引用导致栈溢出
    private static final Set<Class<?>> processedClasses = new HashSet<>();

    // 对外暴露的方法：获取所有扁平化的字段路径
    public static List<String> getFlattenedFieldNames(Class<?> rootClass) {
        List<String> fieldNames = new ArrayList<>();
        if (processedClasses.contains(rootClass)) {
            return fieldNames;
        }
        processedClasses.add(rootClass);

        // 遍历当前类的所有声明字段
        for (Field field : rootClass.getDeclaredFields()) {
            field.setAccessible(true);
            Class<?> fieldType = field.getType();

            // 判断是否需要展开这个字段的嵌套结构
            if (shouldExpandField(fieldType)) {
                // 递归获取嵌套类的字段，拼接路径
                List<String> nestedFields = getFlattenedFieldNames(fieldType);
                for (String nestedField : nestedFields) {
                    fieldNames.add(field.getName() + "." + nestedField);
                }
            } else {
                // 普通字段直接加入列表
                fieldNames.add(field.getName());
            }
        }

        processedClasses.remove(rootClass);
        return fieldNames;
    }

    // 自定义判断逻辑：哪些类型需要展开（可根据业务调整）
    private static boolean shouldExpandField(Class<?> clazz) {
        // 排除基本类型、包装类、String、集合、数组等不需要展开的类型
        return !clazz.isPrimitive()
                && !isWrapperType(clazz)
                && !clazz.equals(String.class)
                && !clazz.isArray()
                && !Iterable.class.isAssignableFrom(clazz);
    }

    // 判断是否是基本类型的包装类
    private static boolean isWrapperType(Class<?> clazz) {
        return clazz.equals(Integer.class) || clazz.equals(Long.class) || clazz.equals(Double.class)
                || clazz.equals(Float.class) || clazz.equals(Boolean.class) || clazz.equals(Character.class)
                || clazz.equals(Byte.class) || clazz.equals(Short.class);
    }
}

使用示例 #

调用工具类就能直接拿到扁平化的列名：

public class Main {
    public static void main(String[] args) {
        List<String> csvColumns = FlattenedFieldUtils.getFlattenedFieldNames(Book.class);
        // 输出结果：[title, author.name, author.age]
        System.out.println(csvColumns);
    }
}

2. 借助第三方工具库快速实现 #

如果不想自己写递归逻辑，可以用成熟的工具库来简化开发，比如Apache Commons BeanUtils：

它的PropertyUtils.describe()方法会自动遍历所有嵌套属性，返回一个包含属性路径和对应值的Map：

import org.apache.commons.beanutils.PropertyUtils;
import java.util.Map;

public class CsvHelper {
    public static void main(String[] args) throws Exception {
        // 先实例化一个测试对象（实际场景可以是任意Book实例）
        Book book = new Book();
        Author author = new Author();
        author.setName("J.K.Rowling");
        author.setAge(58);
        book.setTitle("Harry Potter");
        book.setAuthor(author);

        // 获取所有扁平化属性
        Map<String, Object> properties = PropertyUtils.describe(book);
        // 排除默认的"class"属性
        properties.remove("class");
        
        // 打印所有列名
        properties.keySet().forEach(System.out::println);
        // 输出：title, author.name, author.age
    }
}

注意：需要在项目中引入commons-beanutils的依赖（比如Maven/Gradle），这个方法依赖类的getter方法，所以要确保嵌套类（比如Author）有对应的getName()、getAge()方法。

3. 自定义注解精准控制展开范围 #

如果只需要展开特定的嵌套字段，而不是所有组合类，可以用自定义注解来标记需要展开的字段：

第一步：定义注解 #

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface ExpandNested {
}

第二步：标记需要展开的字段 #

public class Book { 
    private String title; 
    // 标记这个字段需要展开
    @ExpandNested
    private Author author; 
}

第三步：修改工具类逻辑 #

在递归遍历的时候，只处理带有@ExpandNested注解的字段：

// 在getFlattenedFieldNames方法中修改判断逻辑
if (field.isAnnotationPresent(ExpandNested.class) && shouldExpandField(fieldType)) {
    List<String> nestedFields = getFlattenedFieldNames(fieldType);
    for (String nestedField : nestedFields) {
        fieldNames.add(field.getName() + "." + nestedField);
    }
} else {
    fieldNames.add(field.getName());
}

这样就能精准控制哪些嵌套类需要展开，避免不必要的遍历。

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