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

Tìm kiếm

Database & ORMMid14 phút đọc

ORM và JPA: persistence context, dirty checking và N+1

Ôn 13 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

Khi các entity đã trỏ vào nhau (bài 2, bài 3), Hibernate làm nhiều việc ngầm: sửa field không gọi save vẫn có UPDATE, API liệt kê 50 khoá học bắn 51 câu SQL, LazyInitializationException bất ngờ xuất hiện. Đọc xong, bạn giải thích được persistence context, dirty checking, flush, và biết phát hiện, chữa N+1. Nên đọc trước bài 1 (entity, repository) và bài 2 (quan hệ entity).

1. Persistence context và vòng đời entity

Ý chính: persistence context là nơi Hibernate giữ các entity đang quản lý trong một transaction. Entity ở trạng thái managed thì mọi thay đổi tự được ghi xuống DB khi flush.

Slide không có phần này nhưng vòng senior hay hỏi. Ví dụ dùng entity Course, Teacher, Tag của bài 2.

1.1. Persistence context là gì

Persistence context là vùng nhớ gắn với một EntityManager (Hibernate gọi là Session), dạng map (kiểu entity, id) → object. Trong Spring, mặc định nó sống bằng một transaction. Nó đảm bảo hai điều:

  • Cache cấp 1 (first-level cache): findById(1) hai lần trong cùng transaction chỉ ra một câu SQL, lần hai lấy từ context.
  • Identity: trong cùng context, một dòng DB ứng với đúng một object, nên em.find(Course.class, 1) == em.find(Course.class, 1) là true.

1.2. Bốn trạng thái của entity

stateDiagram-v2
  [*] --> Transient: new Course()
  Transient --> Managed: persist()
  Managed --> Removed: remove()
  Removed --> Managed: persist()
  Managed --> Detached: transaction kết thúc / clear() / detach()
  Detached --> Managed: merge() (trả về bản managed mới)
  Removed --> [*]: flush + commit (DELETE)
  [*] --> Managed: find() / query
Bảng bốn trạng thái: có id không, context có theo dõi không
Trạng thái Có id? Context có theo dõi? Ghi chú
Transient (new) Thường chưa Không Object Java bình thường, chưa liên quan DB
Managed (persistent) Có Có Mọi thay đổi được tự ghi xuống DB khi flush
Detached Có Không Context đã đóng; sửa object không có tác dụng gì
Removed Có Có, đã đánh dấu xoá DELETE chạy khi flush
  • persist(entity): biến chính object đó thành managed.
  • merge(entity): copy trạng thái object (thường là detached) vào một bản managed (load từ DB nếu cần) và trả về bản đó. Object truyền vào vẫn detached. Bug hay gặp: tiếp tục sửa object cũ sau khi merge.

1.3. Dirty checking và flush

Khi load entity, Hibernate giữ một snapshot (bản chụp trạng thái ban đầu). Lúc flush, nó so từng field với snapshot, field nào khác thì sinh UPDATE. Đó là dirty checking.

@Transactional
public void rename(long courseId, String newTitle) {
    Course course = courseRepository.findById(courseId).orElseThrow();
    course.rename(newTitle);
    // Không cần gọi save(): course đang managed,
    // khi transaction commit Hibernate flush và tự sinh UPDATE courses SET title=? ...
}

Flush khác commit. Flush gửi SQL xuống DB nhưng vẫn trong transaction hiện tại; commit mới làm thay đổi bền vững và hiển thị cho transaction khác. Rollback sau flush vẫn huỷ hết.

  • Gọi save() cho entity đang managed là thừa (vô hại nhưng gây hiểu lầm).
  • Sửa nhầm field của entity managed (ví dụ để “định dạng” cho response) là thay đổi thật xuống DB. Thêm một lý do để map sang DTO sớm.
Khi nào flush, UPDATE mọi cột và chi phí với job lớn

Flush xảy ra (với FlushMode.AUTO mặc định):

  1. Trước khi transaction commit.
  2. Trước khi chạy một query có thể bị ảnh hưởng bởi thay đổi đang chờ (để query thấy dữ liệu mới nhất).
  3. Khi gọi flush() hoặc saveAndFlush() thủ công.

