无需转为Map，如何递归更新对象并原地替换嵌套字符串？

我尝试通过以下代码递归替换对象中的所有嵌套字符串，该方案虽能运行，但替换后原对象未发生变化——推测是因为将CustomResponse类型的原对象转为Map导致的。目前我必须先转为Map才能进行遍历，但希望找到无需转Map的实现方式。CustomResponse仅为示例，实际会传入多种类似对象，因此需要通用的对象处理逻辑，而非针对特定类编写代码。另外要求不创建新对象，尽量实现原地替换。

当前代码如下：

import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;

import java.util.List;
import java.util.Map;

private static ObjectMapper MAPPER = new ObjectMapper();

@SuppressWarnings("unchecked")
public void parse(Object obj) {
    if (obj instanceof List) {
        List<Object> arr = (List<Object>) obj;
        for (int i = 0; i < arr.size(); i++) {
            Object o = arr.get(i);
            if (o instanceof String) {
                String str = (String) o;
                arr.set(i, str + " atest");
            } else {
                parse(o);
            }
        }
    } else if (obj instanceof Map) {
        Map<Object, Object> map = (Map<Object, Object>) obj;
        for (Map.Entry<Object, Object> entry : map.entrySet()) {
            Object o = entry.getValue();
            if (o instanceof String) {
                String str = (String) o;
                entry.setValue(str + " atest");
            } else {
                parse(o);
            }
        }
    } else if (obj instanceof CustomResponse) {
        // 这里的逻辑大概率是问题所在
        Map<Object, Object> map = MAPPER.convertValue(obj, new TypeReference<Map<Object, Object>>() {});
        parse(map);
    }
}

我还考虑过使用反射实现，但感觉过于繁琐：

else if (obj instanceof CustomResponse) {
    Field[] fields = obj.getClass().getDeclaredFields();
    for (Field field : fields) {
        field.setAccessible(true);
        Object fieldValue = field.get(obj);
        if (fieldValue instanceof String) {
            String str = (String) fieldValue;
            field.set(obj, str + " atest");
        } else {
            parse(fieldValue);
        }
    }
}

请问如何实现无需转为Map的递归原地更新对象中嵌套字符串的通用方案？

要实现通用的原地替换，反射是唯一可行的通用方案——你之前的反射代码只针对CustomResponse，只需要把它改成通用处理任意非集合、非字符串的对象即可，同时优化反射逻辑来覆盖更多场景（比如父类字段、排除静态/transient字段等）。

核心思路 #

1. 保留原有对List和Map的处理逻辑，因为它们本身是可修改的集合类型
2. 对于普通Java对象（非集合、非字符串），用反射遍历其所有字段（包括父类字段）
3. 对每个字段的值递归处理：如果是字符串则原地修改，否则继续递归解析
4. 跳过静态字段、transient字段，避免修改不必要的内容

完整实现代码 #

import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.util.List;
import java.util.Map;

@SuppressWarnings("unchecked")
public void parse(Object obj) {
    if (obj == null) {
        return;
    }
    
    // 处理List集合
    if (obj instanceof List) {
        List<Object> arr = (List<Object>) obj;
        for (int i = 0; i < arr.size(); i++) {
            Object o = arr.get(i);
            if (o instanceof String) {
                arr.set(i, ((String) o) + " atest");
            } else {
                parse(o);
            }
        }
    } 
    // 处理Map集合
    else if (obj instanceof Map) {
        Map<Object, Object> map = (Map<Object, Object>) obj;
        for (Map.Entry<Object, Object> entry : map.entrySet()) {
            Object o = entry.getValue();
            if (o instanceof String) {
                entry.setValue(((String) o) + " atest");
            } else {
                parse(o);
            }
        }
    } 
    // 处理普通字符串（边界情况，避免递归）
    else if (obj instanceof String) {
        // 注意：字符串是不可变类型，这里无法原地修改，只能在调用层替换
        // 但因为我们是从集合/对象字段过来的，已经在父层处理了替换，这里无需操作
    } 
    // 处理普通Java对象（通用逻辑，不再针对特定类）
    else {
        Class<?> clazz = obj.getClass();
        // 遍历当前类及所有父类的字段
        while (clazz != null && clazz != Object.class) {
            Field[] fields = clazz.getDeclaredFields();
            for (Field field : fields) {
                // 跳过静态字段和transient字段
                if (Modifier.isStatic(field.getModifiers()) || Modifier.isTransient(field.getModifiers())) {
                    continue;
                }
                try {
                    field.setAccessible(true);
                    Object fieldValue = field.get(obj);
                    if (fieldValue instanceof String) {
                        // 原地修改字段值
                        field.set(obj, ((String) fieldValue) + " atest");
                    } else {
                        // 递归处理嵌套对象/集合
                        parse(fieldValue);
                    }
                } catch (IllegalAccessException e) {
                    // 处理访问异常，可根据需求调整日志或抛出
                    e.printStackTrace();
                }
            }
            // 向上遍历父类
            clazz = clazz.getSuperclass();
        }
    }
}

关键优化点说明 #

• 通用对象处理：不再判断特定类，只要是普通Java对象就用反射处理，满足你对多种类型的需求
• 父类字段覆盖：通过while (clazz != null && clazz != Object.class)遍历当前类和所有父类的字段，避免遗漏父类中的字符串字段
• 字段过滤：跳过静态和transient字段，符合常规Java对象的序列化/修改逻辑，避免修改不必要的内容
• 原地修改：直接通过field.set(obj, ...)修改原对象的字段值，完全不需要转Map或创建新对象
• 空值处理：开头增加obj == null的判断，避免空指针异常

注意事项 #

• 字符串是Java中的不可变类型，所以我们无法直接修改字符串本身，但通过修改集合元素或对象字段的引用，实现了"原地替换"的效果
• 如果对象中有final字段，反射无法修改，需要根据业务需求决定是否跳过或抛出异常
• 对于一些特殊类型（比如枚举、第三方不可修改的对象），需要根据实际情况补充判断逻辑

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