Why relationships matter in JPA in Spring Boot - Test Your Understanding

Practice - 5 Tasks

1fill in blank

easy

Complete the code to define a one-to-many relationship in JPA.

Spring Boot

@Entity
public class Author {
    @Id
    private Long id;
    
    @OneToMany(mappedBy = [1])
    private List<Book> books;
}

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

Aauthor

BauthorId

Cbooks

Dbook

Attempts:

3 left

💡 Hint

Common Mistakes

Using the wrong field name in mappedBy causes errors.

Confusing the collection name with the mappedBy value.

The mappedBy attribute refers to the field name in the related entity that owns the relationship. Here, it should be author as defined in the Book entity.

2fill in blank

medium

Complete the code to specify the owning side of a many-to-one relationship.

Spring Boot

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

    @ManyToOne
    @JoinColumn(name = [1])
    private Author author;
}

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

A"book_id"

B"id"

C"author_id"

D"authorName"

Attempts:

3 left

💡 Hint

Common Mistakes

Using the wrong column name causes database errors.

Omitting quotes around the column name.

The @JoinColumn specifies the foreign key column in the Book table that links to the Author. It is commonly named author_id.

3fill in blank

hard

Fix the error in the code to correctly define a bidirectional one-to-one relationship.

Spring Boot

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

    @OneToOne(mappedBy = [1])
    private Profile profile;
}

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

    @OneToOne
    @JoinColumn(name = "user_id")
    private User user;
}

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

Auser

BprofileId

Cprofile

DuserId

Attempts:

3 left

💡 Hint

Common Mistakes

Using the wrong field name in mappedBy causes runtime errors.

Confusing the owning and inverse sides.

The mappedBy in User should refer to the field name in Profile that owns the relationship, which is user.

4fill in blank

hard

Fill both blanks to create a many-to-many relationship with a join table.

Spring Boot

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

    @ManyToMany
    @JoinTable(name = [1],
        joinColumns = @JoinColumn(name = [2]))
    private Set<Course> courses;
}

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

A"student_course"

B"student_id"

C"course_id"

D"course_student"

Attempts:

3 left

💡 Hint

Common Mistakes

Mixing up join table and join column names.

Using the wrong entity name in joinColumns.

The join table is commonly named combining both entities, e.g., student_course. The joinColumns refers to the foreign key column for the owning entity, here student_id.

5fill in blank

hard

Fill all three blanks to define a unidirectional one-to-many relationship with cascade and fetch type.

Spring Boot

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

    @OneToMany(cascade = [1], fetch = [2])
    @JoinColumn(name = [3])
    private List<Employee> employees;
}

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

ACascadeType.ALL

BFetchType.LAZY

C"department_id"

DFetchType.EAGER

Attempts:

3 left

💡 Hint

Common Mistakes

Using FetchType.EAGER can cause performance issues.

Forgetting to specify the join column name.

CascadeType.ALL applies all cascade operations. FetchType.LAZY delays loading employees until needed. The join column department_id links employees to the department.

Practice

1. Why are relationships important in JPA when working with entities?

easy

A. They allow easy navigation and management of related data between entities.

B. They improve the speed of the Java compiler.

C. They automatically generate user interfaces for entities.

D. They replace the need for database tables.

Solution

1. Step 1: Understand the role of relationships in JPA

   Relationships link entities so you can access related data easily, like a map connecting places.

2. Step 2: Recognize the benefit of these links

   They help manage and query related data without manual joins or extra queries.

3. Final Answer:

   They allow easy navigation and management of related data between entities. -> Option A

4. Quick Check:

   Relationships = Easy data navigation [OK]

Hint: Think of relationships as bridges connecting data [OK]

Common Mistakes:

• Confusing relationships with UI features
• Assuming relationships speed up compilation
• Believing relationships remove database tables

2. Which annotation correctly defines a many-to-one relationship in JPA?

easy

A. @OneToMany

