@OneToOne relationship in Spring Boot - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to declare a one-to-one relationship in a Spring Boot entity.

Spring Boot

public class User {
    @[1]
    private Profile profile;
}

Drag options to blanks, or click blank then click option'

AOneToOne

BManyToMany

COneToMany

DManyToOne

Attempts:

3 left

💡 Hint

Common Mistakes

Using @OneToMany or @ManyToOne which define different relationships.

Forgetting the '@' symbol before the annotation.

The @OneToOne annotation defines a one-to-one relationship between two entities.

2fill in blank

medium

Complete the code to specify the owning side of a one-to-one relationship with a join column.

Spring Boot

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

Drag options to blanks, or click blank then click option'

AMappedBy

BJoinTable

CColumn

DJoinColumn

Attempts:

3 left

💡 Hint

Common Mistakes

Using @JoinTable instead of @JoinColumn for one-to-one relationships.

Confusing @Column with @JoinColumn.

The @JoinColumn annotation specifies the foreign key column in the owning entity.

3fill in blank

hard

Fix the error in the mappedBy attribute to correctly define the inverse side of the one-to-one relationship.

Spring Boot

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

Drag options to blanks, or click blank then click option'

AprofileId

Buser

Cprofile

DuserId

Attempts:

3 left

💡 Hint

Common Mistakes

Using the class name instead of the field name in mappedBy.

Using the wrong field name that does not exist in the owning entity.

The mappedBy value should be the name of the field in the owning entity that owns the relationship, here 'profile'.

4fill in blank

hard

Fill both blanks to complete the bidirectional one-to-one relationship between User and Profile.

Spring Boot

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

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

Drag options to blanks, or click blank then click option'

AJoinColumn

BJoinTable

Cprofile

Duser

Attempts:

3 left

💡 Hint

Common Mistakes

Mixing up JoinColumn and JoinTable annotations.

Using the wrong field name in mappedBy.

The owning side uses @JoinColumn and the inverse side uses mappedBy with the owning side's field name.

5fill in blank

hard

Fill all three blanks to create a one-to-one relationship with cascade and fetch type settings.

Spring Boot

public class User {
    @OneToOne(cascade = CascadeType.[1], fetch = FetchType.[2])
    @JoinColumn(name = "profile_id")
    private Profile [3];
}

Drag options to blanks, or click blank then click option'

AALL

BEAGER

Cprofile

DLAZY

Attempts:

3 left

💡 Hint

Common Mistakes

Using LAZY fetch when eager loading is intended.

Using incorrect cascade types like PERSIST only.

Naming the field something other than 'profile'.

cascade = CascadeType.ALL applies all cascade operations, fetch = FetchType.EAGER loads the related entity immediately, and the field name is 'profile'.

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