@ManyToMany relationship in Spring Boot - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What is the output of this @ManyToMany mapping retrieval?

Given two entities Student and Course with a bidirectional @ManyToMany relationship, what will be printed when fetching a student and listing their courses?

Spring Boot

public class Student {
  @ManyToMany
  private Set<Course> courses = new HashSet<>();
  // getters and setters
}

public class Course {
  @ManyToMany(mappedBy = "students")
  private Set<Student> students = new HashSet<>();
  // getters and setters
}

// In service:
Student s = studentRepository.findById(1L).get();
System.out.println(s.getCourses().size());

A Prints the number of courses the student is enrolled in, e.g., 3

B Throws a NullPointerException because courses is null

C Always prints 0 because the collection is not initialized

D Throws a LazyInitializationException if session is closed

💡 Hint

Think about how JPA initializes collections in a @ManyToMany relationship when accessed inside a transaction.

In a properly configured Spring Boot JPA environment, fetching a student entity and accessing its courses collection inside an open session will load the related courses. The size printed is the actual number of courses linked to that student.

📝 Syntax

intermediate

Which option correctly defines a bidirectional @ManyToMany relationship?

Select the correct code snippet that defines a bidirectional @ManyToMany relationship between Author and Book entities.

A

@Entity
public class Author {
  @ManyToMany(mappedBy = "authors")
  private Set<Book> books = new HashSet<>();
}
@Entity
public class Book {
  @ManyToMany
  private Set<Author> authors = new HashSet<>();
}

B

@Entity
public class Author {
  @ManyToMany
  private Set<Book> books = new HashSet<>();
}
@Entity
public class Book {
  @ManyToMany(mappedBy = "books")
  private Set<Author> authors = new HashSet<>();
}

C

@Entity
public class Author {
  @OneToMany
  private Set<Book> books = new HashSet<>();
}
@Entity
public class Book {
  @ManyToMany(mappedBy = "books")
  private Set<Author> authors = new HashSet<>();
}

D

@Entity
public class Author {
  @ManyToMany
  private List<Book> books = new ArrayList<>();
}
@Entity
public class Book {
  @ManyToMany(mappedBy = "books")
  private List<Author> authors = new ArrayList<>();
}

💡 Hint

The owning side does not use mappedBy, the inverse side uses mappedBy with the owning side's field name.

In a bidirectional @ManyToMany, one side is the owner without mappedBy, the other side uses mappedBy referencing the owner's field. Option B correctly shows this pattern.

🔧 Debug

advanced

Why does this @ManyToMany relationship cause a duplicate entry error?

Consider this code snippet where adding the same Course twice to a Student causes a database constraint violation. What is the likely cause?

Spring Boot

Student s = studentRepository.findById(1L).get();
Course c = courseRepository.findById(2L).get();
s.getCourses().add(c);
s.getCourses().add(c);
studentRepository.save(s);

A The equals and hashCode methods are not overridden in Course entity

B The Set collection is not properly initialized, allowing duplicates

C The cascade type is missing, so duplicates are inserted

D The join table is missing a unique constraint

💡 Hint

Sets rely on equals and hashCode to avoid duplicates.

If equals and hashCode are not overridden in the entity, the Set cannot detect duplicates properly, causing duplicate inserts and constraint violations.

❓ lifecycle

advanced

What happens when you remove an entity from a @ManyToMany collection and save?

Given a Student entity with a @ManyToMany relationship to Course, what happens in the database when you remove a Course from the Student's courses set and save the Student?

Spring Boot

Student s = studentRepository.findById(1L).get();
Course c = courseRepository.findById(2L).get();
s.getCourses().remove(c);
studentRepository.save(s);

A An exception is thrown because orphanRemoval is not enabled

B The Course entity is deleted from the database

C Nothing changes because cascade remove is not set

D The link between Student and Course is removed from the join table

💡 Hint

Removing from a collection updates the join table, not the related entity itself.

Removing a Course from the Student's courses set and saving updates the join table to remove the association link. The Course entity itself remains in the database.

🧠 Conceptual

expert

Which statement about @ManyToMany join tables is true?

Choose the correct statement about the join table used in a @ManyToMany relationship in JPA.

A The join table cannot be customized in JPA

B The join table is automatically an entity and can be queried directly

C The join table must have a composite primary key of both foreign keys by default

D The join table stores additional entity attributes by default

💡 Hint

Think about how JPA manages many-to-many relationships internally.

By default, the join table has a composite primary key made of the foreign keys from both related entities. It does not store extra attributes unless explicitly mapped as an entity.

Practice

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

easy

A. A relationship where entities inherit from each other.

B. A relationship where one entity has only one of the other entity.

C. A relationship where entities are unrelated.

D. A relationship where each entity can have many of the other entity.

Solution

1. Step 1: Understand the meaning of @ManyToMany

   The annotation defines a link where each entity can be related to many instances of the other entity.

