自定义REST API响应：移除Jackson序列化JSON属性名的优化方案

Let's break down how to fix the JSON format mismatch and clean up your Java class hierarchy to avoid unnecessary complexity.

Problem Recap #

Your frontend expects a nested array-only JSON structure (no property keys like plateFilterFluorescence), but your current Java class hierarchy is generating verbose, keyed JSON. We need two things:

1. Strip all property names during Jackson serialization
2. Simplify the overly nested class structure where possible

Approach 1: Use @JsonValue for Clean, Attribute-Free Serialization #

The @JsonValue annotation tells Jackson to serialize an object by directly outputting the value of a specific method/field, instead of wrapping it in the object's property keys. This is perfect for converting your nested objects into pure arrays.

Here's the refactored class structure:

1. FilterFluorescence.java (Map to [filter, value] array)

public class FilterFluorescence {
    private String filter;
    private Double fluorescence;

    // Constructor, getters, setters omitted

    // Convert to [filter-with-dash, fluorescence] array
    @JsonValue
    public Object[] toFlatArray() {
        // Replace underscore with hyphen to match frontend's "x1-m1" format
        return new Object[]{filter.replace("_", "-"), fluorescence};
    }
}

2. WellFilterFluorescence.java (Wrap filter data in an array)

public class WellFilterFluorescence {
    private List<FilterFluorescence> data;

    // Constructor, getters, setters omitted

    @JsonValue
    public List<Object[]> toNestedArray() {
        return data.stream()
                   .map(FilterFluorescence::toFlatArray)
                   .collect(Collectors.toList());
    }
}

3. PlateFilterFluorescence.java (Wrap well data in an array)

public class PlateFilterFluorescence {
    private List<WellFilterFluorescence> wellFilterFluorescence;

    // Constructor, getters, setters omitted

    @JsonValue
    public List<List<Object[]>> toDoubleNestedArray() {
        return wellFilterFluorescence.stream()
                   .map(WellFilterFluorescence::toNestedArray)
                   .collect(Collectors.toList());
    }
}

4. RawDataCurve.java (Final wrapper for the top-level array)

public class RawDataCurve {
    private List<PlateFilterFluorescence> plateFilterFluorescence;

    // Constructor, getters, setters omitted

    @JsonValue
    public List<List<List<Object[]>>> toTripleNestedArray() {
        return plateFilterFluorescence.stream()
                   .map(PlateFilterFluorescence::toDoubleNestedArray)
                   .collect(Collectors.toList());
    }
}

When you serialize a List<RawDataCurve> now, Jackson will output exactly the array-only format your frontend expects:

[ [ [ [ "x1-m1", 128650.3 ], [ "x2-m2", 19589.033 ] ] ], [ [ [ "x1-m1", 128640.3 ], [ "x2-m2", 19559.033 ] ] ] ]

Approach 2: Custom Serializer (For Minimal Class Changes) #

If you don't want to refactor your existing class hierarchy, create a custom Jackson serializer to manually build the nested array structure:

public class RawDataCurveSerializer extends StdSerializer<RawDataCurve> {

    public RawDataCurveSerializer() {
        super(RawDataCurve.class);
    }

    @Override
    public void serialize(RawDataCurve curve, JsonGenerator gen, SerializerProvider provider) throws IOException {
        gen.writeStartArray();
        for (PlateFilterFluorescence plate : curve.getPlateFilterFluorescence()) {
            gen.writeStartArray();
            for (WellFilterFluorescence well : plate.getWellFilterFluorescence()) {
                gen.writeStartArray();
                for (FilterFluorescence filter : well.getData()) {
                    gen.writeStartArray();
                    gen.writeString(filter.getFilter().replace("_", "-"));
                    gen.writeNumber(filter.getFluorescence());
                    gen.writeEndArray();
                }
                gen.writeEndArray();
            }
            gen.writeEndArray();
        }
        gen.writeEndArray();
    }
}

Then attach the serializer to your RawDataCurve class:

@JsonSerialize(using = RawDataCurveSerializer.class)
public class RawDataCurve {
    // Existing fields/methods
}

Bonus: Simplify Your Implementation #

If your business logic allows, you can eliminate unnecessary class layers entirely:

• Replace the nested RawDataCurve → PlateFilterFluorescence → WellFilterFluorescence hierarchy with a direct List<List<List<List<Object[]>>>> structure (each level maps to the array nesting).
• Use a utility class to convert your raw data into this nested array format directly, cutting out the middleman classes.

This will make your codebase leaner and reduce serialization overhead.

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