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

Concept Flow - @ManyToOne relationship

Define Entity A

↓

Add @ManyToOne field to Entity A

↓

Entity A references Entity B

↓

Save Entity A with Entity B linked

↓

Database stores foreign key in Entity A's table

↓

Fetch Entity A retrieves linked Entity B

Shows how one entity holds a reference to another using @ManyToOne, storing a foreign key and linking data.

Execution Sample

Spring Boot

import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.ManyToOne;

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

  @ManyToOne
  private Customer customer;

  // getters and setters
}

@Entity
public class Customer {
  @Id
  private Long id;
  private String name;

  // getters and setters
}

Defines Order entity with a ManyToOne link to Customer entity.

Execution Table

Step	Action	Entity State	Database Effect	Result
1	Create Customer object	Customer{name='Alice'}	No DB action yet	Customer ready
2	Create Order object	Order{customer=null}	No DB action yet	Order ready
3	Set Order.customer = Customer	Order{customer=Alice}	No DB action yet	Order linked to Customer
4	Save Customer to DB	Customer{id=1, name='Alice'}	Insert Customer row	Customer stored with id=1
5	Save Order to DB	Order{id=10, customer=Alice}	Insert Order row with customer_id=1	Order stored with FK to Customer
6	Fetch Order from DB	Order{id=10, customer_id=1}	Select Order row	Order loaded with customer_id=1
7	Fetch Customer from DB via Order	Customer{id=1, name='Alice'}	Select Customer row	Customer loaded and linked
8	End	-	-	Execution complete

💡 Execution stops after Order and Customer are saved and linked via foreign key.

Variable Tracker

Variable	Start	After Step 1	After Step 3	After Step 4	After Step 5	Final
customer	null	Customer{name='Alice'}	Customer{name='Alice'}	Customer{id=1, name='Alice'}	Customer{id=1, name='Alice'}	Customer{id=1, name='Alice'}
order	null	null	Order{customer=Alice}	Order{customer=Alice}	Order{id=10, customer=Alice}	Order{id=10, customer=Alice}

Key Moments - 3 Insights

Why does the Order entity store a foreign key instead of the whole Customer object in the database?

Because @ManyToOne creates a link via a foreign key column in Order's table pointing to Customer's primary key, not embedding the whole Customer data. See execution_table step 5.

What happens if you save Order before saving Customer?

The foreign key in Order would reference a Customer that doesn't exist yet, causing a database error. Step 4 must happen before step 5.

How does fetching Order also get the linked Customer?

When fetching Order, the foreign key customer_id is used to fetch the Customer entity separately, linking them in memory. See steps 6 and 7.

Visual Quiz - 3 Questions

Look at the execution_table at step 5, what database action happens?

A Update Customer row

B Insert Order row with customer_id foreign key

C Insert Customer row

D Delete Order row

💡 Hint

Check the 'Database Effect' column at step 5 in execution_table.

At which step is the Customer entity assigned to the Order entity in memory?

A Step 1

B Step 5

C Step 3

D Step 7

💡 Hint

Look at the 'Entity State' column to see when Order.customer changes from null.

If you skip saving Customer before Order, what likely happens?

A Database error due to missing foreign key reference

B Order saves successfully with null customer

C Customer is auto-created

D Order saves with customer name embedded

💡 Hint

Refer to key_moments about saving order before customer.

Concept Snapshot

@ManyToOne links one entity to another by storing a foreign key.
Use @ManyToOne on a field in the 'many' side entity.
Saving the 'one' side first is required.
Database stores foreign key in 'many' side table.
Fetching 'many' side can load linked 'one' side entity.

Full Transcript

The @ManyToOne relationship in Spring Boot connects one entity to another by storing a foreign key in the database. First, you create the 'one' side entity (Customer) and the 'many' side entity (Order). You add @ManyToOne annotation on the Order's customer field. When saving, you must save the Customer first to get its ID. Then save the Order with the customer linked. The database stores the foreign key in the Order table. When fetching an Order, the linked Customer is loaded using that foreign key. This flow ensures data integrity and proper linking between entities.

Practice

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

easy

A. A many-to-one relationship where many entities link to one entity

B. A one-to-many relationship where one entity links to many entities

C. A one-to-one relationship between two entities

D. A many-to-many relationship between two entities

Solution

1. Step 1: Understand relationship types in JPA

   @ManyToOne means many instances of an entity relate to one instance of another entity.

2. Step 2: Match the description to the annotation

   The annotation @ManyToOne specifically defines many entities pointing to one entity.

3. Final Answer:

   A many-to-one relationship where many entities link to one entity -> Option A

4. Quick Check:

   @ManyToOne = many entities to one entity [OK]

