Đến nội dung chính
notes.vinhnq.com

Tìm kiếm

Database & ORMMid13 phút đọc

ORM và JPA: quan hệ entity 1-1, 1-n, n-n và mappedBy

Ôn 12 thẻ
Trong bài này

Cụm bài ORM và JPA: 1. Entity và repository · 2. Quan hệ entity · 3. Schema E-Learning, DTO, JSON · 4. Persistence context và N+1 · 5. JPQL, @Transactional, locking

Bài 1 dựng entity cho từng bảng riêng lẻ; bài này cho các entity trỏ vào nhau. Đọc xong, bạn biết đặt khoá ngoại ở đâu, entity nào là owning side, mappedBy nghĩa là gì và cascade tới đâu thì an toàn. Nên đọc trước bài 1 và phần ERD, khoá ngoại trong cụm Database.

1. Quan hệ giữa các entity

Ý chính: quan hệ trong Java phải khớp với khoá ngoại trong database; JPA cần biết bên nào giữ FK để ghi cột đó.

Sau bài này: bài 3 áp các mapping vào schema E-Learning thật và xử lý vòng lặp JSON, bài 4 nói về persistence context và N+1, bài 5 về JPQL, @Transactional và locking.

1.1. Entity, attribute, relationship

Ý chính: entity là thứ cần lưu (Teacher, Course), attribute là thông tin của nó (id, tên), relationship là liên hệ giữa các entity, gồm ba loại.

  • One-to-One (1-1): mỗi sinh viên chỉ mượn một cuốn sách, mỗi cuốn chỉ cho một người mượn.
  • One-to-Many (1-n): mỗi sinh viên mượn được nhiều cuốn.
  • Many-to-Many (n-n): một sinh viên học nhiều lớp, một lớp có nhiều sinh viên.

1.2. Biểu diễn trong database quan hệ

Ý chính: các bảng nối nhau bằng foreign key (FK — cột trỏ tới primary key của bảng khác, DB không cho trỏ tới dòng không tồn tại). Loại quan hệ quyết định FK nằm ở đâu.

Quan hệ FK đặt ở đâu Vì sao
1-1 bảng phụ thuộc (không tồn tại độc lập được), thêm UNIQUE thiếu UNIQUE thì hai dòng trỏ cùng chỗ, quan hệ thực chất thành 1-n
1-n bắt buộc ở phía “nhiều” (mỗi sách lưu student_id) đặt ở phía “một” thì một ô chứa nhiều giá trị, vi phạm dạng chuẩn 1
n-n bảng trung gian (join table) với hai cột FK cặp hai FK thường là primary key của bảng trung gian

Mô hình rút gọn dùng trong bài (schema đầy đủ với chapter, lesson, tiến độ, địa chỉ ở bài 3):