Ngoại lệ: với GenerationType.IDENTITY, persist phải INSERT ngay để lấy id, không chờ flush, nên Hibernate cũng không gom được INSERT thành JDBC batch. Bài lỗi thường gặp có ví dụ lỗi unique bị ném từ save() chứ không phải flush().

Load 10.000 entity trong một transaction nghĩa là 10.000 snapshot trong heap và flush phải so 10.000 object. Với job lớn: chia lô và flush() + clear() sau mỗi lô, hoặc dùng @Transactional(readOnly = true) khi chỉ đọc (Hibernate bỏ qua snapshot và dirty checking).

2. Lazy, eager và bài toán N+1

Ý chính: để quan hệ LAZY rồi fetch đúng thứ cần cho từng use case. N+1 là cái giá khi chạm vào quan hệ lazy trong vòng lặp; chữa bằng cách lấy quan hệ theo lô hoặc trong cùng một câu SQL.

2.1. Lazy và eager

  • EAGER: load entity thì load luôn quan hệ (bằng JOIN hoặc query phụ).
  • LAZY: quan hệ được thay bằng proxy (object giả đứng chỗ, với @ManyToOne) hoặc collection bọc (PersistentBag, PersistentSet với @OneToMany). Chỉ khi truy cập dữ liệu bên trong, Hibernate mới chạy query.

LazyInitializationException: truy cập quan hệ lazy sau khi persistence context đã đóng, ví dụ Jackson serialize course.getTeacher().getName() ở controller. Sửa đúng là fetch đủ dữ liệu trong service (fetch join, entity graph, DTO projection), không phải bật EAGER hay open-in-view (xem bài 5 của cụm).

Lỗi này hay lọt qua test: @Transactional trên test giữ session mở đến hết test nên lazy loading vẫn chạy, còn production thì ném exception; xem bài test Spring Boot.

2.2. N+1 là gì

@Transactional(readOnly = true)
public List<CourseSummary> listCourses() {
    return courseRepository.findAll().stream()                 // 1 query: SELECT * FROM courses
            .map(c -> new CourseSummary(c.getTitle(),
                                        c.getTeacher().getName())) // N query: SELECT * FROM teacher WHERE id=?
            .toList();
}

Mỗi khoá học thêm một query lấy giảng viên: N+1 query, 50 dòng là 51 round-trip (lượt đi về) tới DB. Local nhanh nên không ai thấy; production có độ trễ mạng và nhiều request đồng thời thì sập.

Phát hiện: bật log SQL khi dev, bật hibernate.generate_statistics=true, viết test đếm số câu query (datasource-proxy hoặc Hypersistence Utils hỗ trợ assert số statement).

2.3. Cách khắc phục

1. Fetch join trong JPQL: lấy luôn quan hệ trong một câu SQL có JOIN.

@Query("select c from Course c join fetch c.teacher where c.status = :status")
List<Course> findWithTeacherByStatus(@Param("status") CourseStatus status);

2. @EntityGraph: khai báo quan hệ cần fetch mà không phải viết JPQL, dùng được với derived query.

@EntityGraph(attributePaths = {"teacher", "tags"})
List<Course> findByStatus(CourseStatus status);

3. Batch fetching: vẫn lazy, nhưng gom nhiều id vào một câu WHERE id IN (...). N+1 thành 1 + ceil(N/batch). Nên bật mặc định làm “lưới an toàn”, hoặc đặt @BatchSize(size = 50) trên từng collection/entity.

spring.jpa.properties.hibernate.default_batch_fetch_size: 50

4. DTO projection: chỉ select đúng cột cần, không load entity, không dirty checking. Nhanh nhất cho màn hình chỉ đọc.

public record CourseSummary(Long id, String title, String teacherName) {}

@Query("""
       select new com.vinhnq.elearning.dto.CourseSummary(c.id, c.title, t.name)
       from Course c join c.teacher t
       where c.status = :status
       """)
