Mô Hình Hóa Các Mối Quan Hệ Trong JPA: One-to-One, One-to-Many, Many-to-Many | Java Spring Roadmap

Mapping JPA sai hiếm khi ném exception ngay. Nó tạo thêm một bảng trung gian bạn không biết, một khóa ngoại cho phép NULL, hoặc 200 câu SELECT cho màn hình 20 dòng. Hãy đọc DDL và SQL Hibernate sinh ra, không chỉ annotation.

Ba mối quan hệ trong JPA — one-to-one, one-to-many, many-to-many — chỉ trả lời một câu hỏi: khóa ngoại nằm ở đâu. Bài này dùng Jakarta Persistence 3.2, Hibernate 7.4.15.Final và Spring Data JPA 4.1.2 trên Java 25 LTS, kèm hệ quả SQL để kiểm tra bằng mắt.

Cập nhật 2026

  • Jakarta Persistence 3.2 (Jakarta EE 11): import jakarta.persistence.*; javax.persistence không còn compile trên Boot 4.1.2.
  • Hibernate 7.4.15.Final là bản stable (2026-11-06); 8.0.0.Beta4 chỉ là bản phát triển.
  • Spring Data JPA 4.1.2 đi với Boot 4.1.2/Framework 7.0.10; API mapping không đổi.
  • Đừng dùng ddl-auto=update để kiểm tra mapping; đọc DDL sinh ra hoặc dùng migration + validate.

Nguyên tắc: owning side và hệ quả SQL

CSDL quan hệ chỉ có hai cách lưu quan hệ: cột khóa ngoại hoặc bảng trung gian chứa hai FK. JPA không có cách thứ ba; annotation chỉ quyết định bảng nào giữ FK và SQL sinh ra khi thêm, sửa, xóa.

Owning side là phía có FK trong bảng của nó; phía còn lại là inverse side, khai báo mappedBy trỏ tới field owning. Không chắc thì tìm bảng giữ FK.

Với @ManyToOne/@OneToOne, sửa ở inverse side không ghi FK. Với @OneToMany(mappedBy), Hibernate theo dõi collection nên cascade persist/delete được, nhưng vẫn phải set FK ở con; nếu không sẽ có UPDATE thừa và có thể vi phạm NOT NULL.

One-to-One: FK unique hoặc khóa chính dùng chung

Một người có đúng một hồ sơ. Cách thứ nhất: bảng hồ sơ giữ user_id làm FK kèm unique — thiếu unique, CSDL vẫn cho phép hai hồ sơ cùng người. Cách thứ hai: dùng chính khóa chính của người (shared primary key) để không có cột id dư.

// File: src/main/java/com/evotek/shop/user/UserProfile.java
import jakarta.persistence.*;

@Entity
@Table(name = "user_profiles")
public class UserProfile {

    @Id
    private Long id; // cùng giá trị với users.id

    @OneToOne(fetch = FetchType.LAZY, optional = false)
    @MapsId                       // lấy PK từ association
    @JoinColumn(name = "user_id") // vừa là PK, vừa là FK
    private User user;

    private String phone;
}

@Entity
@Table(name = "users")
public class User {

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

    @OneToOne(mappedBy = "user", cascade = CascadeType.ALL, orphanRemoval = true)
    private UserProfile profile;
}

Hệ quả SQL: user_profiles có cột user_id là khóa chính và khóa ngoại, không có cột id riêng. Nếu chọn FK thường, viết @JoinColumn(name = "user_id", unique = true, nullable = false) trên bên owning; DDL sẽ có unique index và FK.

@OneToOne mặc định EAGER. Trên owning side, LAZY chỉ thật sự lazy khi FK không null (optional = false) hoặc có bytecode enhancement; nếu không Hibernate vẫn query.

One-to-Many / Many-to-One: FK nằm ở bảng “nhiều”

Một đơn hàng có nhiều dòng; mỗi dòng thuộc đúng một đơn. FK order_id nằm ở order_lines, nên OrderLine là owning side với @ManyToOne. Order giữ collection và khai báo mappedBy = "order".

// File: src/main/java/com/evotek/shop/order/Order.java
package com.evotek.shop.order;

import jakarta.persistence.*;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;

@Entity
@Table(name = "orders")
public class Order {

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

    private BigDecimal total = BigDecimal.ZERO;

