Jackson Enum Serialization and Deserialization: Complete Solution with @JsonCreator and @JsonValue

Problem Background of Enum Serialization and Deserialization

In Java development, JSON serialization and deserialization of enum types is a common requirement. The Jackson library provides various annotations to simplify this process, but developers often encounter inconsistencies between serialization and deserialization in practical usage.

Analysis of @JsonValue Annotation Limitations

In initial implementations, developers typically use the @JsonValue annotation to specify the serialization format for enums. For example:

public enum Event {
    FORGOT_PASSWORD("forgot password");

    private final String value;

    private Event(final String description) {
        this.value = description;
    }

    @JsonValue
    final String value() {
        return this.value;
    }
}

This implementation successfully serializes the enum into the specified string value, but encounters problems during deserialization. Jackson defaults to using the enum's name() method for deserialization and cannot recognize custom string values, resulting in JsonMappingException errors.

Complete Self-Contained Solution

To resolve this issue, we need to handle both serialization and deserialization directions simultaneously. Here is the complete implementation based on @JsonCreator and @JsonValue annotations:

public enum DeviceScheduleFormat {
    Weekday,
    EvenOdd,
    Interval;

    private static Map<String, DeviceScheduleFormat> namesMap = new HashMap<String, DeviceScheduleFormat>(3);

    static {
        namesMap.put("weekday", Weekday);
        namesMap.put("even-odd", EvenOdd);
        namesMap.put("interval", Interval);
    }

    @JsonCreator
    public static DeviceScheduleFormat forValue(String value) {
        return namesMap.get(StringUtils.lowerCase(value));
    }

    @JsonValue
    public String toValue() {
        for (Entry<String, DeviceScheduleFormat> entry : namesMap.entrySet()) {
            if (entry.getValue() == this)
                return entry.getKey();
        }
        return null;
    }
}

In-Depth Analysis of Implementation Principles

The core of this solution lies in establishing a bidirectional mapping table:

• Static Mapping Table Initialization: Establishes the mapping relationship from strings to enum values in the static code block
• @JsonCreator Method: Responsible for converting input string values to corresponding enum instances
• @JsonValue Method: Responsible for converting enum instances back to corresponding string representations

This approach ensures consistency between serialization and deserialization while maintaining the self-contained nature of the enum class.

Simplified Solution for Jackson 2.6+

Starting from Jackson 2.6.2, a more concise solution is available:

public enum Event {
    @JsonProperty("forgot password")
    FORGOT_PASSWORD;
}

This method uses the @JsonProperty annotation directly on enum constants, simplifying the code structure, but requires attention to Jackson version compatibility.

Extended Discussion on Type Information Handling

The issues mentioned in the reference material demonstrate another important aspect of enum serialization—type information handling. When using the @JsonTypeInfo annotation, special attention must be paid to the choice of serialization format:

@JsonFormat(shape = JsonFormat.Shape.OBJECT)
@JsonTypeInfo(use = JsonTypeInfo.Id.CLASS, include = JsonTypeInfo.As.PROPERTY, property="@class")
public enum SimpleFakeRecordType {
    FAKE1("Fake1"),
    FAKE2("Fake2"),
    FAKE3("Fake3");
    
    @JsonProperty("name")
    private String name;
    
    SimpleFakeRecordType(final String name) {
        this.name = name;
    }
    
    public String getName() {
        return name;
    }
    
    public void setName(String name) {
        this.name = name;
    }
}

This implementation correctly serializes enum objects containing type information, but requires careful attention to JSON structure matching during deserialization.

Best Practice Recommendations

Based on the above analysis, we recommend:

1. For scenarios requiring complete control over serialization format, use the combination of @JsonCreator and @JsonValue
2. For simple string mappings, prefer @JsonProperty in Jackson 2.6+
3. When handling complex type information, carefully configure relevant parameters of @JsonTypeInfo
4. Always conduct complete serialization-deserialization testing to ensure bidirectional conversion correctness

Conclusion

The key to Jackson enum serialization and deserialization lies in understanding the working mechanism of annotations and Jackson's default behavior. Through reasonable annotation combinations and mapping table design, flexible and reliable enum JSON processing solutions can be achieved. Developers should choose the most suitable implementation based on specific requirements and Jackson versions.