@ManyToMany relationship in Spring Boot - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to declare a many-to-many relationship in a Spring Boot entity.

Spring Boot

import jakarta.persistence.*;
import java.util.*;

@Entity
public class Student {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;

    @[1]
    private Set<Course> courses = new HashSet<>();

    // getters and setters
}

Drag options to blanks, or click blank then click option'

AOneToMany

BOneToOne

CManyToMany

DManyToOne

Attempts:

3 left

💡 Hint

Common Mistakes

Using @OneToMany instead of @ManyToMany

Forgetting to import the correct annotation

Using @ManyToOne which is for many-to-one relationships

The @ManyToMany annotation defines a many-to-many relationship between entities.

2fill in blank

medium

Complete the code to specify the join table for the many-to-many relationship.

Spring Boot

import jakarta.persistence.*;
import java.util.*;

@Entity
public class Student {

    @ManyToMany
    @[1](
        name = "student_course",
        joinColumns = @JoinColumn(name = "student_id"),
        inverseJoinColumns = @JoinColumn(name = "course_id")
    )
    private Set<Course> courses = new HashSet<>();

    // getters and setters
}

Drag options to blanks, or click blank then click option'

AJoinTable

BEntity

CJoinColumn

DTable

Attempts:

3 left

💡 Hint

Common Mistakes

Using @JoinColumn instead of @JoinTable for the join table

Using @Table which is for entity tables, not join tables

The @JoinTable annotation defines the join table and join columns for a many-to-many relationship.

3fill in blank

hard

Fix the error in the code to correctly map the many-to-many relationship inverse side.

Spring Boot

import jakarta.persistence.*;
import java.util.*;

@Entity
public class Course {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String title;

    @ManyToMany(mappedBy = "[1]")
    private Set<Student> students = new HashSet<>();

    // getters and setters
}

Drag options to blanks, or click blank then click option'

Acourses

Bstudents

Ctitle

Did

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'students' instead of 'courses' in mappedBy

Using a field name that does not exist

The mappedBy attribute should match the name of the collection in the owning entity, which is courses in Student.

4fill in blank

hard

Fill both blanks to complete the code for the join table with cascade and fetch type.

Spring Boot

import jakarta.persistence.*;
import java.util.*;

@Entity
public class Student {

    @ManyToMany(cascade = CascadeType.[1], fetch = FetchType.[2])
    @JoinTable(
        name = "student_course",
        joinColumns = @JoinColumn(name = "student_id"),
        inverseJoinColumns = @JoinColumn(name = "course_id")
    )
    private Set<Course> courses = new HashSet<>();

    // getters and setters
}

Drag options to blanks, or click blank then click option'

AALL

BEAGER

CLAZY

DREMOVE

Attempts:

3 left

💡 Hint

Common Mistakes

Using FetchType.EAGER which loads immediately and can cause performance issues

Using CascadeType.REMOVE only instead of ALL

CascadeType.ALL applies all cascade operations. FetchType.LAZY delays loading related entities until needed.

5fill in blank

hard

Fill all three blanks to complete the bidirectional many-to-many relationship with proper annotations and collection types.

Spring Boot

import jakarta.persistence.*;
import java.util.*;

@Entity
public class Course {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String title;

    @ManyToMany(mappedBy = "[1]", cascade = CascadeType.[2], fetch = FetchType.[3])
    private Set<Student> students = new HashSet<>();

    // getters and setters
}

Drag options to blanks, or click blank then click option'

Acourses

BALL

CLAZY

DList

Attempts:

3 left

💡 Hint

Common Mistakes

Using List instead of Set for many-to-many collections

Incorrect mappedBy value

Using FetchType.EAGER unnecessarily

The mappedBy should be 'courses' to match the owning side. Cascade type ALL applies all cascade operations. Fetch type LAZY delays loading until needed.

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