@OneToOne relationship in Spring Boot - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What is the output when fetching a User with a @OneToOne mapped Address?

Given the following Spring Boot entities, what will be printed when fetching a User and printing its Address street?

Spring Boot

public class User {
  @Id
  private Long id;

  @OneToOne(cascade = CascadeType.ALL)
  @JoinColumn(name = "address_id")
  private Address address;

  public Address getAddress() { return address; }
}

public class Address {
  @Id
  private Long id;
  private String street;

  public String getStreet() { return street; }
}

// Assume userRepository.findById(1L) returns a User with Address street = "Main St"

A null

B Throws LazyInitializationException

C "Main St"

D "" (empty string)

💡 Hint

Consider the default fetch type of @OneToOne and if the session is open when accessing the address.

By default, @OneToOne uses EAGER fetching, so the Address is loaded with the User. Therefore, printing the street outputs "Main St".

📝 Syntax

intermediate

Which code snippet correctly defines a bidirectional @OneToOne relationship?

Choose the correct code snippet that sets up a bidirectional @OneToOne relationship between User and Profile entities.

A

public class User {
  @OneToOne
  @JoinColumn(name = "profile_id")
  private Profile profile;
}

public class Profile {
  @OneToOne(mappedBy = "profile")
  private User user;
}

B

public class User {
  @OneToOne(mappedBy = "user")
  private Profile profile;
}

public class Profile {
  @OneToOne
  @JoinColumn(name = "user_id")
  private User user;
}

C

public class User {
  @OneToOne
  private Profile profile;
}

public class Profile {
  @OneToOne
  private User user;
}

D

public class User {
  @OneToOne(mappedBy = "profile")
  private Profile profile;
}

public class Profile {
  @OneToOne
  @JoinColumn(name = "user_id")
  private User user;
}

💡 Hint

Remember the owning side has the @JoinColumn annotation and the inverse side uses mappedBy.

The owning side is Profile with @JoinColumn. User uses mappedBy to point to Profile's user field. This setup creates a bidirectional @OneToOne.

🔧 Debug

advanced

Why does this @OneToOne mapping cause a runtime error?

Consider this code snippet:

public class Employee {
  @OneToOne
  private ParkingSpot spot;
}

public class ParkingSpot {
  @OneToOne
  private Employee employee;
}

When saving an Employee, a runtime exception occurs. What is the cause?

A Missing @JoinColumn on owning side causes Hibernate to fail determining the foreign key.

B CascadeType.ALL is missing, so related entities are not saved automatically.

C The entities must use @MapsId to share the same primary key.

D The fetch type must be LAZY to avoid infinite recursion.

💡 Hint

Check which side owns the relationship and if the foreign key column is defined.

Without @JoinColumn on one side, Hibernate cannot know which table owns the foreign key, causing a runtime error.

❓ state_output

advanced

What is the state of the database after saving a User with a @OneToOne Address?

Given these entities:

public class User {
  @Id
  private Long id;

  @OneToOne(cascade = CascadeType.PERSIST)
  @JoinColumn(name = "address_id")
  private Address address;
}

public class Address {
  @Id
  private Long id;
  private String city;
}

If you create a User and set a new Address (without saving Address separately) and then save User, what happens in the database?

A User is saved with address_id null; Address is saved separately later.

B Only User is saved; Address is ignored because it was not saved explicitly.

C Saving User fails with a foreign key constraint error because Address ID is null.

D Both User and Address are saved; Address gets an ID and User's address_id points to it.

💡 Hint

Think about what CascadeType.PERSIST does when saving related entities.

CascadeType.PERSIST causes the Address to be saved automatically when saving User, so both are persisted and linked.

🧠 Conceptual

expert

Which statement about @OneToOne fetch types is true?

Consider the default fetch types in JPA for @OneToOne and @ManyToOne. Which statement is correct?

A @OneToOne defaults to EAGER fetch, which can cause performance issues if not managed.

B @OneToOne defaults to LAZY fetch, so related entities load only when accessed.

C @ManyToOne defaults to LAZY fetch, while @OneToOne defaults to LAZY as well.

D @OneToOne and @ManyToOne both default to EAGER fetch for simplicity.

💡 Hint

Recall the JPA specification defaults for fetch types on these annotations.

@OneToOne defaults to EAGER fetch, meaning related entities load immediately, which can impact performance if not handled carefully.

Practice

1. What does the @OneToOne annotation represent in Spring Boot JPA?

easy

A. A relationship where one entity is linked to exactly one other entity

B. A relationship where one entity is linked to many entities

C. A relationship where many entities are linked to many entities

D. A relationship where entities are not linked at all

Solution

1. Step 1: Understand the meaning of @OneToOne

   The @OneToOne annotation defines a direct one-to-one link between two entities in JPA.

2. Step 2: Compare with other relationship types

   Unlike @OneToMany or @ManyToMany, @OneToOne means exactly one entity matches exactly one other entity.

3. Final Answer:

   A relationship where one entity is linked to exactly one other entity -> Option A