erDiagram
  USERS ||--|| USER_PROFILES : has
  TEACHERS ||--o{ COURSES : teaches
  STUDENTS ||--o{ ENROLLMENTS : makes
  COURSES ||--o{ ENROLLMENTS : has
  COURSES }o--o{ TAGS : labeled_with

  USERS {
    bigint id PK
    varchar username
  }
  USER_PROFILES {
    bigint user_id PK,FK
    varchar full_name
  }
  TEACHERS {
    bigint id PK
    varchar name
  }
  COURSES {
    bigint id PK
    bigint teacher_id FK
    varchar title
  }
  STUDENTS {
    bigint id PK
    varchar name
  }
  ENROLLMENTS {
    bigint id PK
    bigint student_id FK
    bigint course_id FK
    datetime enrolled_at
  }
  TAGS {
    bigint id PK
    varchar name
  }

Student - Course bản chất là n-n, nhưng cần lưu thêm ngày đăng ký, thanh toán, tiến độ, nên bảng trung gian thành entity riêng Enrollment (cách làm phổ biến).

1.3. Owning side và mappedBy (slide nói ngược)

Ý chính: owning side là entity giữ FK (có @JoinColumn, hoặc @JoinTable với n-n); Hibernate chỉ nhìn bên này để ghi cột FK. Bên khai báo mappedBy là inverse side, chỉ để điều hướng trong Java.

Giá trị của mappedBy là tên field Java ở entity bên kia, không phải tên cột.

1.4. Quan hệ 1-1

Ý chính: đặt @OneToOne + @JoinColumn ở bảng phụ thuộc (UserProfile), mappedBy ở bảng chính (User). Dùng @MapsId để profile dùng chung primary key với user.

Ví dụ: mỗi User có đúng một UserProfile (họ tên, ngày sinh).

@Entity
@Table(name = "users")
public class User {
    @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String username;

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

    public void setProfile(UserProfile profile) { // giữ hai chiều đồng bộ
        this.profile = profile;
        profile.setUser(this);
    }
}

@Entity
@Table(name = "user_profiles")
public class UserProfile {
    @Id
    private Long id; // dùng chung giá trị với users.id

    @OneToOne(fetch = FetchType.LAZY)
    @MapsId
    @JoinColumn(name = "user_id")
    private User user;

    private String fullName;
}
  • @JoinColumn(name = "user_id") ở UserProfile: owning side, giữ FK tới users. mappedBy = "user" ở User: inverse side.
  • CascadeType.ALL: mọi thao tác trên User lan sang UserProfile, hợp lý vì profile thuộc về user.
  • Slide dùng FetchType.EAGER. Mặc định của @OneToOne và @ManyToOne đúng là EAGER, nhưng nên luôn đặt LAZY rồi fetch khi cần (lý do ở bài 4 của cụm).
  • Mẹo senior: với @MapsId, user_profiles.user_id vừa là PK vừa là FK: không cần cột id, index riêng, và tìm profile bằng findById(userId).
Vì sao phía inverse của @OneToOne vẫn bị load ngay

1.5. Quan hệ 1-n

Ý chính: @ManyToOne + @JoinColumn ở phía “nhiều” luôn là owning side; @OneToMany(mappedBy) ở phía “một”. Helper addCourse ghi cả hai chiều để FK không null.

Ví dụ: một Teacher dạy nhiều Course. FK teacher_id nằm ở bảng courses.

@Entity
public class Teacher {
    @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;

    @OneToMany(mappedBy = "teacher", cascade = {CascadeType.PERSIST, CascadeType.MERGE})
    private List<Course> courses = new ArrayList<>();

    public void addCourse(Course course) {
        courses.add(course);
        course.setTeacher(this); // ghi vào owning side, nếu không FK sẽ null
    }

    public void removeCourse(Course course) {
        courses.remove(course);
        course.setTeacher(null);
    }
}

@Entity
public class Course {
    @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @ManyToOne(fetch = FetchType.LAZY, optional = false)
    @JoinColumn(name = "teacher_id", nullable = false)
    private Teacher teacher;
}
  • @OneToMany mặc định LAZY: courses chỉ được query khi gọi tới (teacher.getCourses().size()).
  • orphanRemoval = true khác CascadeType.REMOVE: nó xoá con khi con bị gỡ khỏi collection; REMOVE chỉ xoá con khi xoá cha. Dùng cho composition thật (Order - OrderLine).
Bẫy @OneToMany một chiều không có @JoinColumn

Đừng làm @OneToMany một chiều không có @JoinColumn: Hibernate tạo bảng trung gian teacher_courses như n-n, thêm bảng và nhiều SQL thừa. Chỉ cần một chiều thì chọn chiều @ManyToOne.

1.6. Quan hệ n-n

Ý chính: owning side đặt @ManyToMany + @JoinTable, bên kia đặt mappedBy. Dùng Set, không cascade xoá; bảng trung gian cần thêm cột thì đổi sang entity riêng.

Slide lấy ví dụ User - Address (người ở nhiều địa chỉ, địa chỉ có nhiều người); pet project dùng Course - Tag.

@Entity
public class Course {
    // ...
    @ManyToMany
    @JoinTable(
        name = "course_tags",
        joinColumns = @JoinColumn(name = "course_id"),        // FK của entity hiện tại
        inverseJoinColumns = @JoinColumn(name = "tag_id"))    // FK của entity bên kia
    private Set<Tag> tags = new HashSet<>();

    public void addTag(Tag tag) { tags.add(tag); tag.getCourses().add(this); }
    public void removeTag(Tag tag) { tags.remove(tag); tag.getCourses().remove(this); }
}

@Entity
public class Tag {
    @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(unique = true)
    private String name;

    @ManyToMany(mappedBy = "tags")
    private Set<Course> courses = new HashSet<>();
}
  • @JoinTable: name là bảng trung gian, joinColumns là FK về entity đang đặt @JoinTable, inverseJoinColumns là FK về entity còn lại.
  • Không cascade REMOVE/ALL cho @ManyToMany: xoá một course sẽ xoá luôn tag mà course khác đang dùng.
Code entity trung gian Enrollment
@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")
    private Student student;

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

    private Instant enrolledAt;
}

1.7. Bảng tổng hợp

Ý chính: owning side luôn là bên mang thông tin cột (@JoinColumn, @MapsId, @JoinTable); inverse side luôn là mappedBy.

Annotation Owning side đặt gì Inverse side đặt gì Fetch mặc định
@OneToOne @JoinColumn (hoặc @MapsId) mappedBy EAGER
@ManyToOne / @OneToMany @ManyToOne + @JoinColumn @OneToMany(mappedBy) EAGER / LAZY
@ManyToMany @JoinTable(joinColumns, inverseJoinColumns) mappedBy LAZY

Bài tập

Bài tập khai báo quan hệ của buổi này làm trên schema E-Learning đầy đủ, nên lời giải nằm ở bài 3, Bài 4. Các bài tạo entity, repository và CRUD ở bài 1.

Đọc thêm từ slide

Ba chủ đề slide gợi ý tự đọc

Slide gợi ý tự tìm hiểu entity relationship (mục 1), Filter trong Spring (servlet filter chạy trước DispatcherServlet, dùng cho logging, trace id, xác thực) và Dependency Injection (xem IoC và Dependency Injection).

Ghi nhớ

  • Nói được FK đặt ở bảng nào cho 1-1, 1-n, n-n, và vì sao 1-1 cần UNIQUE.
  • Giải thích được vì sao chỉ teacher.getCourses().add(course) thì teacher_id vẫn null.
  • Biết khi nào cascade ALL/orphanRemoval an toàn, khi nào xoá nhầm dữ liệu.
  • Giải thích được vì sao @ManyToMany nên dùng Set, và khi nào tách thành entity trung gian.

Câu hỏi phỏng vấn

Junior

Trong quan hệ 1-n, khoá ngoại đặt ở đâu và vì sao?

Ở bảng phía “nhiều” (mỗi course lưu teacher_id).

Đặt ở phía “một” thì một ô phải chứa nhiều giá trị, vi phạm dạng chuẩn 1. Trong JPA, phía @ManyToOne giữ FK và là owning side.

mappedBy dùng để làm gì?

Đánh dấu phía inverse của quan hệ hai chiều; giá trị là tên field ở entity bên kia.

Phía có mappedBy không giữ FK, thay đổi ở đó không được ghi xuống DB. Hibernate chỉ dựa vào owning side (bên có @JoinColumn/@JoinTable).

@OneToMany một chiều không có @JoinColumn sinh ra gì?

Một bảng trung gian thừa (ví dụ teacher_courses), vì Hibernate coi nó như n-n.

Mỗi lần thêm con là thêm một INSERT vào bảng đó, dù nghiệp vụ chỉ cần cột teacher_id ở bảng con. Chỉ cần một chiều thì map @ManyToOne ở phía con; cần cả hai chiều thì thêm @OneToMany(mappedBy = ...) ở phía cha.

Mid

CascadeType.REMOVE và orphanRemoval khác nhau ra sao?

REMOVE xoá con khi cha bị xoá; orphanRemoval xoá con khi con bị gỡ khỏi collection của cha, kể cả khi cha vẫn còn.

Cả hai chỉ phù hợp với quan hệ sở hữu thật sự, không bao giờ dùng cho @ManyToMany.

Vì sao nên dùng Set thay vì List cho @ManyToMany?

Vì List không có cột thứ tự là bag: xoá một phần tử thì Hibernate xoá hết dòng của entity đó trong bảng trung gian rồi chèn lại.

Set cho phép xoá đúng một dòng. Fetch join hai bag cùng lúc còn gây MultipleBagFetchException.

Khi nào dùng @ManyToMany, khi nào tách bảng trung gian thành entity riêng?

@ManyToMany khi bảng trung gian chỉ có hai cột FK; quan hệ cần thuộc tính riêng thì tách entity.

Ví dụ hai cột: course–tag, user–address. Cần ngày đăng ký, điểm, trạng thái, đánh giá thì phải là entity riêng với hai @ManyToOne, có unique constraint trên cặp FK. Nhiều team mặc định dùng entity riêng từ đầu, vì thêm cột vào quan hệ là chuyện thường xảy ra.

Senior

Vì sao @OneToOne phía inverse luôn bị load ngay dù đặt LAZY?

Vì để tạo proxy, Hibernate phải biết quan hệ là null hay có giá trị, mà phía inverse không có cột FK nên phải query bảng kia.

Phía owning có cột FK nên biết ngay. Cách xử lý: dùng @MapsId và chỉ map một chiều từ phía con, hoặc bật bytecode enhancement, hoặc thay bằng truy vấn tường minh khi cần.

Từ vựng tiếng Anh

Term Phát âm Nghĩa Ví dụ câu dùng trong phỏng vấn
owning side /ˈoʊ.nɪŋ saɪd/ bên sở hữu quan hệ (giữ FK) “Only changes on the owning side are written to the foreign key.”
inverse side /ˈɪn.vɜːrs saɪd/ bên nghịch đảo (mappedBy) “The collection with mappedBy is the inverse side.”
foreign key /ˈfɔːr.ən kiː/ khoá ngoại “The foreign key lives on the many side.”
join table /dʒɔɪn ˈteɪ.bəl/ bảng trung gian “A many-to-many relationship needs a join table.”
bidirectional /ˌbaɪ.dɪˈrek.ʃən.əl/ hai chiều “In a bidirectional mapping I keep both sides in sync with helper methods.”
unidirectional /ˌjuː.nɪ.dɪˈrek.ʃən.əl/ một chiều “A unidirectional many-to-one is usually all you need.”
cascade /kæsˈkeɪd/ lan truyền thao tác “I avoid cascading removals on many-to-many associations.”
orphan removal /ˈɔːr.fən rɪˈmuː.vəl/ xoá bản ghi mồ côi “Orphan removal deletes a line item once it’s removed from the order.”
composition /ˌkɑːm.pəˈzɪʃ.ən/ quan hệ sở hữu (con không sống thiếu cha) “Cascade ALL only makes sense for true composition.”

Tiếp theo: ORM và JPA bài 3: ánh xạ schema E-Learning, DTO và vòng lặp JSON.


Ghi chép dựa trên khoá Fundamentals of Backend (Ronin Engineer), viết lại theo cách hiểu của mình.