@OneToMany and @ManyToOne JPA Mapping in Java

JPA (Java Persistence API) provides powerful annotations to define relationships between entities. The @OneToMany and @ManyToOne annotations are used to represent one-to-many and many-to-one relationships between database tables.

Understanding the Relationships

@ManyToOne

Represents "many instances of this entity belong to one instance of another entity"
The owning side of the relationship
Foreign key is stored in the table of the entity with @ManyToOne

@OneToMany

Represents "one instance of this entity has many instances of another entity"
The inverse side of the relationship
No foreign key column in the database table

Basic Implementation

Entity Classes Example

Department Entity (One-to-Many Side)

package com.example.model;
import javax.persistence.*;
import java.util.ArrayList;
import java.util.List;
@Entity
@Table(name = "departments")
public class Department {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
@Column(name = "name")
private String name;
@Column(name = "code")
private String code;
// One-to-Many relationship with Employee
@OneToMany(mappedBy = "department", 
cascade = CascadeType.ALL, 
fetch = FetchType.LAZY)
private List<Employee> employees = new ArrayList<>();
// Constructors
public Department() {}
public Department(String name, String code) {
this.name = name;
this.code = code;
}
// Getters and Setters
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 String getCode() {
return code;
}
public void setCode(String code) {
this.code = code;
}
public List<Employee> getEmployees() {
return employees;
}
public void setEmployees(List<Employee> employees) {
this.employees = employees;
}
// Helper methods for bidirectional relationship
public void addEmployee(Employee employee) {
employees.add(employee);
employee.setDepartment(this);
}
public void removeEmployee(Employee employee) {
employees.remove(employee);
employee.setDepartment(null);
}
@Override
public String toString() {
return "Department{" +
"id=" + id +
", name='" + name + '\'' +
", code='" + code + '\'' +
'}';
}
}

Employee Entity (Many-to-One Side)