B. @ManyToMany

C. @ManyToOne

D. @OneToOne

Solution

1. Step 1: Recall JPA relationship annotations

   @ManyToOne is used when many entities relate to one entity, like many orders to one customer.

2. Step 2: Match the annotation to the relationship type

   @ManyToOne fits the question, others represent different relationships.

3. Final Answer:

   @ManyToOne -> Option C

4. Quick Check:

   @ManyToOne = many to one link [OK]

Hint: Many to one? Use @ManyToOne annotation [OK]

Common Mistakes:

• Using @OneToMany instead of @ManyToOne
• Confusing @OneToOne with many-to-one
• Mixing up @ManyToMany for simple many-to-one

3. Given the following JPA entities, what will be the output when fetching a Book and accessing its author.getName()?

@Entity
class Book {
  @Id
  Long id;
  String title;
  @ManyToOne
  Author author;
}

@Entity
class Author {
  @Id
  Long id;
  String name;
}

medium

A. NullPointerException because author is not initialized.

B. A compilation error due to missing @JoinColumn annotation.

C. The book's title will be returned instead of the author's name.

D. The author's name linked to the book will be returned.

Solution

1. Step 1: Understand the @ManyToOne relationship

   The Book entity has a many-to-one link to Author, so each book has one author object.

2. Step 2: Accessing author.getName()

   When fetching a Book, JPA loads the linked Author, so calling getName() returns the author's name.

3. Final Answer:

   The author's name linked to the book will be returned. -> Option D

4. Quick Check:

   Book.author.getName() = Author's name [OK]

Hint: ManyToOne means book has one author object [OK]

Common Mistakes:

• Assuming missing @JoinColumn causes compile error
• Expecting NullPointerException without checking data
• Confusing book title with author name

4. Identify the error in this JPA relationship mapping:

@Entity
class Order {
  @Id
  Long id;
  @OneToMany
  Customer customer;
}

medium

A. Using @OneToMany on a single Customer field instead of a collection.

B. Missing @Id annotation on Customer entity.

C. Order entity should not have any relationships.

D. The @OneToMany annotation should be replaced with @ManyToOne.

Solution

1. Step 1: Check the @OneToMany usage

   @OneToMany expects a collection (like List or Set), not a single object.

2. Step 2: Identify the field type mismatch

   The field 'customer' is a single Customer, so @OneToMany is incorrect here.

3. Final Answer:

   Using @OneToMany on a single Customer field instead of a collection. -> Option A

4. Quick Check:

   @OneToMany needs collection, not single object [OK]

Hint: @OneToMany always needs a collection type [OK]

Common Mistakes:

• Applying @OneToMany to a single entity field
• Ignoring collection requirement for @OneToMany
• Confusing relationship direction annotations

5. You have two entities: Student and Course. A student can enroll in many courses, and a course can have many students. Which JPA relationship setup correctly models this, and why is it important to define it properly?

hard

A. Use @OneToMany on Student and @ManyToOne on Course; it simplifies the database schema.

B. Use @ManyToMany on both sides with a join table; it ensures proper linking and querying of students and courses.

C. Use @OneToOne on both entities; it guarantees unique pairs.

D. No relationship annotations needed; just store IDs manually.

Solution

1. Step 1: Identify the relationship type

   Many students can enroll in many courses, so the relationship is many-to-many.

2. Step 2: Choose correct annotations and explain importance

   @ManyToMany on both sides with a join table models this correctly, allowing JPA to manage links and queries efficiently.

3. Final Answer:

   Use @ManyToMany on both sides with a join table; it ensures proper linking and querying of students and courses. -> Option B

4. Quick Check:

   Many-to-many needs @ManyToMany with join table [OK]

Hint: Many-to-many? Use @ManyToMany with join table [OK]

Common Mistakes:

• Using one-to-many for many-to-many relationships
• Skipping relationship annotations and managing IDs manually
• Using one-to-one where many-to-many is needed