Hint: Remember: Many objects point to one with @ManyToOne [OK]

Common Mistakes:

• Confusing @ManyToOne with @OneToMany
• Thinking it means one-to-one
• Mixing it up with many-to-many

2. Which of the following is the correct way to declare a @ManyToOne relationship with a join column named category_id?

easy

A. @ManyToOne
@JoinColumn(name = "category_id")
private Category category;

B. @OneToMany
@JoinColumn(name = "category_id")
private Category category;

C. @ManyToOne
@JoinColumn(columnName = "category_id")
private Category category;

D. @ManyToOne
@JoinColumn(name = category_id)
private Category category;

Solution

1. Step 1: Check correct annotation usage

   The relationship is many-to-one, so @ManyToOne is correct.

2. Step 2: Verify @JoinColumn syntax

   The attribute to specify column name is name and the value must be a string in quotes.

3. Final Answer:

   @ManyToOne @JoinColumn(name = "category_id") private Category category; -> Option A

4. Quick Check:

   @JoinColumn uses name="column_name" [OK]

Hint: Use @JoinColumn(name = "column_name") with quotes [OK]

Common Mistakes:

• Using @OneToMany instead of @ManyToOne
• Using columnName instead of name in @JoinColumn
• Omitting quotes around column name

3. Given the entities below, what will be the output of System.out.println(order.getCustomer().getName()); if the order is linked to a customer named "Alice"?

public class Order {
  @ManyToOne
  @JoinColumn(name = "customer_id")
  private Customer customer;

  public Customer getCustomer() { return customer; }
}

public class Customer {
  private String name;
  public String getName() { return name; }
}

medium

A. Compilation error

B. customer_id

C. null

D. Alice

Solution

1. Step 1: Understand the relationship and method calls

   The order has a customer linked via @ManyToOne, so calling getCustomer() returns the Customer object.

2. Step 2: Access the customer's name

   Calling getName() on the Customer returns the customer's name, which is "Alice".

3. Final Answer:

   Alice -> Option D

4. Quick Check:

   order.getCustomer().getName() = "Alice" [OK]

Hint: Follow the chain: order -> customer -> name [OK]

Common Mistakes:

• Expecting the join column name instead of customer name
• Assuming null if not initialized
• Thinking it causes a compile error

4. Identify the error in the following code snippet that uses @ManyToOne:

@Entity
public class Book {
  @Id
  private Long id;
  @ManyToOne
  @JoinColumn(name = "author_id")
  private Author author;

  public Author getAuthor() { return author; }
  public void setAuthor(Author author) { this.author = author; }
}

@Entity
public class Author {
  private String name;
  public String getName() { return name; }
}

medium

A. Author class is missing @Entity annotation

B. Book class should use @OneToMany instead of @ManyToOne

C. Missing @Id annotation in Author class

D. Join column name should be "authorId" not "author_id"

Solution

1. Step 1: Check entity requirements

   Every JPA entity must have a primary key annotated with @Id. The Author class lacks this.

2. Step 2: Verify other annotations

   Author has @Entity but no @Id, which will cause runtime errors.

3. Final Answer:

   Missing @Id annotation in Author class -> Option C

4. Quick Check:

   Entity requires @Id field [OK]

Hint: Always add @Id to every entity class [OK]

Common Mistakes:

• Confusing relationship annotations
• Ignoring missing primary key
• Assuming join column naming causes error

5. You have two entities: Order and Customer. Each order belongs to one customer, but a customer can have many orders. You want to fetch all orders with their customers efficiently. Which approach correctly uses @ManyToOne for eager loading?

hard

A. Use @ManyToOne(fetch = FetchType.LAZY) on Order's customer and fetch customers separately

B. Use @ManyToOne(fetch = FetchType.EAGER) on Order's customer to load customers with orders

C. Use @OneToMany(fetch = FetchType.EAGER) on Customer's orders and no mapping on Order

D. Use @ManyToOne without fetch type and manually query customers for each order

Solution

1. Step 1: Understand fetch types in @ManyToOne

   By default, @ManyToOne uses FetchType.EAGER, loading the related customer eagerly with the order.

2. Step 2: Match the best approach

   Explicitly using fetch = FetchType.EAGER on the Order's customer field ensures efficient eager loading for this many-to-one relationship.

3. Final Answer:

   Use @ManyToOne(fetch = FetchType.EAGER) on Order's customer to load customers with orders -> Option B

4. Quick Check:

   @ManyToOne = EAGER by default [OK]

Hint: EAGER fetch on @ManyToOne loads related data together [OK]

Common Mistakes:

• Using LAZY fetch without proper query optimization
• Using @OneToMany on Customer without Order mapping
• Manually querying related entities inefficiently