List<CourseSummary> findSummaries(@Param("status") CourseStatus status);
Thêm hai chuyện của fetch join với collection
  • MultipleBagFetchException: fetch join hai collection kiểu List trong cùng query. Đổi sang Set thì hết lỗi nhưng ra tích Descartes (10 tag × 100 enrollment = 1000 dòng cho một course). Nên fetch từng collection bằng query riêng.

Bài tập

Bài 6 (luyện thêm, không có trong slide): đếm và chữa N+1 trên API danh sách khoá học

Yêu cầu: API GET /courses trả về tên khoá học kèm username giảng viên. Viết một test chứng minh code hiện tại bị N+1, rồi sửa sao cho số câu SQL không tăng theo số khoá học.

Lời giải Bài 6: test đếm query và số đo trên Hibernate 6.6

Bật thống kê của Hibernate (spring.jpa.properties.hibernate.generate_statistics=true) và đếm số câu lệnh đã prepare:

@SpringBootTest
@Transactional
class CourseListQueryCountTest {
    @Autowired CourseRepository courseRepository;
    @Autowired EntityManagerFactory emf;

    @Test
    void listing_courses_uses_a_constant_number_of_queries() {
        Statistics stats = emf.unwrap(SessionFactory.class).getStatistics();
        stats.clear();

        courseRepository.findAllWithTeacher()          // query đã sửa
                .forEach(c -> c.getTeacher().getUsername());

        assertThat(stats.getPrepareStatementCount()).isEqualTo(1);
    }
}
public interface CourseRepository extends JpaRepository<Course, Long> {
    @Query("select c from Course c join fetch c.teacher")
    List<Course> findAllWithTeacher();
}

Mình chạy thử cùng mapping này trên Hibernate 6.6 + H2 với 50 khoá học, mỗi khoá một giảng viên:

Cách lấy dữ liệu Số câu SQL
from Course rồi gọi getTeacher().getUsername() trong vòng lặp 51
Như trên nhưng bật default_batch_fetch_size = 50 2
join fetch c.teacher 1

Vòng lặp chạm vào proxy teacher của từng khoá học, mỗi lần một câu SELECT ... FROM teacher WHERE id = ?. Fetch join lấy cả hai bảng trong một câu JOIN; batch fetching vẫn lazy nhưng gom 50 id vào một câu IN (...).

Senior sẽ làm thêm: trả CourseSummary (DTO projection) cho màn hình chỉ đọc; đặt test đếm query cho mọi API danh sách quan trọng để N+1 không quay lại sau refactor; bật default_batch_fetch_size làm lưới an toàn cho cả dự án.

Ghi nhớ

  • Giải thích được persistence context đảm bảo hai điều gì, và nó sống bao lâu trong Spring.
  • Biết vì sao sửa object sau merge không có tác dụng, và vì sao save() với id tự gán thêm một SELECT.
  • Giải thích được vì sao sửa entity không gọi save vẫn có UPDATE, và flush khác commit ở đâu.
  • Kể được bốn cách chữa N+1 và khi nào chọn cách nào.
  • Biết vì sao join fetch collection kèm Pageable nguy hiểm và cách làm thay.

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

Junior

First-level cache (cache cấp 1) của JPA là gì?

Là persistence context gắn với một EntityManager, trong Spring thường sống bằng một transaction.

Trong cùng transaction, findById(1) lần hai không chạy SQL mà lấy object đã có, và một dòng DB luôn ứng với đúng một object Java. Nó không chia sẻ giữa các transaction hay request; cache dùng chung giữa nhiều request là second-level cache, một thứ khác và phải bật riêng.

Flush khác commit thế nào?

Flush gửi SQL đang chờ xuống DB nhưng vẫn trong transaction; commit mới kết thúc transaction và làm thay đổi bền vững.

Sau flush, transaction khác chưa thấy thay đổi và rollback vẫn huỷ được. Hibernate tự flush trước khi commit và trước những query có thể bị ảnh hưởng bởi thay đổi đang chờ.

Mid

Kể các trạng thái của entity. persist và merge khác nhau thế nào?

