Introduction

When designing a relational database in Java, one of the most essential relationships you’ll come across is Many-to-One mapping. It allows multiple entities to be linked to a single parent entity, making data organization more efficient.

In this blog, we’ll break it down so that you can:

  • Understand what Many-to-One mapping is.
  • Implement it using Spring Boot, JPA, and Hibernate.
  • Explore real-world use cases for this relationship.

Let’s dive in! 🚀

Image description

What is Many-to-One Mapping?

A Many-to-One relationship means that many child entities are associated with a single parent entity.

Real-World Examples:

  • Many employees belong to one department.
  • Many orders are placed by one customer.
  • Many books are written by one author.

In database terms, this means that the child table contains a foreign key referencing the primary key of the parent table.

JPA makes it easy to define this relationship using the @ManyToOne annotation. Let’s see how to implement it! 🔥

Implementing Many-to-One Mapping in Spring Boot

1️⃣ Many-to-One Using a Foreign Key (Recommended ✅)

The most common approach is to have a foreign key in the child table pointing to the parent table.

📌 Step 1: Create the Department Entity (Parent) 

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

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

    @OneToMany(mappedBy = "department", cascade = CascadeType.ALL)
    private List<Employee> employees;

    // Getters and Setters
}

📌 Step 2: Create the Employee Entity (Child) 

import jakarta.persistence.*;

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

    @ManyToOne
    @JoinColumn(name = "department_id", nullable = false)
    private Department department;

    // Getters and Setters
}

🔹 Explanation:

  • The Department entity has a List to represent multiple employees.
  • @ManyToOne in Employee establishes a relationship where many employees belong to one department.
  • @JoinColumn(name = "department_id") in Employee stores the foreign key reference to the Department table.

💡 Tip: The cascade = CascadeType.ALL in Department ensures that deleting a department also removes all associated employees.

2️⃣ Many-to-One Using a Join Table 🏛️

Sometimes, instead of storing a foreign key in the child table, you might want a separate table to manage the relationship.

📌 Modify the Employee Entity 

@ManyToOne(cascade = CascadeType.ALL)
@JoinTable(
    name = "employee_department",
    joinColumns = @JoinColumn(name = "employee_id"),
    inverseJoinColumns = @JoinColumn(name = "department_id")
)
private Department department;

🔹 This creates an employee_department table that holds employee_id and department_id, linking both tables.

When to Use Many-to-One Mapping?

Many-to-One relationships are useful when:
✅ Multiple child entities are linked to a single parent (e.g., employees in a department).
✅ You need to maintain data integrity by enforcing a clear relationship.
✅ You want to avoid duplicate data while ensuring efficient queries.

Conclusion 🎯

In this article, we explored:

  • What Many-to-One mapping is.
  • How to implement it in Spring Boot using JPA.
  • Different approaches (foreign key vs. join table).
  • When to use it in real-world applications.

Many-to-One mapping is one of the most widely used relationships in databases. Understanding it will help you build scalable applications efficiently! 🚀

💬 Have questions? Let me know in the comments! Happy coding! 😃