Entity Relationships and Fetching Strategies

Welcome to this lesson on Entity Relationships in Spring Data JPA. In the previous lessons, we've covered the basics of JPA repositories and entities, using derived queries for simple methods, and creating query methods for more complex queries. In this lesson, we're going to discuss how to work with relationships between entities in Spring Data JPA.

Before diving into implementation, it's essential to understand the different types of relationships in the context of data persistence with Spring Data JPA:

• One-to-One: For example, a person and their passport. Each person has one passport, and each passport belongs to one person.
• One-to-Many: For example, one person can be assigned to many different ToDos, but one ToDo cannot be assigned to multiple people.
• Many-to-One: This is just the previous example but viewed from the opposite direction — many ToDos are assigned to the same person.
• Many-to-Many: For example, Google Docs and collaborators. Each person can work on many docs, and each doc can have many collaborators.

Let’s start with the One-to-One relationship. Here is a diagram to illustrate the One-to-One relationship between a person and their passport.

Explanation:

• PERSON and PASSPORT tables are shown with a one-to-one relationship.
• Each PERSON has one PASSPORT and each PASSPORT belongs to one PERSON.
• The ||--|| notation indicates this one-to-one relationship.
• Both tables contain an ID, and there are foreign keys (passportId in PERSON and personId in PASSPORT) representing the relationship.

Let's see how we can define a One-to-One relationship using JPA annotations:

package com.codesignal.entities;

import jakarta.persistence.*;

@Entity
@Table(name = "person")
public class Person {
    
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    private String name;

    @OneToOne(mappedBy = "person", cascade = CascadeType.ALL, fetch = FetchType.LAZY)
    private Passport passport;

    // Constructors, getters, and setters...
}

@Entity
@Table(name = "passport")
public class Passport {
    
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    private String number;

    @OneToOne
    @JoinColumn(name = "person_id")
    private Person person;

    // Constructors, getters, and setters...
}

In the Person class, the @OneToOne annotation indicates a one-to-one relationship with the Passport class. The mappedBy attribute specifies the field in the Passport class that owns the relationship. The cascade = CascadeType.ALL attribute indicates that all JPA-related changes (like persist, merge, remove, etc.) made to the Person entity should cascade to the associated Passport entity. The fetch = FetchType.LAZY attribute indicates that the Passport entity should be lazily loaded, meaning it will be fetched from the database only when explicitly accessed.

In the Passport class, the @OneToOne annotation defines the other end of the relationship with the Person class. The @JoinColumn annotation is used to specify the foreign key column (person_id) in the PASSPORT table that maps to the primary key of the PERSON table.