Spring Boot REST API生成JSON时跳过Wrapper类子对象层级

下面提供几种实用的实现思路，适配Spring Boot常用的JSON序列化场景：

方法一：使用Jackson的@JsonUnwrapped注解（推荐，Spring Boot默认适配） #

Spring Boot默认采用Jackson作为JSON序列化工具，直接在Maximize类的子对象字段上添加@JsonUnwrapped注解，即可自动扁平化结构：

import com.fasterxml.jackson.annotation.JsonUnwrapped;

public class Maximize {
    @JsonUnwrapped
    private Profit profit;
    
    @JsonUnwrapped
    private Stats stats;
    
    // 构造器、getter、setter方法省略
}

该注解会告诉Jackson序列化时直接展开子对象的属性，自动去除profit和stats的层级包装，完全符合你需要的输出格式。

方法二：自定义Jackson序列化器（适配复杂场景） #

如果需要更灵活的序列化逻辑，可以自定义序列化器：

1. 编写自定义序列化类：

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

import java.io.IOException;

public class MaximizeSerializer extends StdSerializer<Maximize> {

    public MaximizeSerializer() {
        this(null);
    }

    public MaximizeSerializer(Class<Maximize> t) {
        super(t);
    }

    @Override
    public void serialize(Maximize maximize, JsonGenerator gen, SerializerProvider provider) throws IOException {
        // 直接写入Profit的属性
        gen.writeObjectField("request_ids", maximize.getProfit().getRequestIds());
        gen.writeNumberField("total_profit", maximize.getProfit().getTotalProfit());
        // 写入Stats的属性
        gen.writeNumberField("avg_night", maximize.getStats().getAvgNight());
        gen.writeNumberField("min_night", maximize.getStats().getMinNight());
        gen.writeNumberField("max_night", maximize.getStats().getMaxNight());
    }
}

2. 在Maximize类上指定使用该序列化器：

import com.fasterxml.jackson.databind.annotation.JsonSerialize;

@JsonSerialize(using = MaximizeSerializer.class)
public class Maximize {
    private Profit profit;
    private Stats stats;
    
    // 构造器、getter、setter方法省略
}

方法三：使用Gson自定义TypeAdapter（如果项目依赖Gson） #

如果项目使用Gson作为序列化工具，可通过自定义TypeAdapter实现扁平化：

1. 编写TypeAdapter类：

import com.google.gson.Gson;
import com.google.gson.TypeAdapter;
import com.google.gson.stream.JsonReader;
import com.google.gson.stream.JsonWriter;

import java.io.IOException;
import java.util.List;

public class MaximizeTypeAdapter extends TypeAdapter<Maximize> {
    @Override
    public void write(JsonWriter out, Maximize value) throws IOException {
        out.beginObject();
        // 写入Profit的属性
        out.name("request_ids");
        new Gson().getAdapter(List.class).write(out, value.getProfit().getRequestIds());
        out.name("total_profit").value(value.getProfit().getTotalProfit());
        // 写入Stats的属性
        out.name("avg_night").value(value.getStats().getAvgNight());
        out.name("min_night").value(value.getStats().getMinNight());
        out.name("max_night").value(value.getStats().getMaxNight());
        out.endObject();
    }

    @Override
    public Maximize read(JsonReader in) throws IOException {
        // 反序列化逻辑按需实现
        return null;
    }
}

2. 注册TypeAdapter到Gson实例：

Gson gson = new GsonBuilder()
    .registerTypeAdapter(Maximize.class, new MaximizeTypeAdapter())
    .create();
// 序列化时使用该Gson实例生成JSON
String json = gson.toJson(maximizeObject);

方法四：创建扁平化DTO（不修改原领域类） #

如果不想改动原Maximize领域类，可以创建专门的DTO用于返回数据：

import java.util.List;

public class MaximizeFlatDTO {
    private List<String> request_ids;
    private int total_profit;
    private int avg_night;
    private int min_night;
    private int max_night;
    
    // 通过Maximize对象初始化DTO
    public MaximizeFlatDTO(Maximize maximize) {
        this.request_ids = maximize.getProfit().getRequestIds();
        this.total_profit = maximize.getProfit().getTotalProfit();
        this.avg_night = maximize.getStats().getAvgNight();
        this.min_night = maximize.getStats().getMinNight();
        this.max_night = maximize.getStats().getMaxNight();
    }
    
    // getter、setter方法省略
}

在Controller中直接返回该DTO对象即可得到扁平化的JSON结构。

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