Cả bài trong một trang: ý chính, sơ đồ, điểm phỏng vấn.
ORM và JPA: quan hệ entity 1-1, 1-n, n-n và mappedBy
1FK nằm ở đâu
Quan hệ trong Java phải khớp với khoá ngoại (FK, cột trỏ tới PK bảng khác) trong DB. Loại quan hệ quyết định FK nằm ở đâu.
Quan hệ
FK đặt ở
Ghi chú
1-1
Bảng phụ thuộc
Thêm UNIQUE
1-n
Phía "nhiều"
Mỗi course lưu teacher_id
n-n
Bảng trung gian
Hai cột FK
2Owning side và mappedBy
Owning side là bên giữ FK (@JoinColumn, @JoinTable); Hibernate chỉ nhìn bên này để ghi cột. Bên có mappedBy là inverse side, chỉ để điều hướng. Slide gọi ngược.
flowchart TD
T["Teacher: @OneToMany(mappedBy)"] -.->|"chỉ điều hướng"| C["Course: @ManyToOne + @JoinColumn"]
C -->|"Hibernate ghi"| F["Cột teacher_id"]
3Helper ghi cả hai chiều
Chỉ sửa phía mappedBy thì FK vẫn null. Viết helper cập nhật cả hai chiều, và để mọi quan hệ LAZY.
@OneToMany(mappedBy = "teacher",
cascade = {PERSIST, MERGE})
private List<Course> courses = new ArrayList<>();
public void addCourse(Course c) {
courses.add(c);
c.setTeacher(this); // ghi owning side
}
4Quan hệ n-n
Owning side đặt @ManyToMany + @JoinTable, bên kia mappedBy. Dùng Set, không cascade xoá; cần thêm cột thì tách entity trung gian.
List không thứ tự là "bag": xoá một, chèn lại hết
Thêm cột như ngày đăng ký: entity Enrollment
Không bao giờ cascade ALL cho @ManyToMany
5Cascade và các bẫy mapping
Cascade ALL/orphanRemoval chỉ cho composition thật (con không sống thiếu cha). REMOVE xoá con khi xoá cha; orphanRemoval xoá con khi gỡ khỏi collection.
@OneToMany một chiều thiếu @JoinColumn: thêm bảng thừa
Inverse @OneToOne không lazy được
@MapsId: profile dùng chung PK với user
💡 Ghi nhớ
FK ở phía "nhiều"; 1-1 thêm UNIQUE.
Owning side giữ FK; mappedBy là inverse.
Mọi quan hệ để LAZY, fetch có chủ đích.
@ManyToMany dùng Set.
⭐ Điểm phỏng vấn
Tự trả lời trước, rồi bấm từng câu để xem đáp án.
mappedBy dùng làm gì?
Đánh dấu inverse side, trỏ tên field bên kia.
REMOVE khác orphanRemoval?
REMOVE theo cha; orphanRemoval khi gỡ khỏi collection.
Vì sao inverse @OneToOne load ngay?
Không có FK, phải query để biết null.
Xong phần tự kiểm tra, bài này đã được đánh dấu đã học ✓
⚠️ Lỗi thường gặp
Chỉ add vào list phía mappedBy, FK lưu xuống là null.
Dùng List cho @ManyToMany, bảng trung gian bị xoá chèn lại.
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.
@Entitypublic 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); }}@Entitypublic 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.
@Entitypublic 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); }}@Entitypublic 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.
Ý 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.”