Java Jackson @JsonNaming Example

1. Introduction

When working with Jackson to serialize or deserialize Java objects to/from JSON, developers might encounter scenarios where the naming convention of JSON properties differs from the Java fields. The Jackson @JsonNaming annotation lets developers define naming strategies for the properties without changing the actual field names in Java. In this guide, we'll see how to apply this annotation and use a predefined naming strategy.

2. Example Steps

1. Add the necessary Jackson library dependencies to your project.

2. Create a Java class (POJO) for which you want to apply a specific naming strategy during serialization/deserialization.

3. Use the @JsonNaming annotation on the class and specify the desired naming strategy.

4. Create an instance of Jackson's ObjectMapper to perform serialization.

5. Output the serialized JSON.

3. Java Jackson @JsonNaming Example

import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.PropertyNamingStrategy;
import com.fasterxml.jackson.databind.annotation.JsonNaming;

public class JsonNamingExample {

    public static void main(String[] args) {
        // Create an instance of the User class
        User user = new User("John", "Doe");

        try {
            ObjectMapper objectMapper = new ObjectMapper();
            // Serialize the object to JSON
            String jsonString = objectMapper.writeValueAsString(user);
            System.out.println(jsonString);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    @JsonNaming(PropertyNamingStrategy.SnakeCaseStrategy.class)
    static class User {
        private String firstName;
        private String lastName;

        public User(String firstName, String lastName) {
            this.firstName = firstName;
            this.lastName = lastName;
        }

        // Getters, setters and other methods...
    }
}

Output:

{"first_name":"John","last_name":"Doe"}

4. Step By Step Explanation

1. We created a User class with two fields - firstName and lastName.

2. We applied the @JsonNaming annotation on the User class and specified PropertyNamingStrategy.SnakeCaseStrategy.class as the desired naming strategy. This strategy will convert camel-case field names into snake-case JSON property names (e.g., firstName becomes first_name).

3. In the main method, an instance of the User class is created.

4. We use Jackson's ObjectMapper to serialize the User instance into a JSON string.

5. The resulting JSON string adheres to the snake-case naming convention, thanks to the @JsonNaming annotation.