Guide to create One to One Mapping in Spring Boot using JPA

One to One Relationship using JPA in Spring Boot Application | Unidirectional and Bidirectional

JPA(Java Persistence API) is specification that used object relation mapping to manage relational data in Java application.

In this tutorial, we will see how to create Spring Boot application that uses One to One mapping relation. 

In past tutorial, We had already seen Spring Boot CRUD operation So please check out first for better understanding of one-to-one mapping.

• Spring Boot Crud Operation with Thymeleaf, JPA and MySql Database
  

We will use tow entities, User and UserDetails for our tutorial. 

Unidirectional One to One Mapping :

If one persistence object uses other and in back if other is not using the first persistence object then it becomes unidirectional.

@OneToOne mapping uses FetchType.Lazy loading strategy. 

In Unidirectional mapping, we add @OneToOne mapping in only one class. So in User class we annotate UserProfile field with @OneToOne mapping.

User.java

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.OneToOne;
import javax.persistence.Table;

@Entity
@Table(name = "User")
public class User {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private int userId;
    
    @Column
    private String userName;
    
    @OneToOne
    private UserProfile userProfile;

    public int getUserId() {
        return userId;
    }

    public void setUserId(int userId) {
        this.userId = userId;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public UserProfile getUserProfile() {
        return userProfile;
    }

    public void setUserProfile(UserProfile userProfile) {
        this.userProfile = userProfile;
    }
}

UserProfile.java

@Entity
@Table(name = "UserProfile")
public class UserProfile {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private int userProfileId;
    
    @Column
    private int age;
    
    @Column
    private String country;

    public int getUserProfileId() {
        return userProfileId;
    }

    public void setUserProfileId(int userProfileId) {
        this.userProfileId = userProfileId;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getCountry() {
        return country;
    }

    public void setCountry(String country) {
        this.country = country;
    }
    
}

When you run application, It will create "user_profile_id" column in User table. It is called foreign key column.

@JoinTable Annotation

Change Foreign Key Column name using @JoinTable

If you want to change name of "user_profile_id" foreign key, @JoinTable annotation is used. @JoinColumn annotation is not mandatory to write.

User.java

    @OneToOne
    @JoinColumn(name = "UserProfile")
    private UserProfile userProfile;

Bidirectional One to One Mapping :

In bidirectional mapping, both entities fields are defined by @OneToOne mapping. 

In User entity, we already created ne-to-one mapping on UserProfile. Now we will also define User field as one-to-one mapping in UserProfile entity.

UserProfile.java    

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

    public User getUser() {
        return user;
    }

    public void setUser(User user) {
        this.user = user;
    }

After restarting application, UserProfile table display new column, named "user".

MappedBy Property in One-to-One mapping

In Bidirectional, both tables are displaying foreign key. But if we want to display in only any one of the table we can use mappedBy property in @OneToOne annotation. 

Like, If we only want to display User foreign key in UserProfile table, and don't want to display UserProfile foreign key into User table we can simply add @OneToOne(mappedBy = "user") where "user" is filed in UserProfile entity.

User.java

    @OneToOne(mappedBy = "user")  // use field present in UserProfile entity
    @JoinColumn(name = "UserProfile")
    private UserProfile userProfile;

After this User table contains only two columns :

1. user_id
2. user_name

Conclusion :

In this tutorial, 

• We learned how to use @OneToOne mapping in SpringBoot JPA. 
• We learned how to change foreign key column name using @JoinColumn annotation. 
• We also seen how to use mappedBy property in @OneToOne annotation for displaying foreign key only in one table not in both.

 

Similar Articles :

• Spring Boot CRUD operation with Rest API, JPA and MySql 
• Role based Authorization (Admin and Other User) and Permissions in Spring Security with Spring Boot
• Difference between JpaRepository and CrudRepository in Spring Data JPA