Different JSON Property Names During Serialization and Deserialization in Jackson Library

Introduction

In modern software development, JSON is widely used as a data exchange format. However, in practical projects, developers often encounter requirements for different field names during serialization and deserialization processes. For instance, using full property names in internal systems while requiring simplified field names in external APIs. Jackson, as the most popular JSON processing library in the Java ecosystem, provides flexible configuration options to address this challenge.

Problem Context

Consider a coordinate class Coordinates containing a red field. During deserialization, we want to read values from JSON data containing "red":12; during serialization, we want to output JSON data containing "r":12. This asymmetric naming requirement is quite common in real-world development scenarios.

Basic Solution

The most straightforward solution involves using @JsonProperty annotations on getter and setter methods with different property names specified. The key insight is that method names must be different, allowing Jackson to treat them as separate properties.

Complete implementation code:

public class Coordinates {
    byte red;

    @JsonProperty("r")
    public byte getR() {
        return red;
    }

    @JsonProperty("red")
    public void setRed(byte red) {
        this.red = red;
    }
}

In this implementation, the getR() method uses @JsonProperty("r") annotation to specify "r" as the field name during serialization, while the setRed() method uses @JsonProperty("red") annotation to specify "red" as the field name during deserialization. Since the method names differ, Jackson does not treat them as accessors for the same property.

Test Validation

To verify the solution's correctness, we developed comprehensive test code:

Coordinates c = new Coordinates();
c.setRed((byte) 5);

ObjectMapper mapper = new ObjectMapper();
System.out.println("Serialization: " + mapper.writeValueAsString(c));

Coordinates r = mapper.readValue("{\"red\":25}", Coordinates.class);
System.out.println("Deserialization: " + r.getR());

Test results:

Serialization: {"r":5}
Deserialization: 25

The output demonstrates that "r" is used as the field name during serialization, while "red" is successfully recognized during deserialization, validating the solution's effectiveness.

Supplementary Solution: @JsonAlias Annotation

Starting from Jackson 2.9.0, the @JsonAlias annotation provides an alternative approach. This annotation allows using aliases during deserialization while maintaining the original field name during serialization.

Example implementation:

public class Info {
    @JsonAlias({ "red" })
    public String r;
}

In this approach, field r uses "r" as the field name during serialization but can accept "red" as an alias during deserialization. Note that this method still allows "r" to be recognized during deserialization.

Comparison with Other JSON Libraries

In the .NET ecosystem's System.Text.Json library, similar functionality is achieved through the JsonPropertyName attribute, but this attribute uses the same name for both serialization and deserialization. For asymmetric naming requirements, .NET libraries require more complex custom converter implementations.

In contrast, Jackson achieves this functionality through simple annotation configurations, demonstrating its flexibility and powerful capabilities in JSON processing.

Best Practice Recommendations

When implementing asymmetric naming strategies in practical projects, consider the following best practices:

1. Maintain clear method naming to avoid maintenance difficulties caused by confusing method names
2. Establish unified naming conventions within teams to reduce unnecessary configurations
3. For complex naming mapping requirements, consider using custom serializers
4. Develop comprehensive unit tests to ensure correct serialization and deserialization behavior

Conclusion

The Jackson library, through flexible application of @JsonProperty annotations on getter and setter methods, effectively addresses the requirement for different property names during JSON serialization and deserialization. Combined with the supplementary functionality of @JsonAlias annotations, developers can choose the most appropriate solution based on specific scenarios. This flexibility makes Jackson a powerful tool for handling complex JSON serialization requirements.