@OneToOne relationship in Spring Boot - Step-by-Step Execution

Concept Flow - @OneToOne relationship

Define Entity A

↓

Define Entity B

↓

Add @OneToOne in Entity A

↓

Add @OneToOne in Entity B (optional)

↓

Save Entity A with Entity B

↓

Database stores linked records

↓

Fetch Entity A retrieves Entity B automatically

This flow shows how two entities are linked one-to-one by adding @OneToOne annotations and saving them, so fetching one gets the other.

Execution Sample

Spring Boot

import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.OneToOne;

@Entity
public class Person {
  @Id
  private Long id;

  @OneToOne
  private Passport passport;

  // getters and setters
}

@Entity
public class Passport {
  @Id
  private Long id;

  @OneToOne(mappedBy = "passport")
  private Person person;

  // getters and setters
}

Defines two classes Person and Passport linked by a one-to-one relationship using @OneToOne.

Execution Table

Step	Action	Entity State	Database State	Result
1	Create Person object	Person(passport=null)	Empty	Person created with no passport linked
2	Create Passport object	Passport(person=null)	Empty	Passport created with no person linked
3	Set Person.passport = Passport	Person(passport=Passport)	Empty	Person now references Passport
4	Set Passport.person = Person	Passport(person=Person)	Empty	Passport now references Person
5	Save Person to DB	Person(passport=Passport)	Person and Passport saved with link	Database stores linked records
6	Fetch Person from DB	Person(passport=Passport)	Person and Passport in DB	Person fetched with Passport linked
7	Fetch Passport from DB	Passport(person=Person)	Person and Passport in DB	Passport fetched with Person linked
8	End	Entities linked	Database consistent	One-to-one relationship established

💡 Entities saved and linked; fetching one entity retrieves the other automatically.

Variable Tracker

Variable	Start	After Step 3	After Step 4	After Step 5	Final
Person.passport	null	Passport object	Passport object	Passport object	Passport object
Passport.person	null	null	Person object	Person object	Person object

Key Moments - 3 Insights

Why do we set both sides of the relationship (Person.passport and Passport.person)?

Setting both sides keeps the Java objects in sync; execution_table steps 3 and 4 show this. Without both, one side may not reflect the link.

What happens if we save only Person without setting Passport.person?

The database will save the link from Person to Passport, but Passport.person may be null in Java until refreshed. See step 5 and 6 in execution_table.

Is the @OneToOne annotation required on both entities?

No, only one side needs @OneToOne; the other can use mappedBy to indicate the owner. This is shown in the sample code and steps 3 and 4.

Visual Quiz - 3 Questions

Look at the execution_table at step 4, what is the value of Passport.person?

A null

B Person object

C Passport object

D Undefined

💡 Hint

Check the 'Entity State' column at step 4 in execution_table.

At which step does the database first store the linked entities?

A Step 5

B Step 6

C Step 3

D Step 7

💡 Hint

Look for 'Database State' changes in execution_table rows.

If we skip setting Passport.person, what changes in the execution_table?

A Database does not save Passport

B Person.passport becomes null

C Passport.person remains null after step 4

D Person object is not created

💡 Hint

Refer to variable_tracker and step 4 in execution_table.

Concept Snapshot

@OneToOne links two entities so each has exactly one related entity.
Use @OneToOne on one side and optionally mappedBy on the other.
Set both sides in Java objects to keep them in sync.
Saving the owning side stores the link in the database.
Fetching one entity loads the linked entity automatically.

Full Transcript

The @OneToOne relationship in Spring Boot links two entities so each has exactly one related entity. You define two classes, for example Person and Passport, and add @OneToOne annotations to connect them. One side owns the relationship, the other uses mappedBy to point back. When you create objects, you set both sides to keep them in sync. Saving the owning entity stores both linked records in the database. Later, fetching one entity automatically loads the linked entity. This trace shows each step from creating objects, setting links, saving to the database, and fetching linked data. Key points are setting both sides and understanding which side owns the relationship.