如何基于Java POJO生成包含所有字段的示例JSON结构？

我想要开发一个工具，能够根据任意给定的POJO生成示例JSON结构，要求：

• 即使子对象为null也保留所有字段名
• 字符串字段用空串""而非null
• 集合类型包含一个空元素示例

我创建了以下三个示例POJO：

public class Model {
    private String val1;
    private Child child;
    // getters and setters
}

public class Child {
    private String val2;
    private ArrayList<SubChild> subChildren;
    // getters and setters
}

public class SubChild {
    private String val3;
    // getters and setters
}

期望的目标输出为：

{
  "val1" : "",
  "child" : {
    "val2" : "",
    "subChildren" : [
      {
        "val3" : ""
      }
    ]
  }
}

我尝试了Jackson和Gson的序列化方法，但输出未达预期：

Jackson实现： #

ObjectMapper map = new ObjectMapper().setSerializationInclusion(Include.ALWAYS);
Model testModel = new Model();
map.writerWithDefaultPrettyPrinter().writeValueAsString(testModel);

输出：

{
  "val1" : null,
  "child" : null
}

Gson实现： #

Gson gson = new GsonBuilder().serializeNulls().setPrettyPrinting().create();
Model testModel = new Model();
gson.toJson(testModel);

输出：

{
  "val1" : null,
  "child" : null
}

请问是否有无需手动填充子字段的简便实现方式？希望该工具能支持泛型类，无需知晓填充对象的具体结构。

很高兴帮你解决这个问题！要实现自动生成包含所有字段的示例JSON，核心是先把POJO的所有字段都初始化到位（字符串设为空串、集合添加空元素、子对象实例化），再进行序列化。因为Jackson和Gson默认只会处理已赋值的字段，未初始化的引用类型都是null，直接序列化自然达不到你的要求。下面给你两种实用的实现方式：

方式一：自定义反射初始化工具类 #

你可以写一个通用的反射工具类，递归遍历POJO的所有字段，根据字段类型自动填充默认值。这种方式灵活可控，支持泛型，不用关心具体POJO的结构：

import java.lang.reflect.Field;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.Collection;

public class PojoInitializer {

    @SuppressWarnings("unchecked")
    public static <T> T initialize(Class<T> clazz) throws Exception {
        // 实例化当前类（需要无参构造）
        T instance = clazz.getDeclaredConstructor().newInstance();
        
        // 遍历所有字段
        for (Field field : clazz.getDeclaredFields()) {
            field.setAccessible(true);
            Class<?> fieldType = field.getType();
            
            if (fieldType == String.class) {
                // 字符串字段设为空串
                field.set(instance, "");
            } else if (Collection.class.isAssignableFrom(fieldType)) {
                // 集合类型：初始化集合并添加一个空元素
                Collection<Object> collection = (Collection<Object>) fieldType.getDeclaredConstructor().newInstance();
                // 获取集合的泛型元素类型，递归初始化
                Type genericType = field.getGenericType();
                if (genericType instanceof ParameterizedType) {
                    Type elementType = ((ParameterizedType) genericType).getActualTypeArguments()[0];
                    if (elementType instanceof Class) {
                        Object elementInstance = initialize((Class<?>) elementType);
                        collection.add(elementInstance);
                    }
                }
                field.set(instance, collection);
            } else if (!fieldType.isPrimitive() && !fieldType.isEnum() && !fieldType.isArray()) {
                // 引用类型（非基本类型、枚举、数组）：递归初始化子对象
                Object childInstance = initialize(fieldType);
                field.set(instance, childInstance);
            }
            // 基本类型（int、boolean等）会有默认值，无需额外处理
        }
        
        return instance;
    }
}

然后结合Jackson使用就行：

ObjectMapper mapper = new ObjectMapper().setSerializationInclusion(JsonInclude.Include.ALWAYS);
// 先初始化POJO的所有字段
Model initializedModel = PojoInitializer.initialize(Model.class);
// 序列化得到目标JSON
String json = mapper.writerWithDefaultPrettyPrinter().writeValueAsString(initializedModel);
System.out.println(json);

运行这段代码就能得到你期望的JSON输出，而且不管是嵌套对象还是泛型集合都能处理。

方式二：用Jackson自定义序列化器 #

如果你不想自己写反射逻辑，可以通过Jackson的扩展机制，自定义序列化器来自动处理null字段，在序列化时自动填充默认值：

import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.databind.*;
import com.fasterxml.jackson.databind.ser.BeanSerializerModifier;
import com.fasterxml.jackson.databind.ser.std.StdSerializer;

import java.io.IOException;
import java.lang.reflect.Field;

public class DefaultValueSerializerModifier extends BeanSerializerModifier {

    @Override
    public JsonSerializer<?> modifySerializer(SerializationConfig config, BeanDescription beanDesc, JsonSerializer<?> serializer) {
        return new DefaultValueSerializer((JsonSerializer<Object>) serializer);
    }

    private static class DefaultValueSerializer extends StdSerializer<Object> {
        private final JsonSerializer<Object> delegate;

        public DefaultValueSerializer(JsonSerializer<Object> delegate) {
            super(Object.class);
            this.delegate = delegate;
        }

        @Override
        public void serialize(Object value, JsonGenerator gen, SerializerProvider provider) throws IOException {
            if (value == null) {
                try {
                    // 如果当前字段是null，获取它的类型并初始化
                    Field field = gen.getCurrentValue().getClass().getDeclaredField(gen.getOutputContext().getCurrentName());
                    field.setAccessible(true);
                    Object initialized = PojoInitializer.initialize(field.getType());
                    delegate.serialize(initialized, gen, provider);
                } catch (Exception e) {
                    // 初始化失败的话， fallback到默认序列化
                    delegate.serialize(value, gen, provider);
                }
            } else {
                delegate.serialize(value, gen, provider);
            }
        }
    }
}

然后配置Jackson使用这个Modifier：

ObjectMapper mapper = new ObjectMapper();
mapper.setSerializationInclusion(JsonInclude.Include.ALWAYS);
// 注册自定义序列化器
mapper.registerModule(new SimpleModule()
        .setSerializerModifier(new DefaultValueSerializerModifier()));

// 直接用空的POJO就行，序列化时会自动填充字段
Model testModel = new Model();
String json = mapper.writerWithDefaultPrettyPrinter().writeValueAsString(testModel);
System.out.println(json);

这种方式更贴合Jackson的生态，不需要提前手动初始化POJO，序列化过程中自动处理null字段。

注意事项 #

1. 所有POJO必须有无参构造函数，反射初始化时需要用到；
2. 如果你的POJO里有枚举类型，可以在反射工具类里加个判断，把枚举字段设为第一个枚举值；
3. 对于一些特殊的集合类型（比如自定义集合），可以扩展反射工具类的集合处理逻辑。

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