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