package com.example.model;
import javax.persistence.*;
@Entity
@Table(name = "employees")
public class Employee {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
@Column(name = "first_name")
private String firstName;
@Column(name = "last_name")
private String lastName;
@Column(name = "email")
private String email;
@Column(name = "salary")
private Double salary;
// Many-to-One relationship with Department
@ManyToOne(fetch = FetchType.LAZY)
@JoinColumn(name = "department_id")
private Department department;
// Constructors
public Employee() {}
public Employee(String firstName, String lastName, String email, Double salary) {
this.firstName = firstName;
this.lastName = lastName;
this.email = email;
this.salary = salary;
}
// Getters and Setters
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getFirstName() {
return firstName;
}
public void setFirstName(String firstName) {
this.firstName = firstName;
}
public String getLastName() {
return lastName;
}
public void setLastName(String lastName) {
this.lastName = lastName;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
public Double getSalary() {
return salary;
}
public void setSalary(Double salary) {
this.salary = salary;
}
public Department getDepartment() {
return department;
}
public void setDepartment(Department department) {
this.department = department;
}
@Override
public String toString() {
return "Employee{" +
"id=" + id +
", firstName='" + firstName + '\'' +
", lastName='" + lastName + '\'' +
", email='" + email + '\'' +
", salary=" + salary +
'}';
}
}

Cascade Types

CascadeType defines what operations should be cascaded from the parent entity to the child entities.

// Common cascade configurations
@OneToMany(mappedBy = "department", cascade = CascadeType.ALL) // All operations cascade
@OneToMany(mappedBy = "department", cascade = {CascadeType.PERSIST, CascadeType.MERGE})
@OneToMany(mappedBy = "department", cascade = CascadeType.REMOVE) // Only remove cascades

Available Cascade Types:

PERSIST - Cascade persist operation
MERGE - Cascade merge operation
REMOVE - Cascade remove operation
REFRESH - Cascade refresh operation
DETACH - Cascade detach operation
ALL - All of the above

Fetch Types

// Fetch configurations
@ManyToOne(fetch = FetchType.LAZY)  // Load on demand (recommended for @ManyToOne)
@OneToMany(fetch = FetchType.LAZY)  // Load on demand (recommended for @OneToMany)
@ManyToOne(fetch = FetchType.EAGER) // Load immediately (can cause N+1 query problem)

Repository Interfaces

package com.example.repository;
import com.example.model.Department;
import com.example.model.Employee;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.query.Param;
import org.springframework.stereotype.Repository;
import java.util.List;
@Repository
public interface DepartmentRepository extends JpaRepository<Department, Long> {
Department findByName(String name);
@Query("SELECT d FROM Department d LEFT JOIN FETCH d.employees WHERE d.id = :id")
Department findByIdWithEmployees(@Param("id") Long id);
}
@Repository
public interface EmployeeRepository extends JpaRepository<Employee, Long> {
List<Employee> findByDepartmentId(Long departmentId);
List<Employee> findByDepartmentName(String departmentName);
@Query("SELECT e FROM Employee e WHERE e.salary > :minSalary")
List<Employee> findEmployeesWithSalaryGreaterThan(@Param("minSalary") Double minSalary);
}

Service Layer Implementation

package com.example.service;
import com.example.model.Department;
import com.example.model.Employee;
import com.example.repository.DepartmentRepository;
import com.example.repository.EmployeeRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.List;
@Service
@Transactional
public class CompanyService {
@Autowired
private DepartmentRepository departmentRepository;
@Autowired
private EmployeeRepository employeeRepository;
// Department operations
public Department createDepartment(Department department) {
return departmentRepository.save(department);
}
public Department getDepartmentWithEmployees(Long departmentId) {
return departmentRepository.findByIdWithEmployees(departmentId);
}
// Employee operations
public Employee createEmployee(Employee employee) {
return employeeRepository.save(employee);
}
public Employee assignEmployeeToDepartment(Long employeeId, Long departmentId) {
Employee employee = employeeRepository.findById(employeeId)
.orElseThrow(() -> new RuntimeException("Employee not found"));
Department department = departmentRepository.findById(departmentId)
.orElseThrow(() -> new RuntimeException("Department not found"));
employee.setDepartment(department);
return employeeRepository.save(employee);
}
public List<Employee> getEmployeesByDepartment(Long departmentId) {
return employeeRepository.findByDepartmentId(departmentId);
}
// Bidirectional relationship helper
public Department addEmployeeToDepartment(Long departmentId, Employee employee) {
Department department = departmentRepository.findById(departmentId)
.orElseThrow(() -> new RuntimeException("Department not found"));
department.addEmployee(employee);
return departmentRepository.save(department);
}
}

Controller Layer

package com.example.controller;
import com.example.model.Department;
import com.example.model.Employee;
import com.example.service.CompanyService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
import java.util.List;
@RestController
@RequestMapping("/api")
public class CompanyController {
@Autowired
private CompanyService companyService;
@PostMapping("/departments")
public ResponseEntity<Department> createDepartment(@RequestBody Department department) {
Department savedDepartment = companyService.createDepartment(department);
return ResponseEntity.ok(savedDepartment);
}
@PostMapping("/employees")
public ResponseEntity<Employee> createEmployee(@RequestBody Employee employee) {
Employee savedEmployee = companyService.createEmployee(employee);
return ResponseEntity.ok(savedEmployee);
}
@PutMapping("/employees/{employeeId}/department/{departmentId}")
public ResponseEntity<Employee> assignToDepartment(
@PathVariable Long employeeId, 
@PathVariable Long departmentId) {
Employee employee = companyService.assignEmployeeToDepartment(employeeId, departmentId);
return ResponseEntity.ok(employee);
}
@GetMapping("/departments/{id}/employees")
public ResponseEntity<List<Employee>> getDepartmentEmployees(@PathVariable Long id) {
List<Employee> employees = companyService.getEmployeesByDepartment(id);
return ResponseEntity.ok(employees);
}
@PostMapping("/departments/{departmentId}/employees")
public ResponseEntity<Department> addEmployeeToDepartment(
@PathVariable Long departmentId, 
@RequestBody Employee employee) {
Department department = companyService.addEmployeeToDepartment(departmentId, employee);
return ResponseEntity.ok(department);
}
}

Advanced Mapping Examples

1. Unidirectional One-to-Many (Without @ManyToOne)

@Entity
@Table(name = "orders")
public class Order {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
@OneToMany(cascade = CascadeType.ALL, fetch = FetchType.LAZY)
@JoinColumn(name = "order_id") // Foreign key in OrderItem table
private List<OrderItem> items = new ArrayList<>();
}
@Entity
@Table(name = "order_items")
public class OrderItem {
// No reference back to Order
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
private String productName;
private Integer quantity;
}

2. Using @JoinTable for One-to-Many

@Entity
public class University {
@Id
@GeneratedValue
private Long id;
@OneToMany(cascade = CascadeType.ALL)
@JoinTable(
name = "university_students",
joinColumns = @JoinColumn(name = "university_id"),
inverseJoinColumns = @JoinColumn(name = "student_id")
)
private List<Student> students = new ArrayList<>();
}

3. With Additional Relationship Attributes

@Entity
public class Course {
@Id
@GeneratedValue
private Long id;
@OneToMany(mappedBy = "course", cascade = CascadeType.ALL)
private List<CourseRegistration> registrations = new ArrayList<>();
}
@Entity
public class Student {
@Id
@GeneratedValue
private Long id;
@OneToMany(mappedBy = "student", cascade = CascadeType.ALL)
private List<CourseRegistration> registrations = new ArrayList<>();
}
@Entity
public class CourseRegistration {
@Id
@GeneratedValue
private Long id;
@ManyToOne(fetch = FetchType.LAZY)
@JoinColumn(name = "student_id")
private Student student;
@ManyToOne(fetch = FetchType.LAZY)
@JoinColumn(name = "course_id")
private Course course;
private LocalDate registrationDate;
private Integer grade;
}

Best Practices

1. Always Use Bidirectional Relationships

// Good - Bidirectional
public class Department {
@OneToMany(mappedBy = "department")
private List<Employee> employees;
}
public class Employee {
@ManyToOne
@JoinColumn(name = "department_id")
private Department department;
}

2. Use Lazy Fetching by Default

@ManyToOne(fetch = FetchType.LAZY)  // Recommended
@OneToMany(fetch = FetchType.LAZY)  // Recommended

3. Implement Helper Methods

// In Department class
public void addEmployee(Employee employee) {
employees.add(employee);
employee.setDepartment(this);
}
public void removeEmployee(Employee employee) {
employees.remove(employee);
employee.setDepartment(null);
}

4. Handle Cascading Carefully

// Be specific about which operations should cascade
@OneToMany(mappedBy = "department", 
cascade = {CascadeType.PERSIST, CascadeType.MERGE})
private List<Employee> employees;

Common Issues and Solutions

1. N+1 Query Problem

Problem: Lazy loading causes multiple queries
Solution: Use JOIN FETCH in queries

@Query("SELECT d FROM Department d JOIN FETCH d.employees WHERE d.id = :id")
Department findByIdWithEmployees(@Param("id") Long id);

2. Transaction Management

Problem: LazyInitializationException outside transaction
Solution: Use @Transactional or eager fetching strategically

3. Circular References in JSON

Problem: Infinite recursion when serializing to JSON
Solution: Use @JsonIgnore or DTOs

@OneToMany(mappedBy = "department")
@JsonIgnore
private List<Employee> employees;

This comprehensive guide covers the essential aspects of @OneToMany and @ManyToOne mappings in JPA, providing you with the knowledge to implement these relationships effectively in your Java applications.