4. Quick Check:

   @OneToOne = one-to-one link [OK]

Hint: One entity matches exactly one other entity [OK]

Common Mistakes:

• Confusing @OneToOne with @OneToMany
• Thinking it allows multiple linked entities
• Ignoring the uniqueness of the relationship

2. Which annotation is used on the owning side of a @OneToOne relationship to specify the foreign key column?

easy

A. @MappedBy

B. @Column

C. @JoinColumn

D. @Entity

Solution

1. Step 1: Identify the owning side annotation

   The owning side uses @JoinColumn to specify the foreign key column in the database.

2. Step 2: Differentiate from mappedBy

   @MappedBy is used on the inverse side, not the owning side.

3. Final Answer:

   @JoinColumn -> Option C

4. Quick Check:

   Owning side uses @JoinColumn [OK]

Hint: Owning side uses @JoinColumn for foreign key [OK]

Common Mistakes:

• Using @MappedBy on owning side
• Confusing @Column with @JoinColumn
• Forgetting to specify @JoinColumn

3. Given the following code snippet, what will be the output when fetching Person and accessing person.getPassport().getNumber()?

@Entity
class Person {
  @Id
  private Long id;

  @OneToOne
  @JoinColumn(name = "passport_id")
  private Passport passport;

  // getters and setters
}

@Entity
class Passport {
  @Id
  private Long id;
  private String number;

  // getters and setters
}

medium

A. Throws NullPointerException because passport is not initialized

B. Returns the passport number linked to the person

C. Returns null because @OneToOne is missing mappedBy

D. Compilation error due to missing @MappedBy

Solution

1. Step 1: Analyze the @OneToOne mapping

   The Person entity owns the relationship with @JoinColumn, so passport is linked properly.

2. Step 2: Understand the data fetching

   When fetching Person, accessing person.getPassport().getNumber() returns the linked Passport's number if data exists.

3. Final Answer:

   Returns the passport number linked to the person -> Option B

4. Quick Check:

   Proper @OneToOne with @JoinColumn returns linked entity [OK]

Hint: Owning side with @JoinColumn returns linked entity [OK]

Common Mistakes:

• Assuming mappedBy is required on owning side
• Expecting NullPointerException without data check
• Confusing compilation errors with runtime behavior

4. Identify the error in this @OneToOne mapping:

@Entity
class User {
  @Id
  private Long id;

  @OneToOne(mappedBy = "user")
  private Profile profile;
}

@Entity
class Profile {
  @Id
  private Long id;

  @OneToOne
  private User user;
}

medium

A. Missing @JoinColumn on Profile entity owning side

B. mappedBy should be on Profile, not User

C. User entity should not have @OneToOne annotation

D. Profile entity must use mappedBy instead of @OneToOne

Solution

1. Step 1: Check owning side annotations

   Profile is the owning side but lacks @JoinColumn to specify the foreign key.

2. Step 2: Understand mappedBy usage

   mappedBy is correctly on User side, indicating inverse side.

3. Final Answer:

   Missing @JoinColumn on Profile entity owning side -> Option A

4. Quick Check:

   Owning side needs @JoinColumn [OK]

Hint: Owning side must have @JoinColumn [OK]

Common Mistakes:

• Placing mappedBy on owning side
• Omitting @JoinColumn on owning side
• Confusing owning and inverse sides

5. You want to create a bidirectional @OneToOne relationship between Employee and Desk. Which is the correct way to define the relationship so that Employee owns the relationship and the foreign key is in the Desk table?

hard

A. In Employee: @OneToOne(mappedBy = "desk") Desk desk; In Desk: @OneToOne @JoinColumn Employee employee;

B. In Employee: @OneToOne @JoinColumn Desk desk; In Desk: @OneToOne(mappedBy = "desk") Employee employee;

C. ;eeyolpme eeyolpmE nmuloCnioJ@ enOoTenO@ :kseD nI ;ksed kseD )"eeyolpme" = yBdeppam(enOoTenO@ :eeyolpmE nI

D. In Employee: @OneToOne(mappedBy = "employee") Desk desk; In Desk: @OneToOne @JoinColumn Employee employee;

Solution

1. Step 1: Determine owning side and foreign key location

   The foreign key is in Desk table, so Desk owns the relationship.

2. Step 2: Correct annotation placement

   Desk must have @JoinColumn and no mappedBy; Employee uses mappedBy to point to Desk's field.

3. Step 3: Match option with correct annotations

   In Employee: @OneToOne(mappedBy = "employee") Desk desk; In Desk: @OneToOne @JoinColumn Employee employee; matches this.

4. Final Answer:

   In Employee: @OneToOne(mappedBy = "employee") Desk desk; In Desk: @OneToOne @JoinColumn Employee employee; -> Option D

5. Quick Check:

   Foreign key side owns with @JoinColumn, other side uses mappedBy [OK]

Hint: Foreign key side owns with @JoinColumn, other side uses mappedBy [OK]

Common Mistakes:

• Assigning owning side incorrectly
• Placing mappedBy on owning side
• Confusing which table holds foreign key