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

Concept Flow - @ManyToMany relationship

Define Entity A

↓

Define Entity B

↓

Add @ManyToMany in Entity A

↓

Add @ManyToMany in Entity B

↓

Create Join Table

↓

Save Entities

↓

Entities linked via Join Table

This flow shows how two entities are linked with a @ManyToMany annotation, creating a join table to connect them.

Execution Sample

Spring Boot

import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.ManyToMany;
import java.util.Set;

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

  @ManyToMany
  Set<Course> courses;

  // getters and setters
}

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

  @ManyToMany(mappedBy = "courses")
  Set<Student> students;

  // getters and setters
}

Defines two entities Student and Course linked by a @ManyToMany relationship with a join table.

Execution Table

Step	Action	Entity State	Join Table State	Result
1	Create Student s1	Student s1 with empty courses set	Empty	Student s1 ready
2	Create Course c1	Course c1 with empty students set	Empty	Course c1 ready
3	Add c1 to s1.courses	s1.courses = {c1}	Empty	Link started
4	Add s1 to c1.students	c1.students = {s1}	Empty	Link confirmed
5	Save s1 and c1	Entities saved	Join table has entry (s1_id, c1_id)	Relationship persisted
6	Fetch s1	s1.courses = {c1}	Join table unchanged	Relationship loaded
7	Fetch c1	c1.students = {s1}	Join table unchanged	Relationship loaded

💡 Execution stops after entities are saved and relationship is persisted in join table.

Variable Tracker

Variable	Start	After Step 3	After Step 4	After Step 5	Final
s1.courses	{}	{c1}	{c1}	{c1}	{c1}
c1.students	{}	{}	{s1}	{s1}	{s1}
Join Table	Empty	Empty	Empty	{(s1_id, c1_id)}	{(s1_id, c1_id)}

Key Moments - 3 Insights

Why do we add the relationship on both sides (Student and Course)?

Because @ManyToMany is bidirectional, both sides must reference each other to keep the in-memory objects consistent, as shown in steps 3 and 4 of the execution_table.

What is the role of the join table in a @ManyToMany relationship?

The join table stores pairs of IDs linking the two entities, as seen in step 5 where saving entities creates the join table entry.

Why do we use 'mappedBy' on one side of the relationship?

'mappedBy' tells JPA which side owns the relationship to avoid duplicate join tables, shown in the code sample where Course uses mappedBy="courses".

Visual Quiz - 3 Questions

Look at the execution_table, what is the state of s1.courses after step 3?

A {}

B {c1}

C {s1}

D null

💡 Hint

Check the 'Entity State' column for step 3 in the execution_table.

At which step does the join table get its first entry?

A Step 3

B Step 4

C Step 5

D Step 6

💡 Hint

Look at the 'Join Table State' column in the execution_table.

If we remove 'mappedBy' from Course, what would happen?

A Two join tables would be created

B No join table would be created

C The relationship would be unidirectional

D Entities would not save

💡 Hint

Recall the explanation in key_moments about 'mappedBy' controlling ownership.

Concept Snapshot

@ManyToMany relationship links two entities with multiple connections.
Use @ManyToMany on both sides; one side owns the relation with 'mappedBy'.
JPA creates a join table storing pairs of linked entity IDs.
Add related entities to each other's collections to keep in-memory state consistent.
Save entities to persist the relationship in the join table.

Full Transcript

This visual execution traces the @ManyToMany relationship in Spring Boot. First, two entities, Student and Course, are created with empty sets for their relationships. Then, Course c1 is added to Student s1's courses set, and Student s1 is added to Course c1's students set, establishing a bidirectional link. When both entities are saved, JPA creates a join table entry linking their IDs. Fetching either entity later loads the related entities through this join table. The 'mappedBy' attribute on one side indicates the owning side to avoid duplicate join tables. This process ensures multiple Students can link to multiple Courses and vice versa, with the join table managing these connections.