@OneToMany relationship in Spring Boot - Step-by-Step Execution

Concept Flow - @OneToMany relationship

Define Parent Entity

↓

Add @OneToMany on Collection

↓

Define Child Entity

↓

Add @ManyToOne on Child

↓

Save Parent with Children

↓

Spring Boot persists Parent and Children

↓

Retrieve Parent loads Children

This flow shows how a parent entity holds a collection of child entities using @OneToMany, and how Spring Boot saves and loads them together.

Execution Sample

Spring Boot

import javax.persistence.*;
import java.util.List;

@Entity
class Parent {
  @Id
  @GeneratedValue(strategy = GenerationType.IDENTITY)
  private Long id;

  @OneToMany(mappedBy = "parent", cascade = CascadeType.ALL)
  private List<Child> children;

  // getters and setters
}

@Entity
class Child {
  @Id
  @GeneratedValue(strategy = GenerationType.IDENTITY)
  private Long id;

  @ManyToOne
  @JoinColumn(name = "parent_id")
  private Parent parent;

  // getters and setters
}

Defines a Parent entity with a list of Child entities linked by @OneToMany and @ManyToOne annotations.

Execution Table

Step	Action	Parent.children	Child.parent	Database Operation
1	Create Parent object	[]	null	No DB operation
2	Create Child1 object	[]	null	No DB operation
3	Set Child1.parent = Parent	[]	Parent	No DB operation
4	Add Child1 to Parent.children	[Child1]	Parent	No DB operation
5	Save Parent	[Child1]	Parent	Insert Parent, Insert Child1 with FK to Parent
6	Retrieve Parent from DB	[Child1]	Parent	Select Parent, Select Children where FK matches
7	Access Parent.children	[Child1]	Parent	Children loaded from DB
8	Exit	[Child1]	Parent	All entities persisted and linked

💡 Execution stops after Parent and its Children are saved and retrieved with correct links.

Variable Tracker

Variable	Start	After Step 2	After Step 4	After Step 5	Final
Parent.children	null	[]	[Child1]	[Child1]	[Child1]
Child1.parent	null	null	Parent	Parent	Parent

Key Moments - 2 Insights

Why do we set Child.parent before adding Child to Parent.children?

Because the @ManyToOne side owns the relationship, setting Child.parent ensures the foreign key is correct in the database, as shown in execution_table step 3 and 4.

What happens if we save Parent without setting Child.parent?

The Child's foreign key will be null, so the link is broken in the database. Execution_table step 5 shows saving with correct links only if Child.parent is set.

Visual Quiz - 3 Questions

Look at the execution_table at step 5, what database operations occur?

A Insert Child only, Parent is not saved

B Insert Parent and Child with foreign key linking Child to Parent

C Only insert Parent, Child is not saved

D No database operations happen

💡 Hint

Check the 'Database Operation' column at step 5 in execution_table

At which step does Parent.children first contain Child1?

A Step 2

B Step 3

C Step 4

D Step 5

💡 Hint

Look at the 'Parent.children' column in execution_table rows

If Child1.parent was never set, what would Parent.children contain after saving?

A Parent.children would be empty

B Child1 would still be in Parent.children

C Parent.children would contain null

D Parent.children would cause an error

💡 Hint

Refer to key_moments about relationship ownership and execution_table step 5

Concept Snapshot

@OneToMany links one parent to many children.
Child owns the relationship with @ManyToOne.
Set Child.parent before adding to Parent.children.
Saving Parent cascades to save Children.
Retrieving Parent loads all Children.
This keeps DB foreign keys consistent.

Full Transcript

The @OneToMany relationship in Spring Boot connects one parent entity to many child entities. The parent class has a collection annotated with @OneToMany, and the child class has a reference back to the parent annotated with @ManyToOne. The child side owns the relationship, so setting the child's parent reference is essential before adding the child to the parent's collection. When saving the parent, Spring Boot saves both parent and children, linking them in the database with foreign keys. Retrieving the parent loads all its children automatically. This ensures data consistency and proper linkage between entities.