@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.