@OneToMany relationship in Spring Boot

Introduction

The @OneToMany annotation helps connect one object to many related objects in a simple way. It models real-life situations where one thing owns or controls many others.

When a single customer has many orders in an online shop.

When a blog post has many comments.

When a teacher teaches many students.

When a company has many employees.

Syntax

Spring Boot

@OneToMany(mappedBy = "fieldName", cascade = CascadeType.ALL, fetch = FetchType.LAZY)
private List<RelatedEntity> relatedEntities;

Use mappedBy to tell which field owns the relationship on the other side.

Common options include cascade to manage related data automatically and fetch to control when data loads.

Examples

This means one customer can have many orders. The customer field in Order owns the link.

Spring Boot

@OneToMany(mappedBy = "customer")
private List<Order> orders;

This example loads all comments immediately and saves or deletes them automatically with the parent.

Spring Boot

@OneToMany(cascade = CascadeType.ALL, fetch = FetchType.EAGER)
private Set<Comment> comments = new HashSet<>();

Sample Program

This example shows two classes: Customer and Order. One customer can have many orders. The @OneToMany annotation in Customer links to the list of orders. The Order class uses @ManyToOne to point back to its customer. When you save a customer, all their orders save too because of cascade = CascadeType.ALL.

Spring Boot

import jakarta.persistence.*;
import java.util.List;
import java.util.ArrayList;

@Entity
public class Customer {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;

    @OneToMany(mappedBy = "customer", cascade = CascadeType.ALL, fetch = FetchType.LAZY)
    private List<Order> orders = new ArrayList<>();

    // Constructors, getters, setters
    public Customer() {}
    public Customer(String name) { this.name = name; }
    public Long getId() { return id; }
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    public List<Order> getOrders() { return orders; }
    public void setOrders(List<Order> orders) { this.orders = orders; }
}

@Entity
public class Order {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String product;

    @ManyToOne
    @JoinColumn(name = "customer_id")
    private Customer customer;

    // Constructors, getters, setters
    public Order() {}
    public Order(String product, Customer customer) {
        this.product = product;
        this.customer = customer;
    }
    public Long getId() { return id; }
    public String getProduct() { return product; }
    public void setProduct(String product) { this.product = product; }
    public Customer getCustomer() { return customer; }
    public void setCustomer(Customer customer) { this.customer = customer; }
}

// Usage example (in a service or main method):
// Customer cust = new Customer("Alice");
// Order order1 = new Order("Book", cust);
// Order order2 = new Order("Pen", cust);
// cust.setOrders(List.of(order1, order2));
// Save cust to database, orders saved automatically due to cascade.

Important Notes

Always keep mappedBy consistent to avoid errors.

Lazy fetch means related data loads only when needed, saving memory.

Cascade helps keep related data in sync automatically.

Summary

@OneToMany connects one object to many others, like one person to many things.

Use mappedBy to tell which side owns the relationship.

Cascade and fetch options control how related data is saved and loaded.

Practice

1. What does the @OneToMany annotation represent in Spring Boot JPA?

easy

A. A relationship where one entity is linked to many entities

B. A relationship where many entities are linked to one entity

C. A way to delete entities automatically

D. A method to fetch data lazily

Solution

1. Step 1: Understand the meaning of @OneToMany

   The annotation defines a connection where one object relates to multiple objects, like one author having many books.

2. Step 2: Differentiate from other relationships

   @ManyToOne is the opposite, linking many entities to one. @OneToMany specifically means one to many.

3. Final Answer:

   A relationship where one entity is linked to many entities -> Option A

4. Quick Check:

   @OneToMany = one to many link [OK]

Hint: Think 'one' object owns 'many' related objects [OK]

Common Mistakes:

• Confusing @OneToMany with @ManyToOne
• Thinking it deletes entities automatically
• Assuming it controls fetch type only

2. Which of the following is the correct way to declare a @OneToMany relationship in an entity class?

easy

A. @OneToMany(mappedBy = "parent") private List<Child> children;

B. @OneToMany private Child child;

C. @OneToMany(mappedBy = "children") private Child parent;

D. @OneToMany private Map childrenMap;

