Mastering @ManyToOne and @OneToMany Relationships in Spring Boot

Spring Boot simplifies database integration with JPA (Java Persistence API) and Hibernate, making it easy to manage relationships between entities. This tutorial will delve into the @ManyToOne and @OneToMany annotations, explaining their usage and implementation with practical examples.

What Are @ManyToOne and @OneToMany?

• @ManyToOne: Defines a single entity that is associated with many entities of another type. For example, multiple Orders can belong to a single Customer.
• @OneToMany: Defines one entity that is associated with multiple entities of another type. For example, a single Customer can have multiple Orders.

Together, they define a bidirectional or unidirectional relationship between two entities.

Spring Boot implementation

Setting Up the Project

Before diving into the implementation, ensure you have the following:

1. Spring Boot Starter Project: Set up using Spring Initializr with dependencies:

• Spring Data JPA
• H2 Database (or any preferred database)
• Spring Web (optional for testing REST endpoints)

Example Scenario: Customers and Orders

Let’s build a simple application where:

• A Customer can place multiple Orders.
• Each Order belongs to a single Customer.

Step 1: Create the Entities

Customer Entity

import jakarta.persistence.*;
import java.util.List;

@Entity
public class Customer {

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

    private String name;

    @OneToMany(mappedBy = "customer", cascade = CascadeType.ALL, orphanRemoval = true)
    private List<Order> orders;

    // Constructors, Getters, and Setters
    public Customer() {}

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

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    public List<Order> getOrders() {
        return orders;
    }

    public void setOrders(List<Order> orders) {
        this.orders = orders;
    }
}

Key Points:

• @OneToMany: A customer can have multiple orders.
• mappedBy: Specifies the field in the Order entity responsible for this relationship.
• cascade: Ensures that changes to the Customer entity cascade to the associated Orders.

Order Entity

import jakarta.persistence.*;

@Entity
public class Order {

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

    private String productName;

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

    // Constructors, Getters, and Setters
    public Order() {}

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

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getProductName() {
        return productName;
    }

    public void setProductName(String productName) {
        this.productName = productName;
    }

    public Customer getCustomer() {
        return customer;
    }

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

Key Points:

• @ManyToOne: An order is associated with one customer.
• @JoinColumn: Defines the foreign key column (customer_id) in the Order table.

Step 2: Configure the Repository Layer

CustomerRepository

import org.springframework.data.jpa.repository.JpaRepository;

public interface CustomerRepository extends JpaRepository<Customer, Long> {}

OrderRepository

import org.springframework.data.jpa.repository.JpaRepository;

public interface OrderRepository extends JpaRepository<Order, Long> {}

Step 3: Add Some Test Data

Using CommandLineRunner

import org.springframework.boot.CommandLineRunner;
import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Component;

@Component
public class DataLoader {

    @Bean
    CommandLineRunner loadData(CustomerRepository customerRepository, OrderRepository orderRepository) {
        return args -> {
            Customer customer1 = new Customer("John Doe");
            Customer customer2 = new Customer("Jane Smith");

            Order order1 = new Order("Laptop", customer1);
            Order order2 = new Order("Phone", customer1);
            Order order3 = new Order("Tablet", customer2);

            customer1.setOrders(List.of(order1, order2));
            customer2.setOrders(List.of(order3));

            customerRepository.save(customer1);
            customerRepository.save(customer2);
        };
    }
}

Step 4: Testing the Relationship

Query Data Using Repositories

import org.springframework.boot.CommandLineRunner;
import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Component;

@Component
public class QueryRunner {

    @Bean
    CommandLineRunner runQueries(CustomerRepository customerRepository, OrderRepository orderRepository) {
        return args -> {
            // Fetch all customers
            customerRepository.findAll().forEach(customer -> {
                System.out.println("Customer: " + customer.getName());
                customer.getOrders().forEach(order -> {
                    System.out.println("  Order: " + order.getProductName());
                });
            });

            // Fetch all orders
            orderRepository.findAll().forEach(order -> {
                System.out.println("Order: " + order.getProductName() + ", Customer: " + order.getCustomer().getName());
            });
        };
    }
}

Step 5: Running the Application

1. Run the Spring Boot application.
2. Verify the relationships through the console logs.
3. If using an H2 database, navigate to /h2-console and inspect the Customer and Order tables.

Additional Notes

• Cascade Types: Use CascadeType.ALL to propagate changes. Use it cautiously to avoid unintentional deletions.
• Orphan Removal: Automatically deletes Order entities when removed from the Customer‘s orders list.
• Lazy Loading: By default, @OneToMany is lazy-loaded. Use @Transactional or fetch strategies to avoid issues.

Conclusion

The @ManyToOne and @OneToMany annotations provide powerful tools for managing relationships in Spring Boot. By following this guide, you can efficiently model and manipulate relational data in your applications.

See Also

• Java NIO: A Comprehensive Guide with Real-World Example
• Comprehensive Guide to Java Unit Testing