Four Advanced Spring Boot Solutions to Eliminate @JsonIgnore and Resolve JSON Recursion

Problem Overview

In a Spring Boot 3.5.0 project using JPA, bidirectional relationships such as Order ↔ Customer lead to infinite JSON recursion during serialization: the Order serializes its customer, which in turn serializes its orders, and so on, eventually causing a stack‑overflow error.

The common quick fix is to place @JsonIgnore on one side of the relationship (e.g., on Order.customer), which stops the recursion but also hides the customer data entirely, which is often undesirable.

Four Advanced Solutions

2.1 Use @JsonIgnoreProperties

Apply @JsonIgnoreProperties("customer") to the orders collection in Customer while leaving Order untouched. This tells Jackson to ignore the customer property only when serializing the Customer side, preserving the customer field in Order.

public class Customer {
    // ...
    @OneToMany(mappedBy = "customer", cascade = CascadeType.ALL, orphanRemoval = true)
    @JsonIgnoreProperties("customer")
    private List<Order> orders = new ArrayList<>();
}

public class Order {
    // ...
    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "customer_id")
    private Customer customer;
}

Resulting JSON no longer recurses while still exposing the customer data in Order.

2.2 Use @JsonManagedReference and @JsonBackReference

Mark the parent side with @JsonManagedReference and the child side with @JsonBackReference. During serialization, the managed side is output normally, while the back‑reference side is omitted, breaking the cycle.

public class Order {
    // ...
    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "customer_id")
    @JsonBackReference
    private Customer customer;
}

public class Customer {
    // ...
    @OneToMany(mappedBy = "customer", cascade = CascadeType.ALL, orphanRemoval = true)
    @JsonManagedReference
    private List<Order> orders = new ArrayList<>();
}

The two annotations can be swapped depending on which side you prefer to serialize.

2.3 Register the Jackson Hibernate Module

Include the jackson-datatype-hibernate6 dependency and configure a bean that registers Hibernate6Module. This module makes Jackson aware of Hibernate lazy‑loaded proxies and prevents recursion without adding any annotations to the entities.

<dependency>
    <groupId>com.fasterxml.jackson.datatype</groupId>
    <artifactId>jackson-datatype-hibernate6</artifactId>
</dependency>

@Configuration
public class JacksonConfig {
    @Bean
    public Jackson2ObjectMapperBuilderCustomizer hibernateJacksonModule() {
        return builder -> builder.modulesToInstall(new Hibernate6Module());
    }
}

After this configuration, the entities can be serialized without any Jackson-specific annotations.

2.4 Use @JsonIdentityInfo

Apply @JsonIdentityInfo with an identifier generator (e.g., ObjectIdGenerators.PropertyGenerator) to both entities. During serialization, objects with the same identifier are emitted only once, and subsequent references are replaced by the identifier, thus avoiding infinite loops.

@JsonIdentityInfo(generator = ObjectIdGenerators.PropertyGenerator.class, property = "id")
@Entity
@Table(name = "t_order")
public class Order { /* fields */ }

@JsonIdentityInfo(generator = ObjectIdGenerators.PropertyGenerator.class, property = "id")
@Entity
@Table(name = "t_customer")
public class Customer { /* fields */ }

This approach works well for deeply nested or complex object graphs.

Conclusion

The article demonstrates that while @JsonIgnore solves the recursion problem, it also discards useful data. The four presented alternatives provide more granular control, allowing developers to keep necessary relationship data while preventing stack overflow errors during JSON serialization.