How To Serialize and Deserialize Enums with Jackson

Serialization and deserialization are fundamental processes in software development, allowing data to be converted between different formats, such as between Java objects and JSON. Jackson is a popular library for handling JSON in Java applications. Enumerations, often referred to as enums, are a common data structure in Java used to represent a fixed set of constant values. In this article, we will explore how to serialize and deserialize enums using the Jackson library.

1. Introduction to Serialization and Deserialization

Serialization is the process of converting objects into a format (such as JSON) that can be easily stored or transmitted, while deserialization is the reverse process of converting the stored data back into objects. This is particularly useful when exchanging data between different systems or persisting it in a storage medium.

2. Enum Basics

Enums in Java are used to define a set of constant values. They are declared using the enum keyword and are often used to represent categories, states, or options in a more readable and type-safe manner.

public enum Day {
    MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY
}

3. Jackson Library Overview

Jackson is a high-performance JSON library for Java. It provides easy-to-use annotations and classes for serializing and deserializing Java objects to and from JSON. The library includes various modules, such as jackson-databind, which is responsible for binding JSON data to Java objects.

4. Serializing Enums with Jackson

Serializing enums using Jackson is straightforward. By default, enums are serialized as strings, using their names. To illustrate this, consider the following example:

import com.fasterxml.jackson.databind.ObjectMapper;

public class EnumSerializationExample {
    public static void main(String[] args) throws Exception {
        ObjectMapper objectMapper = new ObjectMapper();

        Day today = Day.WEDNESDAY;
        String json = objectMapper.writeValueAsString(today);

        System.out.println("Serialized JSON: " + json);
    }
}

In this example, the Day.WEDNESDAY enum constant is serialized as a string “WEDNESDAY”.

5. Deserializing Enums with Jackson

Deserializing enums is also straightforward with Jackson. When receiving JSON data, Jackson will automatically map the JSON string to the corresponding enum value.

import com.fasterxml.jackson.databind.ObjectMapper;

public class EnumDeserializationExample {
    public static void main(String[] args) throws Exception {
        ObjectMapper objectMapper = new ObjectMapper();

        String json = "\"FRIDAY\"";
        Day day = objectMapper.readValue(json, Day.class);

        System.out.println("Deserialized Enum: " + day);
    }
}

In this example, the JSON string “\”FRIDAY\”” is deserialized into the Day.FRIDAY enum constant.

6. Customizing Enum Serialization and Deserialization

Jackson provides options for customizing the serialization and deserialization of enums. For instance, you can use the @JsonFormat annotation to specify how an enum should be serialized or deserialized. Additionally, you can implement a custom serializer and deserializer by extending the JsonSerializer and JsonDeserializer classes.

7. Customizing Enum Serialization and Deserialization

While Jackson’s default behavior of serializing enums as strings works well in most cases, there might be scenarios where you need more control over the serialization and deserialization process. Jackson offers several ways to achieve this customization:

Using @JsonFormat Annotation

The @JsonFormat annotation can be used to control how an enum is serialized and deserialized. You can use the shape attribute to specify how the enum should be represented in JSON.

import com.fasterxml.jackson.annotation.JsonFormat;

@JsonFormat(shape = JsonFormat.Shape.STRING)
public enum Status {
    @JsonProperty("active")
    ACTIVE,
    @JsonProperty("inactive")
    INACTIVE
}

In this example, the Status enum will be serialized as "active" and "inactive" instead of their default names.

Custom Serializer and Deserializer

For more advanced customization, you can implement custom serializers and deserializers. This allows you to define how an enum should be converted to JSON and back.

import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.databind.JsonSerializer;
import com.fasterxml.jackson.databind.SerializerProvider;
import com.fasterxml.jackson.databind.JsonDeserializer;
import com.fasterxml.jackson.databind.DeserializationContext;
import java.io.IOException;

public class CustomEnumSerializer extends JsonSerializer<Status> {
    @Override
    public void serialize(Status status, JsonGenerator jsonGenerator, SerializerProvider serializerProvider) throws IOException {
        jsonGenerator.writeString(status.getCode());
    }
}

public class CustomEnumDeserializer extends JsonDeserializer<Status> {
    @Override
    public Status deserialize(JsonParser jsonParser, DeserializationContext deserializationContext) throws IOException {
        String code = jsonParser.getText();
        return Status.fromCode(code);
    }
}

In this example, the CustomEnumSerializer serializes the Status enum using a custom code, and the CustomEnumDeserializer deserializes the JSON code back into the corresponding enum.

8. Conclusion

Serialization and deserialization of enums are common tasks in Java applications that deal with JSON data. The Jackson library provides a powerful and flexible way to handle these processes, allowing you to easily map between Java enums and JSON representations. By understanding the basics of serialization and deserialization, as well as the customization options available in Jackson, you can effectively manage enums in your JSON-based applications. Whether you’re using Jackson’s default behavior or opting for more advanced customization, the ability to serialize and deserialize enums will enhance the efficiency and functionality of your software.