You need to enable JavaScript to run this app. 使用Jackson如何展开Java类所有嵌套变量并生成扁平化JSON?
优惠活动
大模型
产品
解决方案
定价
更多

使用Jackson如何展开Java类所有嵌套变量并生成扁平化JSON?

基于Jackson实现嵌套对象扁平化序列化的通用方案

不需要手动遍历实体、手动构建Map再序列化,通过自定义Jackson序列化模块的方式,可以零侵入实现全链路嵌套对象的字段平铺,完全兼容你现有的实体类定义。

核心实现逻辑

自定义序列化器的核心是递归遍历目标对象的所有字段,遵循以下处理规则:

  • 遇到基础类型、字符串、日期等可直接作为JSON值的原子类型,直接将字段名和值存入最终的结果Map
  • 遇到自定义POJO类型,继续递归钻取其内部字段,不保留原嵌套层级的key,直接将内部字段平铺到结果Map的根层级
  • 最终将收集完成的扁平Map序列化为JSON字符串,不需要在业务代码中手写任何对象遍历逻辑

完整可复用代码

import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.databind.*;
import com.fasterxml.jackson.databind.module.SimpleModule;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class FlatJsonSerializer {
    // 定义不需要递归展开的原子类型,可根据业务需求自行扩充
    private static final Set<Class<?>> ATOMIC_TYPES = Set.of(
        int.class, Integer.class,
        long.class, Long.class,
        double.class, Double.class,
        float.class, Float.class,
        boolean.class, Boolean.class,
        String.class,
        Date.class,
        java.time.LocalDate.class,
        java.time.LocalDateTime.class
    );

    /**
     * 获取配置好扁平化序列化逻辑的ObjectMapper实例
     */
    public static ObjectMapper getFlatMapper() {
        ObjectMapper mapper = new ObjectMapper();
        SimpleModule flatModule = new SimpleModule();
        // 注册通用的扁平化序列化逻辑,对所有未被特殊处理的POJO生效
        flatModule.addSerializer(Object.class, new JsonSerializer<Object>() {
            @Override
            public void serialize(Object value, JsonGenerator gen, SerializerProvider serializers) throws java.io.IOException {
                Map<String, Object> flatResult = new HashMap<>();
                flattenObject(value, flatResult);
                gen.writeObject(flatResult);
            }
        });
        mapper.registerModule(flatModule);
        // 关闭字段可见性限制,支持反射读取所有私有字段
        mapper.setVisibility(PropertyAccessor.FIELD, JsonAutoDetect.Visibility.ANY);
        return mapper;
    }

    /**
     * 递归展开对象字段,平铺到结果Map中
     */
    private static void flattenObject(Object target, Map<String, Object> resultMap) {
        if (target == null || ATOMIC_TYPES.contains(target.getClass())) {
            return;
        }
        Class<?> clazz = target.getClass();
        for (Field field : clazz.getDeclaredFields()) {
            // 跳过静态字段
            if (Modifier.isStatic(field.getModifiers())) {
                continue;
            }
            field.setAccessible(true);
            try {
                Object fieldValue = field.get(target);
                if (fieldValue == null) {
                    resultMap.put(field.getName(), null);
                    continue;
                }
                // 原子类型直接存入,非原子类型递归展开
                if (ATOMIC_TYPES.contains(fieldValue.getClass())) {
                    resultMap.put(field.getName(), fieldValue);
                } else {
                    flattenObject(fieldValue, resultMap);
                }
            } catch (IllegalAccessException e) {
                throw new RuntimeException("读取对象字段失败", e);
            }
        }
    }
}

实际使用示例

完全不需要修改你现有定义的A、B类代码,直接调用工具类获取Mapper序列化实例即可:

// 原有实体类定义
class A {
   int a1;
   double a2;
   public A(int a1, double a2) {
      this.a1 = a1;
      this.a2 = a2;
   }
}
class B {
   String b1;
   A a;
   public B(A a, String b1) {
      this.a = a;
      this.b1 = b1;
   }
}

// 序列化测试
public class SerializeTest {
    public static void main(String[] args) throws Exception {
        B b = new B(new A(1, 2.5), "test");
        ObjectMapper flatMapper = FlatJsonSerializer.getFlatMapper();
        String resultJson = flatMapper.writeValueAsString(b);
        // 输出结果: {"a1":1,"a2":2.5,"b1":"test"},和你期望的扁平化结构完全一致
        System.out.println(resultJson);
    }
}

可扩展调整点

  • 字段冲突处理:如果存在不同嵌套层级的重名字段,默认逻辑会以后遍历到的字段值覆盖原有值。如果需要避免冲突,只要在递归时拼接当前字段路径作为key(比如把A类的字段存为a.a1)即可,完全可以按需调整。
  • 父类字段支持:当前实现仅遍历当前类的声明字段,如果需要展开父类继承的字段,只要在flattenObject方法中增加循环向上遍历父类字段的逻辑即可。
  • 集合类型支持:如果实体中存在List、Map等集合类型,只要在flattenObject方法中增加对应的分支判断,即可实现集合元素的平铺逻辑。

内容的提问来源于stack exchange,提问作者loveyzhou

相关产品推荐
方舟 Agent Plan

超全模态模型 × Harness 升级,最新支持 Deepseek-V4.1-Flash、GLM-5.3 系列、Doubao-Seedream-5.0-pro、Kimi-K3 (部分), 限时 9.9 元起

最近更新时间:2026.11.10 22:24:03