    @OneToMany(mappedBy = "order", cascade = CascadeType.ALL, orphanRemoval = true)
    private List<OrderLine> lines = new ArrayList<>();

    public void addLine(OrderLine line) {
        lines.add(line);
        line.setOrder(this);            // giữ FK ở owning side
        total = total.add(line.getSubtotal());
    }

    public void removeLine(OrderLine line) {
        lines.remove(line);             // orphanRemoval sinh DELETE
        line.setOrder(null);
        total = total.subtract(line.getSubtotal());
    }
}
// File: src/main/java/com/evotek/shop/order/OrderLine.java
package com.evotek.shop.order;

import jakarta.persistence.*;
import java.math.BigDecimal;

@Entity
@Table(name = "order_lines")
public class OrderLine {

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

    @ManyToOne(fetch = FetchType.LAZY, optional = false)
    @JoinColumn(name = "order_id", nullable = false)
    private Order order;

    private String sku;
    private int quantity;
    private BigDecimal unitPrice = BigDecimal.ZERO;

    public BigDecimal getSubtotal() {
        return unitPrice.multiply(BigDecimal.valueOf(quantity));
    }

    void setOrder(Order order) { this.order = order; }
}

Hệ quả SQL: order_lines.order_id là FK NOT NULL. Xóa một Order xóa các dòng của nó; gỡ một dòng khỏi collection cũng sinh DELETE nhờ orphanRemoval. Nếu set order = null mà không gỡ khỏi collection, Hibernate báo lỗi orphan hoặc để dữ liệu không nhất quán trong persistence context.

Hai chi tiết dễ bỏ qua: @ManyToOne mặc định EAGER, nên thiếu fetch = LAZY thì mỗi dòng hàng kéo theo cả đơn; optional = false giúp tránh join thừa và cho phép proxy lazy.

Unidirectional @OneToMany cũng được, nhưng biết hệ quả: thiếu mappedBy lẫn @JoinColumn thì Hibernate tạo bảng trung gian; thêm @JoinColumn thì FK ở bảng con nhưng không có field đọc ngược, và Hibernate ghi FK bằng UPDATE phụ. Bidirectional có field ở cả hai phía, chỉ owning side ghi FK, và helper method giữ chúng đồng bộ; khi con cần biết cha — gần như luôn vậy — cách này rẻ hơn cả code lẫn SQL.

Many-to-Many: bảng trung gian và cái bẫy domain

Một sinh viên học nhiều khóa, một khóa có nhiều sinh viên. Không bảng nào giữ FK của bên kia nên cần bảng trung gian: owning side khai báo @JoinTable, inverse side dùng mappedBy.

// File: src/main/java/com/evotek/shop/course/Student.java
@Entity
@Table(name = "students")
public class Student {

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

    @ManyToMany
    @JoinTable(
        name = "student_course",
        joinColumns = @JoinColumn(name = "student_id"),
        inverseJoinColumns = @JoinColumn(name = "course_id"))
    private Set<Course> courses = new HashSet<>();
}

@Entity
@Table(name = "courses")
public class Course {

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

    @ManyToMany(mappedBy = "courses")
    private Set<Student> students = new HashSet<>();
}

Hệ quả SQL: student_course có khóa chính tổ hợp (student_id, course_id) và hai FK. Không cột nào mô tả ngày đăng ký, điểm, trạng thái — vì bảng trung gian không phải entity. Đó là lý do @ManyToMany thường là mô hình domain tồi: quan hệ thật luôn có thuộc tính và vòng đời riêng.

Khi quan hệ có dữ liệu riêng, biến bảng trung gian thành entity:

@Entity
@Table(name = "enrollments",
       uniqueConstraints = @UniqueConstraint(columnNames = {"student_id", "course_id"}))
public class Enrollment {

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

    @ManyToOne(fetch = FetchType.LAZY, optional = false)
    @JoinColumn(name = "student_id", nullable = false)
    private Student student;

    @ManyToOne(fetch = FetchType.LAZY, optional = false)
    @JoinColumn(name = "course_id", nullable = false)
    private Course course;

    private LocalDate enrolledOn;
    private BigDecimal grade;
}

Trong Student, thay collection khóa học bằng @OneToMany(mappedBy = "student", cascade = CascadeType.ALL, orphanRemoval = true) trên List<Enrollment>. Đổi lại bạn có unique constraint, ngày đăng ký, điểm và cascade đúng vòng đời enrollment thay vì xóa lan sang course.

