@ManyToOne relationship in Spring Boot

Introduction

The @ManyToOne annotation helps connect two data tables where many items belong to one main item. It makes managing related data easier.

When you have many orders that belong to one customer.

When many comments belong to one blog post.

When many employees work in one department.

When many books are written by one author.

Syntax

Spring Boot

@ManyToOne
@JoinColumn(name = "column_name")
private EntityType entity;

@ManyToOne marks the many side of the relationship.

@JoinColumn sets the database column that links the two tables.

Examples

Many orders belong to one customer, linked by customer_id.

Spring Boot

@ManyToOne
@JoinColumn(name = "customer_id")
private Customer customer;

Many employees belong to one department, linked by department_id.

Spring Boot

@ManyToOne
@JoinColumn(name = "department_id")
private Department department;

Sample Program

This example shows two classes: Order and Customer. Many orders can belong to one customer. The @ManyToOne annotation links each order to its customer. When we print, we see the order's product and the customer's name.

Spring Boot

import jakarta.persistence.*;

@Entity
public class Order {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String product;

    @ManyToOne
    @JoinColumn(name = "customer_id")
    private Customer customer;

    // Constructors, getters, setters
    public Order() {}

    public Order(String product, Customer customer) {
        this.product = product;
        this.customer = customer;
    }

    public Long getId() { return id; }
    public String getProduct() { return product; }
    public Customer getCustomer() { return customer; }

    public void setProduct(String product) { this.product = product; }
    public void setCustomer(Customer customer) { this.customer = customer; }
}

@Entity
public class Customer {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;

    // Constructors, getters, setters
    public Customer() {}

    public Customer(String name) {
        this.name = name;
    }

    public Long getId() { return id; }
    public String getName() { return name; }

    public void setName(String name) { this.name = name; }
}

// Example usage in a service or main method
public class Example {
    public static void main(String[] args) {
        Customer customer = new Customer("Alice");
        Order order = new Order("Book", customer);

        System.out.println("Order product: " + order.getProduct());
        System.out.println("Order belongs to customer: " + order.getCustomer().getName());
    }
}

Important Notes

Always set @JoinColumn to specify the foreign key column in the database.

@ManyToOne is the most common way to model many items linked to one item.

Remember to have getters and setters for JPA to work properly.

Summary

@ManyToOne connects many objects to one object in the database.

Use @JoinColumn to name the linking column.

This helps keep related data organized and easy to access.

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