Why relationships matter in JPA in Spring Boot - Challenge Your Understanding

Challenge - 5 Problems

❓ component_behavior

intermediate

What happens when you fetch a OneToMany relationship lazily in JPA?

Consider a JPA entity Author with a @OneToMany relationship to Book marked as fetch = FetchType.LAZY. What will happen when you access the books collection outside a transaction?

Spring Boot

public class Author {
    @OneToMany(fetch = FetchType.LAZY, mappedBy = "author")
    private List<Book> books;

    // getters and setters
}

// In a service method without transaction
Author author = authorRepository.findById(1L).orElseThrow();
List<Book> books = author.getBooks(); // What happens here?

A The code compiles but returns an empty list always.

B A LazyInitializationException is thrown because the collection is accessed outside the transaction.

C The books collection is null because it was not fetched eagerly.

D The books collection is fully loaded automatically without any error.

💡 Hint

Think about how lazy loading works and when the database session is active.

Lazy loading defers loading the related entities until accessed. If accessed outside a transaction or session, JPA cannot fetch the data and throws LazyInitializationException.

📝 Syntax

intermediate

Which annotation correctly defines a bidirectional ManyToOne/OneToMany relationship in JPA?

Given two entities Order and OrderItem, which option correctly sets up a bidirectional relationship where one order has many order items?

Spring Boot

public class Order {
    // relationship here
}

public class OrderItem {
    // relationship here
}

A

@ManyToOne(mappedBy = "items") private Order order; // in Order
@OneToMany @JoinColumn(name = "order_id") private List<OrderItem> items; // in OrderItem

B

@OneToMany private List<OrderItem> items; // in Order
@ManyToOne(mappedBy = "order") private Order order; // in OrderItem

C

@OneToMany(mappedBy = "order") private List<OrderItem> items; // in Order
@ManyToOne @JoinColumn(name = "order_id") private Order order; // in OrderItem

D

@ManyToOne private Order order; // in Order
@OneToMany(mappedBy = "order") private List<OrderItem> items; // in OrderItem

💡 Hint

Remember that mappedBy goes on the inverse side and @JoinColumn on the owning side.

The Order entity is the inverse side with mappedBy. The OrderItem owns the relationship with @JoinColumn. This setup is correct for bidirectional OneToMany/ManyToOne.

❓ state_output

advanced

What is the state of entities after cascading a persist in a OneToMany relationship?

Given an Author entity with a @OneToMany(cascade = CascadeType.PERSIST) relationship to Book, what happens when you persist the author with new books added?

Spring Boot

Author author = new Author();
author.setName("Jane Doe");
Book book1 = new Book();
book1.setTitle("Book One");
Book book2 = new Book();
book2.setTitle("Book Two");
author.setBooks(List.of(book1, book2));
entityManager.persist(author);
// What is the state of book1 and book2 after this?

A Both book1 and book2 are also persisted automatically due to cascade persist.

B Only author is persisted; book1 and book2 remain transient and not saved.

C Books are persisted but without their relationship to author set.

D Persisting author throws an exception because books are not explicitly persisted.

💡 Hint

Think about what cascade persist means for related entities.

CascadeType.PERSIST causes JPA to persist all related entities automatically when the parent is persisted. So both books are saved along with the author.

🔧 Debug

advanced

Why does this bidirectional relationship cause infinite recursion in JSON serialization?

Given these entities with bidirectional relationships, serializing Author to JSON causes infinite recursion. Why?

Spring Boot

public class Author {
    @OneToMany(mappedBy = "author")
    private List<Book> books;
    // getters and setters
}

public class Book {
    @ManyToOne
    private Author author;
    // getters and setters
}

// Serialization code:
ObjectMapper mapper = new ObjectMapper();
String json = mapper.writeValueAsString(author);

A Because the Book entity lacks a primary key, causing serialization to fail.

B Because the @OneToMany annotation is missing fetch type, causing serialization failure.

C Because the ObjectMapper is not configured to handle collections, causing an error.

D Because Author references Book and Book references Author, causing infinite back-and-forth serialization.

💡 Hint

Think about how JSON serialization handles circular references.

Bidirectional relationships cause infinite recursion during serialization because each side references the other endlessly. This must be handled with annotations like @JsonManagedReference and @JsonBackReference or similar.

🧠 Conceptual

expert

Why is it important to define owning and inverse sides in JPA relationships?

In JPA, relationships have owning and inverse sides. Why does this distinction matter?

A Because only the owning side controls the database foreign key updates, preventing inconsistent data.

B Because the inverse side is the only one that can cascade operations to related entities.

C Because the owning side is ignored during persistence, and only the inverse side is saved.

D Because both sides independently update the database, causing duplicate foreign keys.

💡 Hint

Consider which side JPA uses to manage the foreign key column in the database.

The owning side is responsible for managing the foreign key column in the database. The inverse side is just a mirror and does not update the database. This prevents conflicts and keeps data consistent.