Why relationships matter in JPA in Spring Boot - See It in Action

Understanding Why Relationships Matter in JPA

📖 Scenario: You are building a simple Spring Boot application to manage a library. The library has authors and books. Each book is written by one author, and each author can write many books.To keep the data organized and connected, you need to use relationships in JPA (Java Persistence API). This helps the application understand how authors and books relate to each other.

🎯 Goal: Build two JPA entity classes, Author and Book, and connect them using a OneToMany and ManyToOne relationship. This will show how JPA manages related data automatically.

📋 What You'll Learn

Create an Author entity with id and name fields

Create a Book entity with id, title, and a reference to Author

Set up a OneToMany relationship from Author to Book

Set up a ManyToOne relationship from Book to Author

💡 Why This Matters

🌍 Real World

Managing related data like authors and books is common in library systems, online stores, and content management. Relationships help keep data consistent and easy to query.

💼 Career

Understanding JPA relationships is essential for backend developers working with databases in Java applications, especially in Spring Boot projects.

1

Create the Author entity

Create a JPA entity class called Author with fields id (annotated with @Id and @GeneratedValue) and name (type String). Use @Entity annotation on the class.

Spring Boot

@Entity
public class Author {
    // Your code here
}

Hint

Remember to import javax.persistence.Entity, javax.persistence.Id, and javax.persistence.GeneratedValue.

2

Create the Book entity with author reference

Create a JPA entity class called Book with fields id (annotated with @Id and @GeneratedValue), title (type String), and a field author of type Author annotated with @ManyToOne. Use @Entity annotation on the class.

Spring Boot

@Entity
public class Author {
    @Id
    @GeneratedValue
    private Long id;
    private String name;

    // Getters and setters
    public Long getId() {
        return id;
    }
    public void setId(Long id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}

@Entity
public class Book {
    // Your code here
}

Hint

Don't forget to import javax.persistence.ManyToOne for the author field.

3

Add OneToMany relationship in Author

In the Author class, add a field books of type List<Book> annotated with @OneToMany(mappedBy = "author"). Initialize it with an empty ArrayList. Add getter and setter for books.

Spring Boot

@Entity
public class Author {
    @Id
    @GeneratedValue
    private Long id;
    private String name;

    // Getters and setters
    public Long getId() {
        return id;
    }
    public void setId(Long id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }

    // Your code here
}

@Entity
public class Book {
    @Id
    @GeneratedValue
    private Long id;
    private String title;

    @ManyToOne
    private Author author;

    // Getters and setters
    public Long getId() {
        return id;
    }
    public void setId(Long id) {
        this.id = id;
    }
    public String getTitle() {
        return title;
    }
    public void setTitle(String title) {
        this.title = title;
    }
    public Author getAuthor() {
        return author;
    }
    public void setAuthor(Author author) {
        this.author = author;
    }
}

Hint

Use mappedBy = "author" to link to the author field in Book.

4

Complete the relationship setup

Ensure both Author and Book classes have proper imports for JPA annotations and collections. Confirm the Author class has @OneToMany(mappedBy = "author") on books and the Book class has @ManyToOne on author. This completes the bidirectional relationship.

Spring Boot

import java.util.ArrayList;
import java.util.List;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.GeneratedValue;
import javax.persistence.OneToMany;

@Entity
public class Author {
    @Id
    @GeneratedValue
    private Long id;
    private String name;

    @OneToMany(mappedBy = "author")
    private List books = new ArrayList();

    // Getters and setters
    public Long getId() {
        return id;
    }
    public void setId(Long id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public List getBooks() {
        return books;
    }
    public void setBooks(List books) {
        this.books = books;
    }
}

@Entity
public class Book {
    @Id
    @GeneratedValue
    private Long id;
    private String title;

    @ManyToOne
    private Author author;

    // Getters and setters
    public Long getId() {
        return id;
    }
    public void setId(Long id) {
        this.id = id;
    }
    public String getTitle() {
        return title;
    }
    public void setTitle(String title) {
        this.title = title;
    }
    public Author getAuthor() {
        return author;
    }
    public void setAuthor(Author author) {
        this.author = author;
    }
}

// Your code here to confirm imports and annotations

Hint

Check that all necessary imports and annotations are present for the relationship to work.

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