Transient, managed, detached, removed. persist biến chính object thành managed; merge copy vào một bản managed và trả về bản đó.

Transient là mới, chưa được quản lý; managed nằm trong persistence context, thay đổi được tự ghi; detached là context đã đóng; removed là đã đánh dấu xoá. Sau merge, object truyền vào vẫn detached.

Dirty checking là gì? Vì sao sửa entity mà không gọi save vẫn có UPDATE?

Hibernate so entity managed với snapshot lúc load, và sinh UPDATE khi flush cho entity bị đổi.

Flush chạy trước commit hoặc trước query liên quan, nên entity managed trong transaction không cần save. Hệ quả: sửa nhầm entity để hiển thị cũng bị lưu xuống DB.

LazyInitializationException xảy ra khi nào và cách sửa?

Khi truy cập quan hệ lazy sau khi persistence context đóng; sửa bằng cách fetch đủ dữ liệu trong service và trả DTO.

Thường gặp ở controller hoặc lúc Jackson serialize entity. Fetch bằng fetch join, @EntityGraph hoặc DTO projection trong transaction của service. Không sửa bằng EAGER hay open-in-view vì chỉ che giấu vấn đề và gây N+1.

Senior

N+1 là gì, phát hiện và xử lý thế nào?

Một query lấy N dòng cha rồi mỗi dòng kích hoạt một query lazy, tổng N+1 round-trip; chữa theo use case.

Phát hiện bằng log SQL, Hibernate statistics, hoặc test assert số câu query. Xử lý: fetch join hoặc @EntityGraph cho quan hệ to-one, batch fetching (default_batch_fetch_size) làm lưới an toàn, DTO projection cho màn hình chỉ đọc. Với collection + phân trang thì query trang id trước rồi fetch theo id, tránh phân trang trong bộ nhớ.

Một batch job xử lý 1 triệu dòng bằng JPA bị OOM và chậm dần. Vì sao và sửa thế nào?

Persistence context giữ mọi entity đã load cùng snapshot, nên heap tăng tuyến tính và mỗi lần flush phải dirty-check toàn bộ.

Sửa:

  • Xử lý theo lô (đọc theo keyset), flush() + clear() sau mỗi lô.
  • Bật hibernate.jdbc.batch_size và order_inserts/order_updates, dùng id SEQUENCE để batch được insert.
  • Dùng readOnly hoặc StatelessSession khi không cần dirty checking, hoặc bulk UPDATE/JDBC thuần cho thao tác hàng loạt.

Từ vựng tiếng Anh

Term Phát âm Nghĩa Ví dụ câu dùng trong phỏng vấn
persistence context /pərˈsɪs.təns ˈkɑːn.tekst/ vùng quản lý entity của EntityManager “The persistence context acts as a first-level cache within a transaction.”
first-level cache /fɜːrst ˈlev.əl kæʃ/ cache cấp 1 trong một transaction “The second findById call was served from the first-level cache.”
snapshot /ˈsnæp.ʃɑːt/ bản chụp trạng thái ban đầu “Hibernate compares each managed entity with its snapshot on flush.”
lazy loading /ˈleɪ.zi ˈloʊ.dɪŋ/ tải trễ “Lazy loading defers the query until you touch the association.”
dirty checking /ˈdɜːr.ti ˈtʃek.ɪŋ/ kiểm tra thay đổi tự động “Thanks to dirty checking, I don’t need to call save on a managed entity.”
flush /flʌʃ/ đẩy thay đổi xuống DB “A flush sends SQL to the database, but nothing is visible until commit.”
N+1 problem /en plʌs wʌn ˈprɑː.bləm/ lỗi N+1 query “The N+1 problem showed up as fifty-one queries for one page.”
fetch join /fetʃ dʒɔɪn/ join kèm tải quan hệ “A fetch join loads the teacher in the same query.”
projection /prəˈdʒek.ʃən/ chỉ chọn một số cột “For read-only screens I use a DTO projection.”

Tiếp theo: ORM và JPA bài 5: JPQL, native query, @Transactional và locking (open-session-in-view nằm ở đó).


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.