Solution

1. Step 1: Check the collection type for @OneToMany

   @OneToMany requires a collection like List or Set to hold multiple related entities, so List<Child> is correct.

2. Step 2: Verify the mappedBy attribute usage

   mappedBy should point to the field name in the Child entity that owns the relationship, here "parent" is correct.

3. Final Answer:

   @OneToMany(mappedBy = "parent") private List<Child> children; -> Option A

4. Quick Check:

   Use collection + mappedBy for correct syntax [OK]

Hint: Use a collection and mappedBy to link entities [OK]

Common Mistakes:

• Using single object instead of collection
• Wrong mappedBy value
• Using Map instead of List or Set

3. Given the following code snippet, what will be the output when fetching a Department entity?

@Entity
public class Department {
  @Id
  private Long id;

  @OneToMany(mappedBy = "department", fetch = FetchType.EAGER)
  private List<Employee> employees;

  // getters and setters
}

Assuming the department has 3 employees, what happens when you load the department?

medium

A. Only one employee is loaded due to default limit

B. The department loads without employees until accessed

C. The department loads with all 3 employees immediately

D. An error occurs because fetch type is invalid

Solution

1. Step 1: Understand fetch type EAGER

   FetchType.EAGER means related entities are loaded immediately with the main entity.

2. Step 2: Apply to the employees list

   Since employees are marked EAGER, all 3 employees will be loaded when the department is fetched.

3. Final Answer:

   The department loads with all 3 employees immediately -> Option C

4. Quick Check:

   FetchType.EAGER loads related entities immediately [OK]

Hint: EAGER fetch loads all related data immediately [OK]

Common Mistakes:

• Confusing EAGER with LAZY fetch
• Assuming default fetch loads lazily
• Expecting errors from fetch type

4. Identify the error in this @OneToMany mapping:

@Entity
public class Order {
  @Id
  private Long id;

  @OneToMany
  private List<Item> items;

  // getters and setters
}

Why might this cause issues when saving an Order with Items?

medium

A. List<Item> should be Set<Item> for @OneToMany

B. Missing mappedBy causes owning side confusion

C. The @Id annotation is missing

D. Items should be annotated with @ManyToMany

Solution

1. Step 1: Check ownership in bidirectional @OneToMany

   Without mappedBy, JPA doesn't know which side owns the relationship, causing extra join tables or errors.

2. Step 2: Understand impact on saving

   Without ownership, saving Order and Items may not link properly, causing data inconsistency.

3. Final Answer:

   Missing mappedBy causes owning side confusion -> Option B

4. Quick Check:

   mappedBy defines owner, missing it causes issues [OK]

Hint: Always set mappedBy on non-owning side [OK]

Common Mistakes:

• Omitting mappedBy in bidirectional relationships
• Confusing collection types for @OneToMany
• Misusing @ManyToMany instead of @OneToMany

5. You want to delete a Category and all its related Product entities automatically. Which @OneToMany configuration achieves this behavior?

hard

A. @OneToMany(cascade = CascadeType.PERSIST) private List<Product> products;

B. @OneToMany(mappedBy = "category") private List<Product> products;

C. @OneToMany(fetch = FetchType.LAZY) private List<Product> products;

D. @OneToMany(mappedBy = "category", cascade = CascadeType.ALL, orphanRemoval = true) private List<Product> products;

Solution

1. Step 1: Understand cascade and orphanRemoval

   CascadeType.ALL applies all operations including delete to related entities. orphanRemoval=true removes child entities if removed from parent.

2. Step 2: Apply to deleting Category

   With cascade ALL and orphanRemoval, deleting Category deletes all linked Products automatically.

3. Final Answer:

   @OneToMany(mappedBy = "category", cascade = CascadeType.ALL, orphanRemoval = true) private List<Product> products; -> Option D

4. Quick Check:

   Use cascade ALL + orphanRemoval for auto-delete [OK]

Hint: Cascade ALL + orphanRemoval deletes children automatically [OK]

Common Mistakes:

• Forgetting cascade causes children to remain
• Using only cascade PERSIST won't delete children
• Ignoring orphanRemoval for child removal