2. Step 2: Compare with other relationship types

   Unlike one-to-one or one-to-many, many-to-many allows multiple connections on both sides.

3. Final Answer:

   A relationship where each entity can have many of the other entity. -> Option D

4. Quick Check:

   @ManyToMany = many-to-many link [OK]

Hint: Think: many items linked to many others [OK]

Common Mistakes:

• Confusing with one-to-one or one-to-many
• Thinking it means inheritance
• Ignoring the bidirectional nature

2. Which of the following is the correct way to define a join table in a @ManyToMany relationship?

easy

A. @JoinColumn(name = "student_course")

B. @JoinTable(name = "student_course", joinColumns = @JoinColumn(name = "student_id"), inverseJoinColumns = @JoinColumn(name = "course_id"))

C. @Table(name = "student_course")

D. @JoinTable(name = "student_course", joinColumns = @JoinColumn(name = "course_id"), inverseJoinColumns = @JoinColumn(name = "student_id"))

Solution

1. Step 1: Identify correct @JoinTable usage

   The join table must specify the table name and correctly assign joinColumns and inverseJoinColumns to the owning and inverse sides.

2. Step 2: Check column names match entities

   joinColumns should refer to the current entity's ID, inverseJoinColumns to the other entity's ID.

3. Final Answer:

   @JoinTable(name = "student_course", joinColumns = @JoinColumn(name = "student_id"), inverseJoinColumns = @JoinColumn(name = "course_id")) -> Option B

4. Quick Check:

   @JoinTable with correct joinColumns = A [OK]

Hint: joinColumns = this entity, inverseJoinColumns = other entity [OK]

Common Mistakes:

• Swapping joinColumns and inverseJoinColumns
• Using @JoinColumn instead of @JoinTable
• Omitting joinColumns or inverseJoinColumns

3. Given the following code snippet, what will be the output when printing student.getCourses().size() after adding two courses to the student?

@Entity
class Student {
  @ManyToMany
  Set<Course> courses = new HashSet<>();

  public Set<Course> getCourses() { return courses; }
}

@Entity
class Course {}

Student student = new Student();
Course c1 = new Course();
Course c2 = new Course();
student.getCourses().add(c1);
student.getCourses().add(c2);
System.out.println(student.getCourses().size());

medium

A. 2

B. 0

C. 1

D. Compilation error

Solution

1. Step 1: Understand the collection type and additions

   The courses field is a HashSet, which allows unique elements. Adding two different Course objects increases size to 2.

2. Step 2: Confirm no errors in adding elements

   Adding elements to the set is valid and no exceptions occur here.

3. Final Answer:

   2 -> Option A

4. Quick Check:

   Two courses added = size 2 [OK]

Hint: HashSet size equals unique added elements [OK]

Common Mistakes:

• Assuming size is 0 because of missing persistence
• Confusing with list allowing duplicates
• Expecting compilation error due to missing annotations

4. Identify the error in this @ManyToMany mapping:

@Entity
class Author {
  @ManyToMany
  Set<Book> books;
}

@Entity
class Book {
  @ManyToMany(mappedBy = "books")
  Set<Author> authors;
}

medium

A. The @ManyToMany annotation is missing @JoinTable on both sides.

B. The mappedBy attribute is incorrectly used on the owning side.

C. The collections are not initialized, causing NullPointerException.

D. The entities must extend a common superclass.

Solution

1. Step 1: Check collection initialization

   The sets 'books' and 'authors' are declared but not initialized, so they are null by default.

2. Step 2: Understand impact of null collections

   Trying to add or access elements will cause NullPointerException at runtime.

3. Final Answer:

   The collections are not initialized, causing NullPointerException. -> Option C

4. Quick Check:

   Uninitialized sets cause null errors [OK]

Hint: Always initialize collections to avoid null errors [OK]

Common Mistakes:

• Assuming @JoinTable is mandatory on both sides
• Confusing owning side with inverse side
• Thinking inheritance is required

5. You have two entities, Student and Club, with a @ManyToMany relationship. You want to add a new club to a student and ensure both sides reflect this change. Which code snippet correctly updates both sides?

hard

A. student.getClubs().add(club); club.getStudents().add(student);

B. student.getClubs().add(club);

C. club.getStudents().add(student);

D. student.setClubs(Set.of(club));

Solution

1. Step 1: Understand bidirectional @ManyToMany updates

   Both sides must be updated to keep the relationship consistent in memory.

2. Step 2: Check which code updates both sides

   student.getClubs().add(club); club.getStudents().add(student); adds the club to the student's clubs and the student to the club's students, syncing both sides.

3. Final Answer:

   student.getClubs().add(club); club.getStudents().add(student); -> Option A

4. Quick Check:

   Update both sides for consistency [OK]

Hint: Always update both sides of @ManyToMany [OK]

Common Mistakes:

• Updating only one side causing stale data
• Replacing collections without adding
• Ignoring inverse side updates