获取类下所有的字段包括父类和嵌套类

获取类下所有字段

import org.json.JSONObject;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.concurrent.CopyOnWriteArrayList;
import xyz.adscope.amps.tool.AMPSLogUtil;
public class tool {

    /**
     * 带深度限制的递归遍历
     */
    public static void traverseWithDepthLimit(Object object) {
        traverseWithDepthLimit(object, 0, new HashSet<Object>(), 5); // 最大深度5层
    }

    private static void traverseWithDepthLimit(Object obj, int currentDepth, Set<Object> visited, int maxDepth) {
        if (obj == null || currentDepth > maxDepth) {
            return;
        }

        if (visited.contains(obj)) {
            return;
        }
        visited.add(obj);

        Class<?> clazz = obj.getClass();

        if (isBasicType(clazz) || isSystemClass(clazz)) {
            return;
        }

        for (Field field : getAllFields(clazz)) {
            try {
                field.setAccessible(true);
                Object fieldValue = field.get(obj);

                if (fieldValue != null && !isBasicType(fieldValue.getClass())) {
                    if (field.getType().getSimpleName().equals("CopyOnWriteArrayList")) {
                        Log.d("LOG", "jsonString" + " = " + fieldValue.getClass().getName());
                        CopyOnWriteArrayList<?> list = (CopyOnWriteArrayList<?>) fieldValue;
                        Object firstElement = list.get(0);

                        for (Field field1 : getSuperclassFields(firstElement)){
                            if (field1.getType().getSimpleName().equals("String")){
                                field1.setAccessible(true);
                                String jsonString = (String) field1.get(firstElement);
                                if (jsonString != null && !jsonString.isEmpty()){
                                    JSONObject json = new JSONObject(jsonString);

                                    if (json.has("bidding_rit_cpm")) {
                                        Object value = json.get("bidding_rit_cpm");

                                        if (value instanceof Double) {
                                            double doubleValue = (Double) value;
                                            AMPSLogUtil.d("LOG", "jsonString" + " = " + doubleValue );
                                        } else if (value instanceof Integer) {
                                            int intValue = (Integer) value;
                                            Log.d("LOG", "jsonString" + " = " + intValue );
                                        }
                                    }
                                }
                            }

                        }

                    }
                    traverseWithDepthLimit(fieldValue, currentDepth + 1, visited, maxDepth);
                }

            } catch (Exception e) {
                Log.d("LOG",  "------" + field.getName() + " [错误]" + e);
            }
        }
    }

    /**
     * 判断是否为系统类
     */
    private static boolean isSystemClass(Class<?> clazz) {
        return clazz.getName().startsWith("java.") ||
                clazz.getName().startsWith("android.");
    }

    /**
     * 获取类的所有字段（包括父类）
     */
    private static Field[] getAllFields(Class<?> clazz) {
        List<Field> fieldList = new ArrayList<>();
        while (clazz != null && clazz != Object.class) {
            Collections.addAll(fieldList, clazz.getDeclaredFields());
            clazz = clazz.getSuperclass();
        }
        return fieldList.toArray(new Field[0]);
    }

    /**
     * 判断是否为基本类型或常用类型
     */
    private static boolean isBasicType(Class<?> clazz) {
        return clazz.isPrimitive() ||
                clazz == String.class ||
                clazz == Integer.class ||
                clazz == Long.class ||
                clazz == Double.class ||
                clazz == Float.class ||
                clazz == Boolean.class ||
                clazz == Character.class ||
                clazz == Byte.class ||
                clazz == Short.class;
    }

    public static List<Field> getSuperclassFields(Object obj) {
        List<Field> fields = new ArrayList<>();
        Class<?> currentClass = obj.getClass().getSuperclass();

        // 向上遍历父类链
        while (currentClass != null && currentClass != Object.class) {
            Field[] declaredFields = currentClass.getDeclaredFields();
            for (Field field : declaredFields) {
                fields.add(field);
            }
            currentClass = currentClass.getSuperclass();
        }
        return fields;
    }
}