Một mapping sai, triệu chứng và cách sửa

// SAI: @OneToMany thiếu mappedBy
@Entity
public class Order {
    @OneToMany(cascade = CascadeType.ALL)
    private List<OrderLine> lines = new ArrayList<>();
}

@Entity
public class OrderLine {
    @ManyToOne
    @JoinColumn(name = "order_id")
    private Order order;
}

Triệu chứng: Hibernate coi quan hệ phía Order là unidirectional và sinh thêm bảng trung gian (tên do implicit naming strategy quyết định), trong khi order_lines.order_id vẫn tồn tại vì phía OrderLine là quan hệ riêng. Kết quả là hai đường ghi: thêm dòng vào collection ghi bảng trung gian, set order ghi cột FK. Query theo order_id không thấy dòng vừa thêm; orphanRemoval không chạy; dữ liệu lệch giữa hai nơi.

Cách sửa: thêm mappedBy = "order" vào @OneToMany và bỏ mọi @JoinColumn ở phía collection. Chỉ owning side được khai báo cột FK:

@OneToMany(mappedBy = "order", cascade = CascadeType.ALL, orphanRemoval = true)
private List<OrderLine> lines = new ArrayList<>();

Nếu DDL có cả bảng trung gian lẫn cột FK cho cùng quan hệ, gần như chắc chắn bạn thiếu mappedBy hoặc khai báo hai quan hệ độc lập.

Cascade và orphanRemoval: chọn theo vòng đời

Cascade là tuyên bố về vòng đời: con có tồn tại độc lập hay không. Với Order/OrderLine, con chỉ có nghĩa trong cha nên CascadeType.ALL + orphanRemoval = true hợp lý. Với nhiều-nhiều, bên kia là aggregate riêng nên cascade xóa là sai.

Cascade Hibernate làm gì Dùng khi
PERSIST Persist cha kéo theo persist con mới Con mới và chỉ thuộc cha
MERGE Merge cha kéo theo merge con Nhận graph detached từ ngoài vào
REMOVE Remove cha xóa luôn con Con không được chia sẻ với cha khác
orphanRemoval Gỡ khỏi collection hoặc liên kết thì DELETE con @OneToMany hoặc @OneToOne
ALL Gồm cả REMOVE và REFRESH Aggregate sở hữu trọn vẹn

Ba lỗi thường gặp. cascade = REMOVE trên @ManyToMany xóa khóa học mà sinh viên khác vẫn học, hoặc hỏng FK. orphanRemoval = true trên @ManyToOne không tồn tại — code không compile. Và bật orphanRemoval trên quan hệ mà con có thể chuyển sang cha khác sẽ xóa nhầm dữ liệu.

Fetch, N+1 và cách tải đúng

Mặc định của JPA khiến ORM bị mang tiếng chậm: @OneToMany và @ManyToMany là LAZY; @ManyToOne và @OneToOne là EAGER. Với graph lớn, EAGER kéo theo chuỗi bảng bạn không dùng.

Quan hệ Fetch mặc định Nên làm
@OneToMany LAZY Giữ LAZY, fetch join khi cần
@ManyToMany LAZY Giữ LAZY, cân nhắc join entity
@ManyToOne EAGER Luôn khai báo fetch = LAZY
@OneToOne EAGER LAZY + optional = false

N+1 xảy ra khi load N cha rồi truy cập association lazy trên từng cha: một SELECT cho danh sách, N SELECT cho con — 20 đơn là 21 query, 2.000 đơn là 2.001. Sửa bằng fetch join JPQL hoặc @EntityGraph trên repository method.

// File: src/main/java/com/evotek/shop/order/OrderRepository.java
@Query("select distinct o from Order o join fetch o.lines where o.id = :id")
Optional<Order> findWithLines(@Param("id") Long id);

@EntityGraph(attributePaths = "lines")
List<Order> findByStatus(OrderStatus status);

Với collection lớn, @BatchSize(size = 25) hoặc spring.jpa.properties.hibernate.default_batch_fetch_size=25 giảm N+1 xuống N/25 query mà không cần JPQL — mặc định đáng bật.

Hai giới hạn. Join fetch + phân trang: findAll(Pageable) với @EntityGraph trỏ vào collection buộc Hibernate phân trang trong bộ nhớ và log cảnh báo; hãy query id của trang trước rồi fetch theo id. Fetch hai collection List cùng query sẽ ném MultipleBagFetchException; đổi một bên sang Set hoặc tách query.

