@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.