Java Jackson @JsonBackReference

1. Overview

In object-relational modeling, bidirectional relationships are common, where two entities have references to each other. When trying to serialize such entities to JSON using Jackson, there is a risk of running into infinite recursion issues. The @JsonBackReference and @JsonManagedReference annotations in Jackson provide a solution to this problem. In this article, we'll focus on the @JsonBackReference annotation, using a User Management System as our practical example.

Check out all the Java Jackson JSON tutorials and examples: 50+ Java Jackson JSON Tutorials with Examples

@JsonBackReference Annotation Overview

The @JsonBackReference annotation is used on the property that should not be serialized, i.e., the back part of the reference. This helps in avoiding infinite loops during serialization. Its counterpart, @JsonManagedReference, is used on the opposite side, indicating the property that should be serialized.

2. Development Steps

1. Set up a new Maven project.

2. Incorporate the necessary Jackson dependencies.

3. Create the entity classes, with one having the @JsonBackReference annotation.

4. Implement a main class to showcase serialization.

5. Serialize a sample object to JSON.

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

// Address.java
public class Address {
    private String street;
    private String city;
    @JsonBackReference
    private User user;
    // Constructors, getters, setters...
}
// User.java
public class User {
    private int userId;
    private String userName;
    @JsonManagedReference
    private Address address;
    // Constructors, getters, setters...
}
// MainApp.java
import com.fasterxml.jackson.databind.ObjectMapper;
public class MainApp {
    public static void main(String[] args) {
        Address addr = new Address("123 Main St", "Springfield");
        User usr = new User(101, "John Doe", addr);
        addr.setUser(usr);
        ObjectMapper objectMapper = new ObjectMapper();
        try {
            String resultingJson = objectMapper.writeValueAsString(usr);
            System.out.println(resultingJson);
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }
}

Output:

{"userId":101,"userName":"John Doe","address":{"street":"123 Main St","city":"Springfield"}}

Code Explanation:

Here, a User is associated with an Address, and the Address has a back reference to the User. This forms a bidirectional relationship.

The @JsonBackReference annotation on the user property of the Address class indicates that this field should not be serialized. This helps in avoiding infinite loops during the serialization process.

On the other hand, the @JsonManagedReference annotation in the User class ensures that the address property is serialized.

Thus, when the User object is serialized in the MainApp class, Jackson includes the address property in the JSON output but omits the back reference to the user.

6. Conclusion

Using Jackson's @JsonBackReference annotation allows developers to manage and navigate bidirectional relationships effectively during JSON serialization. Alongside @JsonManagedReference, it ensures a balanced and recursion-free serialization of complex Java object relationships.

Check out all the Java Jackson JSON tutorials and examples: 50+ Java Jackson JSON Tutorials with Examples