equals/hashCode và vòng lặp vô hạn trong JSON

Trong graph bidirectional, equals của cha gọi collection, mỗi con lại gọi cha — đệ quy vô hạn. Đừng dùng Lombok @Data trên entity: equals quét cả association, còn hashCode đổi khi collection đổi khiến object trong HashSet bị “mất”.

@Override
public boolean equals(Object o) {
    if (this == o) return true;
    if (!(o instanceof OrderLine other)) return false;
    return id != null && id.equals(other.id);
}

@Override
public int hashCode() {
    return getClass().hashCode(); // hằng số, ổn định qua các lần flush
}

Cách trên ổn cho entity đã persist. Với entity mới (id null), hãy dùng business key như SKU hoặc UUID gán lúc khởi tạo nếu cần đặt vào Set trước flush; đừng đưa field mutable vào hashCode.

JSON cũng vậy: serialize Order gặp lines, mỗi OrderLine gặp order, quay lại Order — StackOverflowError. @JsonIgnore một phía hết lỗi nhưng là băng dán: mất field client cần, trói entity vào web layer, và có thể chạm association lazy ngoài transaction gây LazyInitializationException. @JsonManagedReference/@JsonBackReference cùng bản chất.

Giải pháp đúng là DTO, chọn field theo use case. Entity chỉ phục vụ persistence; API trả về record:

public record OrderDto(Long id, BigDecimal total, List<OrderLineDto> lines) {}
public record OrderLineDto(String sku, int quantity, BigDecimal unitPrice) {}

Mapping trong service cũng là chỗ fetch đúng association cần.

Những lỗi còn lại cần kiểm tra

  • List không có thứ tự: List mặc định là bag, CSDL không đảm bảo thứ tự. Dùng @OrderBy("sku") nếu chỉ cần sắp xếp khi đọc, @OrderColumn nếu cần lưu vị trí (đổi lại có UPDATE khi chèn giữa), hoặc Set nếu chỉ cần duy nhất.
  • Hai unidirectional FK: khai báo @OneToMany và @ManyToOne mà quên mappedBy tạo hai quan hệ, hai FK hoặc bảng trung gian. Chỉ một bên được giữ FK.
  • Join fetch quá rộng: fetch nhiều collection cùng lúc làm query phình và có thể ném MultipleBagFetchException. Fetch đúng thứ màn hình cần, và đừng serialize entity trực tiếp vì dễ rò rỉ schema lẫn lazy load.

Chọn quan hệ nào?

Quan hệ Dùng khi Mapping gợi ý
1:1 Hai bảng cùng vòng đời, tách vì kích thước hoặc bảo mật @OneToOne + @JoinColumn(unique) hoặc @MapsId
1:N Con thuộc đúng một cha và chết cùng cha @ManyToOne(LAZY) owning + @OneToMany(mappedBy)
N:M Quan hệ thuần, không thuộc tính, hai aggregate độc lập @ManyToMany + @JoinTable
N:M có dữ liệu Có ngày, trạng thái, điểm, vai trò Join entity + hai @ManyToOne

Nhìn về 2027

Hibernate 8.0 vẫn ở beta; khi stable ra, kỳ vọng là tương thích JPA 3.2 và cải thiện hiệu năng fetch, không phải annotation mới. Việc đáng làm ngay: dọn code còn javax.persistence, bỏ EAGER trên @ManyToOne, thay serialize entity bằng DTO.

Checklist trước khi commit

  • DDL chỉ có một FK hoặc một bảng trung gian mỗi quan hệ, không bảng dư.
  • @OneToMany có mappedBy; @ManyToOne có fetch = LAZY và FK NOT NULL.
  • Cascade/orphanRemoval chỉ trên aggregate sở hữu con, không trên nhiều-nhiều.
  • Đã kiểm tra N+1 bằng log SQL; fetch join không phân trang collection.
  • Entity không bị serialize trực tiếp; equals/hashCode không gọi association.

Bài trước là Hibernate Basics: entity đầu tiên, nơi bạn dựng persistence context và khóa chính. Tiếp theo là sự kiện vòng đời entity với callback chạy quanh cascade. Nếu cần repository và derived query, đọc Spring Data JPA cho người mới. Toàn bộ thứ tự bài nằm ở lộ trình Spring Boot.