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ớiusers.mappedBy = "user"ởUser: inverse side.CascadeType.ALL: mọi thao tác trênUserlan sangUserProfile, hợp lý vì profile thuộc về user.- Slide dùng
FetchType.EAGER. Mặc định của@OneToOnevà@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_idvừa là PK vừa là FK: không cần cột id, index riêng, và tìm profile bằngfindById(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;
}
@OneToManymặc định LAZY:courseschỉ được query khi gọi tới (teacher.getCourses().size()).orphanRemoval = truekhácCascadeType.REMOVE: nó xoá con khi con bị gỡ khỏi collection;REMOVEchỉ 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:namelà bảng trung gian,joinColumnslà FK về entity đang đặt@JoinTable,inverseJoinColumnslà FK về entity còn lại.- Không cascade
REMOVE/ALLcho@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_idvẫnnull. - Biết khi nào cascade
ALL/orphanRemovalan toàn, khi nào xoá nhầm dữ liệu. - Giải thích được vì sao
@ManyToManynên dùngSet, 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.