Entity Relationships in Spring Data JPA

In real-world applications, data is often related. For example:

• A user may have one profile
• A customer can place many orders
• A student can enroll in many courses

Entity Relationships in Spring Data JPA (with Hibernate) allows you to map these relationships easily using annotations.

This guide will explain:

• What are entity relationships?
• @OneToOne mapping
• @OneToMany and @ManyToOne mapping
• @ManyToMany mapping
• Examples for each with code

🔗 What Are Entity Relationships in Spring Data JPA?

In databases, relationships describe how tables are connected:

1️⃣ OneToOne Mapping

💡 Example: A User has one Profile

🔧 User Entity

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

    @OneToOne(mappedBy = "user", cascade = CascadeType.ALL)
    private Profile profile;

    // getters and setters
}

🔧 Profile Entity

@Entity
public class Profile {
    @Id @GeneratedValue
    private Long id;
    private String bio;

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

    // getters and setters
}

✅ Notes:

• mappedBy: used on the non-owning side
• @JoinColumn: used on the owning side to define the foreign key

2️⃣ OneToMany and ManyToOne Mapping

💡 Example: A Customer has many Orders

🔧 Customer Entity

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

    @OneToMany(mappedBy = "customer", cascade = CascadeType.ALL)
    private List orders = new ArrayList<>();

    // getters and setters
}

🔧 Order Entity

@Entity
public class Order {
    @Id @GeneratedValue
    private Long id;
    private String product;

    @ManyToOne
    @JoinColumn(name = "customer_id")
    private Customer customer;

    // getters and setters
}

✅ Notes:

• @OneToMany is typically placed on the parent side
• @ManyToOne defines the foreign key in the child

3️⃣ ManyToMany Mapping

💡 Example: A Student can enroll in many Courses and a Course can have many Students

🔧 Student Entity

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

    @ManyToMany
    @JoinTable(
        name = "student_course",
        joinColumns = @JoinColumn(name = "student_id"),
        inverseJoinColumns = @JoinColumn(name = "course_id")
    )
    private List courses = new ArrayList<>();

    // getters and setters
}

🔧 Course Entity

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

    @ManyToMany(mappedBy = "courses")
    private List students = new ArrayList<>();

    // getters and setters
}

✅ Notes:

• @JoinTable creates a third (join) table to hold many-to-many relationships
• mappedBy is used on the inverse side

🔍 How to Test These Relationships

You can create sample data in a CommandLineRunner or using a controller:

@Bean
CommandLineRunner run(StudentRepository studentRepo, CourseRepository courseRepo) {
    return args -> {
        Course java = new Course("Java Basics");
        Course spring = new Course("Spring Boot");

        Student student = new Student("Alice");
        student.getCourses().add(java);
        student.getCourses().add(spring);

        java.getStudents().add(student);
        spring.getStudents().add(student);

        studentRepo.save(student);
    };
}

🧼 Cascading and Fetch Types

Cascade Types:

• CascadeType.PERSIST: Propagates save
• CascadeType.REMOVE: Deletes child when parent is deleted
• CascadeType.ALL: All operations are cascaded

Fetch Types:

• FetchType.LAZY: Loads only when needed
• FetchType.EAGER: Loads immediately

💡 Prefer LAZY for large data sets to avoid performance issues.

✅ Summary

📌 Best Practices

• Always define mappedBy on the non-owning side
• Use @JoinColumn to customize foreign key column names
• Avoid FetchType.EAGER unless really necessary
• Use DTOs for large/complex data instead of directly exposing entities

References

Spring JPA Docs