Spring Boot: JPA One-to-One Mapping

Introduction

When working with relational databases in Java, JPA (Java Persistence API) makes it easier to map relationships between entities. One of the most fundamental relationships is One-to-One mapping. In this blog, we'll break it down in a way that makes it simple and enjoyable to learn!

By the end of this article, you'll understand:

• What One-to-One mapping is.
• How to implement it in Spring Boot with JPA and Hibernate.
• The different ways to set up the relationship.
• Practical use cases for real-world applications.

Let's dive in! 🚀

What is One-to-One Mapping?

A One-to-One relationship means that one entity is associated with exactly one other entity. For example:

• A User can have exactly one Profile.
• A Car can have exactly one Engine.

In database terms, this means that the primary key of one table is linked to the primary key of another table.

How Does One-to-One Mapping Work in JPA?

JPA provides the @OneToOne annotation to define this relationship. There are different ways to implement it, depending on how you design your database:

1. Using a Foreign Key (Recommended) ✅
2. Using a Shared Primary Key 🔑
3. Using a Join Table 🏛️

Let's see how we can implement these approaches in Spring Boot!

Implementing One-to-One Mapping in Spring Boot

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

The most common way to set up a One-to-One relationship is by using a foreign key. Here’s how we do it:

📌 Step 1: Create the User Entity

import jakarta.persistence.*; @Entity public class User { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Long id; private String name; @OneToOne(cascade = CascadeType.ALL) @JoinColumn(name = "profile_id", referencedColumnName = "id") private Profile profile; // Getters and Setters } 

📌 Step 2: Create the Profile Entity

import jakarta.persistence.*; @Entity public class Profile { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Long id; private String bio; private String website; // Getters and Setters } 

🔹 In the User entity, we used @OneToOne and @JoinColumn(name = "profile_id") to specify that the profile_id column in the User table acts as a foreign key pointing to the id column in the Profile table.

2️⃣ One-to-One Mapping Using a Shared Primary Key

In this approach, the primary key of one table is also used as the primary key of another table.

📌 Update the Profile Entity

@Entity public class Profile { @Id private Long id; private String bio; private String website; @OneToOne @MapsId @JoinColumn(name = "id") private User user; } 

🔹 The @MapsId annotation ensures that the Profile entity shares the same primary key as User.

3️⃣ One-to-One Mapping Using a Join Table

Sometimes, you may want a third table to manage the relationship. In this case, JPA allows us to use @JoinTable.

📌 Modify the User Entity

@OneToOne(cascade = CascadeType.ALL) @JoinTable(name = "user_profile", joinColumns = @JoinColumn(name = "user_id"), inverseJoinColumns = @JoinColumn(name = "profile_id")) private Profile profile; 

🔹 This approach creates a user_profile table that holds the user_id and profile_id columns, acting as a bridge between User and Profile.

When to Use One-to-One Mapping?

One-to-One relationships are useful in scenarios where:
✅ The related data is rarely accessed separately (e.g., user profile information).
✅ You need data integrity with clear ownership (e.g., a unique identity document per user).
✅ You want to simplify queries and avoid data duplication.

Conclusion 🎯

In this article, we explored:

• What One-to-One mapping is.
• Three ways to implement it in Spring Boot with JPA.
• When to use each approach.

One-to-One mapping is a powerful way to structure your database relationships effectively. Mastering it will help you build better, more scalable applications! 🚀

💬 Got questions or feedback? Drop a comment below! Happy coding! 😃