Java Jackson @JsonProperty

1. Overview

Jackson is a popular Java library used for converting Java objects into JSON format and vice versa. A common scenario is the need to customize the naming of fields during the serialization to or deserialization from JSON. Jackson’s @JsonProperty annotation addresses this need.

@JsonProperty Annotation Overview

The @JsonProperty annotation signifies the desired property name in the JSON content. It's instrumental when you want to rename the field in the JSON output, especially when the Java field name and the JSON property name aren't identical.

2. Development Steps

1. Create a new Maven project.

2. Add Jackson dependencies.

3. Design an Employee class using @JsonProperty.

4. Create a separate class for the serialization logic.

5. Create a main class to demonstrate the serialization.

3. Create a Maven Project

There are different ways to create a simple Maven project:

Create a Simple Maven Project using the Command Line Interface

Create a Simple Maven Project using  Eclipse IDE

Create a Simple Maven Project using  IntelliJ IDEA

4. Maven Dependencies

Open the pom.xml file, and add the following Jackson data binding dependency:

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.13.0</version>
</dependency>

5. Code Program

Let’s structure our program using the Employee Management System example:
// Employee.java
import com.fasterxml.jackson.annotation.JsonProperty;
public class Employee {
    @JsonProperty("full_name")
    private String name;
    @JsonProperty("years_of_experience")
    private int experience;
    // Standard constructor, getters, and setters...
}
// JsonSerializer.java
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
public class JsonSerializer {
    public static String serializeToJson(Object object) throws JsonProcessingException {
        ObjectMapper mapper = new ObjectMapper();
        return mapper.writeValueAsString(object);
    }
}
// MainClass.java
public class MainClass {
    public static void main(String[] args) {
        Employee emp = new Employee();
        emp.setName("John Doe");
        emp.setExperience(5);
        try {
            String json = JsonSerializer.serializeToJson(emp);
            System.out.println(json);
        } catch (JsonProcessingException e) {
            e.printStackTrace();
        }
    }
}

Output:

{"full_name":"John Doe","years_of_experience":5}

Code Explanation:

The Employee class defines the data structure and uses @JsonProperty to customize JSON property names. 

The JsonSerializer class is responsible for serialization. 

The MainClass instantiates an Employee object, serializes it using JsonSerializer, and prints the resulting JSON.

6. Conclusion

The @JsonProperty annotation in Jackson enables Java developers to tailor JSON property names during serialization/deserialization. This ensures that the JSON output can match specific standards or naming conventions, granting developers precise control over their JSON output.