Partner – Moderne – NPI EA (cat=Spring Boot)
announcement - icon

Refactor Java code safely — and automatically — with OpenRewrite.

Refactoring big codebases by hand is slow, risky, and easy to put off. That’s where OpenRewrite comes in. The open-source framework for large-scale, automated code transformations helps teams modernize safely and consistently.

Each month, the creators and maintainers of OpenRewrite at Moderne run live, hands-on training sessions — one for newcomers and one for experienced users. You’ll see how recipes work, how to apply them across projects, and how to modernize code with confidence.

Join the next session, bring your questions, and learn how to automate the kind of work that usually eats your sprint time.

Course – Black Friday 2026 – NPI EA – main – before_post_content
announcement - icon

Yes, we're now running our Black Friday Sale. All Courses are 33% off until 1st December, 2026 at 17:00 Romania time:

>> EXPLORE ACCESS NOW

Course – Black Friday 2026 – NPI – main – before_post_content
announcement - icon

Yes, we're now running our Black Friday Sale. All Courses are 33% off until 1st December, 2026 at 17:00 Romania time:

>> EXPLORE ACCESS NOW

1. Introduction

In this quick tutorial, we’ll explore ways to avoid Jackson serialization on non-fetched lazy objects using the Baeldung University domain model. We’ll set up a simple Spring-based application to demonstrate the principles, but no prior Spring experience is needed to follow along. All examples rely only on JPA concepts.

2. Setting Up the Example

One common challenge when working with JPA and Jackson is serializing entities containing lazy associations. We’ll start with a representation of a university department, which contains many courses:

@Entity
class Department {

    @Id
    Long id;

    String name;

    @OneToMany(mappedBy = "department")
    List<Course> courses;

    // getters and setters
}

The relationship to courses is mapped by the department field in Course. We also have to explicitly set the fetch type to LAZY, since the default for many-to-one relationships is EAGER:

@Entity
class Course {

    @Id
    Long id;

    String name;

    @ManyToOne(fetch = FetchType.LAZY)
    Department department;

    // getters and setters
}

When Jackson serializes an entity, it calls all of its getters. If a field is still lazily loaded, this triggers extra database queries. And if the persistence context is already closed, serialization fails with a LazyInitializationException.

3. Demonstrating the Problem

To visualize the issue, we’ll create endpoints to save and retrieve Department and Course entities.

3.1. Testing the DepartmentController

Let’s start with a controller with simple POST and GET endpoints:

@RestController
@RequestMapping("/departments")
public class DepartmentController {

    @Autowired
    DepartmentRepository repository;
    
    @PostMapping
    Department post(@RequestBody Department department) {
        return repository.save(department);
    }

    @GetMapping("/{id}")
    Optional<Department> get(@PathVariable("id") Long id) {
        return repository.findById(id);
    }
}

Even if we don’t include any courses, attempting to retrieve a newly created department results in an exception:

curl http://localhost:8080/departments/1

That’s because Jackson fails to initialize the proxied field:

failed to lazily initialize a collection of role: 
  com.baeldung.jacksonlazyfields.model.Department.courses: 
  could not initialize proxy - no Session

3.2. Testing the CourseController

We’ll follow the same pattern for a course controller, with simple POST and GET endpoints. But this time, we’ll only get an exception for courses that contain a department. We can check that by inserting a new department:

curl -X POST http://localhost:8080/departments\
 -H "Content-Type: application/json" \
-d '{"name":"Computer-Science"}'

Then, reference it in a new course by ID:

curl -X POST http://localhost:8080/courses \
-H "Content-Type: application/json" \
-d '{"name":"Machine-Learning", "department":{"id":1} }'

If we try to retrieve that course, we’ll get an exception similar to the first one:

could not initialize proxy [com.baeldung.jacksonlazyfields.model.Department#1]
  - no Session

Let’s see some options we have to avoid this.

4. Using @JsonIgnore

A simple option if we don’t need to serialize a specific association is to include a @JsonIgnore annotation on the field:

@JsonIgnore
@OneToMany(mappedBy = "department")
List<Course> courses;

Now, the field is excluded from serialization:

{
  "id": 1,
  "name": "Computer-Science"
}

This is useful for hiding a field in the payload.

5. Using Jackson’s Hibernate Module

A global solution is registering the Hibernate module for Jackson, which depends on jackson-datatype-hibernate6:

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

After including the dependency in our POM, we have to make sure the ObjectMapper instance we’re using registers the Hibernate6Module:

ObjectMapper mapper = new ObjectMapper();
mapper.registerModule(new Hibernate6Module());

This avoids lazy loading; instead, Jackson now writes null for unfetched associations:

{
  "id": 1,
  "name": "Computer-Science",
  "courses": null
}

This solution is nice because it works for any object serialized with that ObjectMapper instance.

6. Using DTO Projections

A tedious but robust approach is creating DTOs. This way, we have complete control over what is serialized while decoupling the persistence layer, avoiding the need to include external libraries.

6.1. Creating the DTO

First, let’s create a record containing only the fields we want to serialize:

public record DepartmentDto(Long id, String name) {}

6.2. Updating the GET Endpoint

Second, we’ll update our GET endpoint to use the DTO:

@GetMapping("/{id}")
Optional get(@PathVariable("id") Long id) {
    return repository.findById(id)
      .map(d -> new DepartmentDto(id, d.getName()));
}

6.3. Fetching the Results

Now, we’ll have no issues with Jackson stumbling on non-fetched fields:

{ 
  "id": 1, 
  "name": "Computer-Science"
}

7. Conclusion

In this article, we learned how to prevent Jackson from accessing unfetched proxies when serializing lazy relationships. The best approach depends on our design; DTOs are the cleanest, while registering the Hibernate module prevents unexpected exceptions. Also, simply adding @JsonIgnore ensures a field is never serialized.

The code backing this article is available on GitHub. Once you're logged in as a Baeldung Pro Member, start learning and coding on the project.
Partner – Moderne – NPI EA (tag=Refactoring)
announcement - icon

Modern Java teams move fast — but codebases don’t always keep up. Frameworks change, dependencies drift, and tech debt builds until it starts to drag on delivery. OpenRewrite was built to fix that: an open-source refactoring engine that automates repetitive code changes while keeping developer intent intact.

The monthly training series, led by the creators and maintainers of OpenRewrite at Moderne, walks through real-world migrations and modernization patterns. Whether you’re new to recipes or ready to write your own, you’ll learn practical ways to refactor safely and at scale.

If you’ve ever wished refactoring felt as natural — and as fast — as writing code, this is a good place to start.

Course – Black Friday 2026 – NPI EA – main – after_post_content

announcement - icon

Yes, we're now running our Black Friday Sale. All Courses are 33% off until 1st December, 2026 at 17:00 Romania time:

>> EXPLORE ACCESS NOW

Course – Black Friday 2026 – NPI – main – after_post_content

announcement - icon

Yes, we're now running our Black Friday Sale. All Courses are 33% off until 1st December, 2026 at 17:00 Romania time:

>> EXPLORE ACCESS NOW

2 Comments
Oldest
Newest