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 này giải quyết hai vấn đề slide buổi ORM 3 đặt ra: truy vấn phức tạp khi derived query không đủ, và cập nhật hiệu quả khi không muốn select rồi mới update. Sau đó là ba chủ đề senior: @Transactional hỏng ở đâu, khoá lạc quan và bi quan, và vì sao nên tắt open-session-in-view. Nên đọc trước bài 4 về persistence context và N+1.
1. Đặt vấn đề
Ý chính: derived query hết sức khi truy vấn phức tạp hoặc lọc động, còn cách “load rồi sửa” tốn một SELECT cho mỗi lần update. Bài dùng @Query, Specification và bulk update để giải hai việc đó.
1.1. Truy vấn: derived query không đủ
Derived query sinh câu truy vấn từ tên method. Tiện cho truy vấn đơn giản, nhưng khi phức tạp:
List<Course> findByStatusAndPriceBetweenAndTeacherNameContainingIgnoreCaseOrderByCreatedAtDesc(
CourseStatus status, BigDecimal min, BigDecimal max, String teacherName);
- Tên method dài, khó đọc, khó review.
- Không hỗ trợ GROUP BY, HAVING, subquery, hàm tổng hợp phức tạp. Join đơn giản qua property path thì có, như
TeacherNameở trên. - Không có điều kiện động: mỗi tổ hợp bộ lọc cần một method khác.
Giải pháp: @Query với JPQL hoặc native SQL; điều kiện động thì dùng Specification/Criteria (mục 4).
1.2. Lưu dữ liệu: phải select trước khi update
2. JPQL
Ý chính: JPQL viết trên tên entity và field Java, Hibernate dịch sang SQL của DB đang dùng. Muốn UPDATE/DELETE thì thêm @Modifying và chạy trong transaction.
2.1. JPQL là gì
JPQL (Jakarta Persistence Query Language) là ngôn ngữ truy vấn hướng đối tượng: viết trên tên entity và tên field, không phải tên bảng và cột. Cùng một câu JPQL chạy được trên MySQL, PostgreSQL… vì Hibernate dịch theo dialect.
public interface UserRepository extends JpaRepository<User, Long> {
@Query("select u from User u where u.username = :username and u.status = :status")
Optional<User> findActive(@Param("username") String username,
@Param("status") UserStatus status);
@Query("""
select c.teacher.name as teacherName, count(c) as total
from Course c
where c.status = :status
group by c.teacher.name
having count(c) >= :min
""")
List<TeacherCourseCount> countByTeacher(@Param("status") CourseStatus status,
@Param("min") long min);
}
public interface TeacherCourseCount { // interface projection
String getTeacherName();
long getTotal();
}
@Param và cờ -parameters từ Spring 6.1
2.2. Bulk update và delete với @Modifying
@Modifying(clearAutomatically = true, flushAutomatically = true)
@Transactional
@Query("update User u set u.status = :status where u.id = :id")
int updateStatus(@Param("id") Long id, @Param("status") UserStatus status);
@Modifying
@Transactional
@Query("delete from User u where u.status = :status and u.lastLoginAt < :before")
int deleteInactive(@Param("status") UserStatus status, @Param("before") Instant before);
@Modifyingbáo Spring Data đây không phải SELECT, nên gọiexecuteUpdate(); trảintlà số dòng bị ảnh hưởng.- Bắt buộc có transaction, nếu không sẽ gặp
TransactionRequiredException. Repository mặc định là transaction read-only, nên đặt@Transactionaltrên method hoặc gọi từ service có transaction.
2.3. Hạn chế của JPQL
- Không phủ hết SQL: window function, CTE đệ quy,
ON CONFLICT/ON DUPLICATE KEY, hint, kiểu JSON, full-text search. - Phụ thuộc cách map entity: query đi theo quan hệ đã map; quan hệ không map phải join tường minh theo điều kiện.
- Khó tối ưu: không trực tiếp kiểm soát SQL sinh ra, phải bật log để xem.
HQL của Hibernate 6 vượt ra ngoài JPQL chuẩn
Hibernate 6 đã bổ sung khá nhiều qua HQL: CTE, window function, set operation. Nhưng đó là HQL, không còn là JPQL chuẩn, nên gắn code với Hibernate.
3. Native query
Ý chính: native query là SQL chạy nguyên văn, dùng được mọi tính năng của DB nhưng gắn chặt với DB đó và không được kiểm tra lúc build. Dù JPQL hay native, luôn dùng tham số bind.
3.1. Native query là gì
Native query là câu SQL viết trực tiếp cho DB đang dùng: SELECT, INSERT, UPDATE, DELETE, upsert, CTE, window function, hint.
@Query(value = """
select * from users
where username = :username and status = :status
""", nativeQuery = true)
Optional<User> findActiveNative(@Param("username") String username,
@Param("status") String status);
@Modifying
@Transactional
@Query(value = """
insert into course_views (course_id, view_date, views)
values (:courseId, current_date, 1)
on duplicate key update views = views + 1
""", nativeQuery = true)
void incrementViews(@Param("courseId") Long courseId); // upsert đặc thù MySQL
Native update, delete và báo cáo với window function
@Modifying
@Transactional
@Query(value = "update users set status = :status where username = :username", nativeQuery = true)
int updateStatusNative(@Param("username") String username, @Param("status") String status);
@Modifying
@Transactional
@Query(value = "delete from users where status = :status and updated_date < :before", nativeQuery = true)
int deleteInactiveBefore(@Param("status") String status, @Param("before") LocalDateTime before);
Ví dụ native delete trong slide chỉ có câu SQL, thiếu khai báo method, và dùng lẫn tên bảng user/users. deleteInactiveBefore là bản đầy đủ: @Modifying + @Transactional, tham số có @Param, trả số dòng bị xoá, thống nhất dùng users.
Truy vấn báo cáo với window function, thứ JPQL chuẩn không làm được:
public interface TopCourseRow {
Long getCourseId();
String getTitle();
Long getEnrollments();
Integer getRankInCategory();
}
@Query(value = """
select c.id as courseId, c.title as title, count(e.id) as enrollments,
rank() over (partition by c.category_id order by count(e.id) desc) as rankInCategory
from courses c
left join enrollments e on e.course_id = c.id
group by c.id, c.title, c.category_id
""", nativeQuery = true)
List<TopCourseRow> topCoursesPerCategory();
3.2. Hạn chế của native query
- Phụ thuộc DB: sang PostgreSQL là phải sửa (
on duplicate keythànhon conflict). - Mất trừu tượng: phải biết tên bảng, cột; đổi tên field entity thì query không báo lỗi lúc biên dịch.
- Khó bảo trì: sai chỉ lộ lúc chạy, nên cần integration test (Testcontainers với đúng DB production).
- Phân trang cần thêm
countQuery. - Trả entity thì entity vào persistence context; trả projection thì không.
3.3. Không bao giờ nối chuỗi SQL
Cả JPQL và native đều phải dùng tham số bind (:name, ?1). Nối input người dùng vào câu query là SQL injection:
// SAI: username = "x' or '1'='1" sẽ trả về mọi user
em.createNativeQuery("select * from users where username = '" + username + "'");
// ĐÚNG
em.createNativeQuery("select * from users where username = :u", User.class)
.setParameter("u", username);
Tham số bind không thay được tên cột hay hướng sắp xếp. Sắp xếp động thì map từ một whitelist, hoặc dùng Sort của Spring Data (nó kiểm tra property có tồn tại).
3.4. Chọn cái nào
4. Truy vấn động với Specification
Ý chính: mỗi bộ lọc là một Specification nhỏ, trả null khi không có giá trị. Ghép chúng lại thì chỉ bộ lọc có giá trị mới vào WHERE.
Repository kế thừa thêm JpaSpecificationExecutor:
public interface CourseRepository extends JpaRepository<Course, Long>,
JpaSpecificationExecutor<Course> {}
public final class CourseSpecs {
private CourseSpecs() {}
public static Specification<Course> hasStatus(CourseStatus status) {
return (root, q, cb) -> status == null ? null : cb.equal(root.get("status"), status);
}
public static Specification<Course> titleContains(String keyword) {
return (root, q, cb) -> keyword == null || keyword.isBlank() ? null
: cb.like(cb.lower(root.get("title")), "%" + keyword.toLowerCase() + "%");
}
public static Specification<Course> priceBetween(BigDecimal min, BigDecimal max) {
return (root, q, cb) -> {
if (min == null && max == null) return null;
if (min == null) return cb.le(root.get("price"), max);
if (max == null) return cb.ge(root.get("price"), min);
return cb.between(root.get("price"), min, max);
};
}
}
// Service
Page<Course> page = courseRepository.findAll(
Specification.allOf(
CourseSpecs.hasStatus(filter.status()),
CourseSpecs.titleContains(filter.keyword()),
CourseSpecs.priceBetween(filter.minPrice(), filter.maxPrice())),
PageRequest.of(filter.page(), Math.min(filter.size(), 100), Sort.by("createdAt").descending()));
Specification.allOf có từ Spring Data JPA 3.0; bản cũ dùng Specification.where(a).and(b). Phân trang kèm bộ lọc động (Pageable, Page hay Slice, gộp OR các khoảng giá, chặn cột sort lạ) có ở bài phân trang và lọc động.
5. @Transactional: hoạt động thế nào và hỏng ở đâu
Ý chính: @Transactional chỉ chạy khi lời gọi đi qua proxy Spring bọc bean. Phần lớn bug đến từ việc lời gọi không qua proxy, exception không làm rollback, hoặc transaction giữ connection quá lâu.
5.1. Cơ chế
Spring bọc bean bằng một AOP proxy (đối tượng đứng trước bean, chặn lời gọi để thêm hành vi). Khi code bên ngoài gọi method, proxy mở transaction: lấy connection từ pool, setAutoCommit(false), gắn vào thread qua ThreadLocal. Rồi nó gọi method thật, và commit hoặc rollback.
sequenceDiagram
participant C as Controller
participant P as Proxy của CourseService
participant S as CourseService thật
participant DB as Database
C->>P: enroll()
P->>DB: begin (lấy connection, autocommit=false)
P->>S: enroll()
S->>DB: SELECT / INSERT ...
S-->>P: return (hoặc throw)
P->>DB: commit (hoặc rollback nếu RuntimeException)
P-->>C: kết quả
5.2. Các cạm bẫy
Propagation (cách method tham gia transaction đang có), ba loại hay dùng:
| Propagation | Hành vi |
|---|---|
REQUIRED (mặc định) |
Có transaction thì tham gia, chưa có thì tạo mới |
REQUIRES_NEW |
Luôn tạo transaction mới, tạm dừng transaction ngoài |
NESTED |
Savepoint trong transaction hiện tại (chỉ với JDBC DataSourceTransactionManager) |
Đặt @Transactional ở tầng service, nơi định nghĩa một đơn vị nghiệp vụ, không phải controller hay repository. Repository của Spring Data đã có transaction riêng cho từng method. Nhiều lời gọi repository mà service không có transaction thì mỗi cái commit riêng, mất tính nguyên tử.
Thêm: method không public, readOnly = true và đủ bảng propagation
Method không public / final. Proxy không chặn được method private. Từ Spring 6, method protected và package-private được hỗ trợ khi dùng proxy class (CGLIB), nhưng method final hoặc static thì không bao giờ.
Bốn loại propagation còn lại:
| Propagation | Hành vi |
|---|---|
SUPPORTS |
Có thì tham gia, không thì chạy không transaction |
MANDATORY |
Bắt buộc phải có sẵn, không có thì ném exception |
NOT_SUPPORTED |
Tạm dừng transaction hiện tại, chạy không transaction |
NEVER |
Có transaction là ném exception |
6. Locking: optimistic và pessimistic
Ý chính: hai người cùng đọc rồi cùng ghi thì người sau đè mất người trước (lost update). Có ba cách chặn: kiểm tra version lúc ghi, khoá dòng lúc đọc, hoặc để một câu UPDATE có điều kiện tự làm nguyên tử.
Bài toán: khoá học còn 1 chỗ, hai học viên bấm đăng ký cùng lúc. Cả hai đọc seats_left = 1, cả hai ghi seats_left = 0, và khoá học nhận 101 học viên.
6.1. Optimistic locking
Giả định xung đột hiếm. Không khoá khi đọc; khi ghi thì kiểm tra có ai sửa trước mình không. Giống sửa tài liệu chung: lúc lưu mới phát hiện người khác đã lưu bản mới hơn.
@Entity
public class Course {
@Id @GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
private int seatsLeft;
@Version
private long version;
public void takeSeat() {
if (seatsLeft <= 0) throw new CourseFullException(id);
seatsLeft--;
}
}
Hibernate sinh:
UPDATE courses SET seats_left = 0, version = 8 WHERE id = 42 AND version = 7;
-- 0 dòng bị ảnh hưởng → ai đó đã sửa trước → OptimisticLockException
Spring bọc thành ObjectOptimisticLockingFailureException. Xử lý: trả 409 Conflict, hoặc retry cả transaction để đọc lại dữ liệu mới.
Retry với @Retryable và @Version qua HTTP (ETag)
@Retryable(retryFor = ObjectOptimisticLockingFailureException.class, maxAttempts = 3,
backoff = @Backoff(delay = 50, multiplier = 2))
@Transactional
public void enroll(long courseId, long studentId) { ... }
Thứ tự proxy quan trọng: retry phải bọc bên ngoài transaction, mỗi lần thử là một transaction mới. Spring Retry mặc định có order cao hơn transaction nên đúng như vậy; tách ra hai bean là cách chắc chắn nhất.
@Version cũng là cách đúng để làm optimistic concurrency qua HTTP: trả version dưới dạng ETag, client gửi lại bằng If-Match, version lệch thì trả 412 (xem bài thiết kế REST API).
6.2. Pessimistic locking
Giả định xung đột thường xuyên. Khoá dòng ngay khi đọc, transaction khác phải chờ.
public interface CourseRepository extends JpaRepository<Course, Long> {
@Lock(LockModeType.PESSIMISTIC_WRITE)
@QueryHints(@QueryHint(name = "jakarta.persistence.lock.timeout", value = "3000"))
@Query("select c from Course c where c.id = :id")
Optional<Course> findForUpdate(@Param("id") Long id);
}
Sinh SELECT ... FOR UPDATE. Chỉ có tác dụng trong transaction; khoá giữ đến khi commit hoặc rollback.
PESSIMISTIC_READ→ khoá chia sẻ (FOR SHARE): nhiều người cùng đọc, không ai sửa được.PESSIMISTIC_WRITE→ khoá độc quyền (FOR UPDATE).- Luôn đặt lock timeout để không chờ vô hạn.
- Khoá nhiều dòng thì khoá theo thứ tự cố định (ví dụ id tăng dần) để tránh deadlock.
- Hàng đợi job:
FOR UPDATE SKIP LOCKEDcho nhiều worker lấy job khác nhau mà không chờ nhau (Hibernate: lock timeout-2).
6.3. Cách thứ ba: để DB tự làm nguyên tử
Nhiều khi không cần đọc rồi ghi, chỉ cần một câu UPDATE có điều kiện:
@Modifying
@Transactional
@Query("update Course c set c.seatsLeft = c.seatsLeft - 1 where c.id = :id and c.seatsLeft > 0")
int takeSeat(@Param("id") Long id); // trả 0 nghĩa là hết chỗ
Một câu, khoá dòng rất ngắn, không lost update. Đổi lại, nó bỏ qua @Version và persistence context (mục 2.2).
6.4. So sánh
Locking ở ứng dụng còn phối hợp với isolation level của DB (InnoDB mặc định REPEATABLE READ, PostgreSQL mặc định READ COMMITTED). Chi tiết ở bài Database.
7. Open Session in View (OSIV)
Ý chính: OSIV giữ EntityManager mở suốt request để lazy loading “chạy được” ở controller và lúc serialize. Cái giá là giữ connection lâu và che N+1, nên tắt nó đi.
Spring Boot mặc định spring.jpa.open-in-view=true và in cảnh báo lúc khởi động. Khi bật, một interceptor mở EntityManager từ đầu request đến khi ghi xong response.
sequenceDiagram
participant F as OSIV interceptor
participant C as Controller
participant S as Service (@Transactional)
participant J as Jackson
F->>F: mở EntityManager (giữ suốt request)
F->>C: xử lý request
C->>S: getCourses()
S-->>C: List<Course> (transaction đã commit)
C->>J: serialize entity
J->>J: course.getTeacher().getName() → lazy query ngoài transaction
F->>F: đóng EntityManager sau khi ghi response
Cùng gốc vấn đề: entity cất vào HTTP session cũng mất persistence context ở request sau, chạm field lazy là lỗi; bài session và remember-me giải thích vì sao session chỉ nên giữ id hoặc DTO.
Bài tập
Hoàn thiện pet project
Yêu cầu (diễn đạt lại): hoàn thành pet project E-Learning: mọi API đã thiết kế phải chạy với dữ liệu thật, dùng JPQL/native query ở chỗ derived query không đủ. Đề tổng thể ở bài Pet project thực hành.
Mình chia thành bốn việc, mỗi việc dùng một kỹ thuật trong bài:
- Màn hình tìm kiếm khoá học nhiều bộ lọc → Specification + phân trang +
@EntityGraph. - Thống kê số học viên theo khoá học của một giảng viên → JPQL group by + DTO projection.
- Đăng ký khoá học giới hạn chỗ, an toàn khi đồng thời → conditional UPDATE + unique constraint.
- Vô hiệu hoá hàng loạt khoá học quá hạn → bulk update
@Modifyingchạy từ cron job.
Lời giải bốn việc của pet project
1. Tìm kiếm nhiều bộ lọc → Specification + phân trang (mục 4), cộng @EntityGraph để lấy teacher trong cùng query:
public interface CourseRepository extends JpaRepository<Course, Long>, JpaSpecificationExecutor<Course> {
@Override
@EntityGraph(attributePaths = "teacher")
Page<Course> findAll(Specification<Course> spec, Pageable pageable);
}
2. Thống kê theo giảng viên → JPQL với group by và DTO projection:
public record CourseStats(Long courseId, String title, long students) {}
@Query("""
select new com.vinhnq.elearning.dto.CourseStats(c.id, c.title, count(e))
from Course c left join Enrollment e on e.course = c
where c.teacher.id = :teacherId
group by c.id, c.title
order by count(e) desc
""")
List<CourseStats> statsForTeacher(@Param("teacherId") Long teacherId);
3. Đăng ký có giới hạn chỗ → conditional UPDATE + unique constraint:
@Transactional
public void enroll(long courseId, long studentId) {
if (courseRepository.takeSeat(courseId) == 0) {
throw new CourseFullException(courseId); // → 409
}
try {
enrollmentRepository.saveAndFlush(new Enrollment(
studentRepository.getReferenceById(studentId),
courseRepository.getReferenceById(courseId),
Instant.now()));
} catch (DataIntegrityViolationException e) {
throw new AlreadyEnrolledException(studentId, courseId); // unchecked → rollback cả takeSeat
}
}
saveAndFlush để vi phạm unique constraint lộ ra ngay trong method (nếu không, lỗi chỉ xuất hiện lúc commit, ngoài khối try). Exception unchecked làm rollback luôn câu trừ chỗ.
4. Vô hiệu hoá khoá học quá hạn → bulk update với @Modifying, chạy từ một cron job (xem bài Cron job):
@Modifying(clearAutomatically = true)
@Transactional
@Query("update Course c set c.status = :archived where c.status = :published and c.endDate < :today")
int archiveExpired(@Param("archived") CourseStatus archived,
@Param("published") CourseStatus published,
@Param("today") LocalDate today);
Kiểm tra: integration test với Testcontainers MySQL, có một test bắn 20 request đăng ký song song vào khoá học còn 5 chỗ và khẳng định đúng 5 enrollment được tạo.
Ghi nhớ
- Chọn được giữa derived query, JPQL, native và Specification cho một truy vấn cụ thể, và nói được vì sao.
- Kể được bốn thứ bulk
@Modifyingbỏ qua, vàclearAutomatically/flushAutomaticallysửa được gì. - Giải thích được vì sao self-invocation, checked exception và nuốt exception làm
@Transactionalkhông như mong đợi. - Biết khi nào dùng
@Version,FOR UPDATEhay conditional UPDATE cho bài “đặt chỗ có giới hạn”. - Giải thích được vì sao tắt open-session-in-view và thay bằng gì.
Câu hỏi phỏng vấn
Junior
JPQL khác SQL thế nào?
JPQL viết trên entity và field Java, không phụ thuộc DB; SQL (native) viết trên bảng và cột, gắn chặt với một DB.
Hibernate dịch JPQL sang SQL của DB đang dùng. Native query chạy nguyên văn, dùng được mọi tính năng của DB đó.
@Modifying dùng để làm gì?
Đánh dấu @Query là UPDATE/DELETE (hoặc INSERT với native) để Spring Data gọi executeUpdate() thay vì lấy kết quả.
Phải chạy trong transaction; trả về số dòng bị ảnh hưởng.
Khi nào derived query không còn phù hợp?
Khi tên method quá dài, khi cần group by/having/subquery/hàm tổng hợp, hoặc khi điều kiện lọc là động.
Lúc đó chuyển sang @Query (JPQL hoặc native) hoặc Specification.
Mid
Bulk update bằng @Modifying có những tác dụng phụ gì?
Nó đi thẳng xuống DB nên persistence context không biết, và bỏ qua @Version, cascade, lifecycle callback, audit.
Entity đã load vẫn giữ giá trị cũ (dùng clearAutomatically); thay đổi chưa flush có thể bị ghi đè (dùng flushAutomatically).
Vì sao @Transactional không hoạt động khi gọi method trong cùng class?
Vì transaction do proxy bọc bean áp dụng, còn this.method() gọi thẳng object thật, không qua proxy.
Sửa bằng cách tách method sang bean khác hoặc dùng TransactionTemplate.
Transaction có rollback khi ném checked exception không?
Mặc định không: Spring chỉ rollback với RuntimeException và Error.
Muốn rollback với checked exception thì khai báo rollbackFor. Nếu exception bị bắt và nuốt bên trong method thì proxy không thấy, transaction vẫn commit.
Optimistic và pessimistic locking khác nhau thế nào?
Optimistic không khoá, phát hiện xung đột lúc ghi bằng @Version; pessimistic khoá dòng ngay khi đọc bằng SELECT ... FOR UPDATE.
Optimistic sinh WHERE version = ?, xung đột thì exception và retry; hợp với xung đột hiếm và luồng kéo dài qua nhiều request. Pessimistic bắt transaction khác chờ; hợp với tài nguyên tranh chấp cao trong transaction ngắn.
Senior
Open-session-in-view là gì và vì sao nên tắt?
OSIV giữ EntityManager mở suốt request để lazy loading chạy được ở controller và lúc serialize; nên tắt vì nó giữ connection lâu và che N+1.
Dưới tải cao, pool cạn; tầng view truy cập DB ngoài transaction. Tắt bằng spring.jpa.open-in-view=false, rồi fetch đủ dữ liệu trong service và trả DTO.
Giải thích UnexpectedRollbackException.
Method con REQUIRED ném RuntimeException qua proxy nên transaction bị đánh dấu rollback-only; method ngoài nuốt lỗi và commit, Spring thấy dấu đó thì rollback và ném UnexpectedRollbackException.
Muốn phần bên trong thất bại độc lập thì dùng REQUIRES_NEW (chấp nhận thêm connection) hoặc tách thành xử lý bất đồng bộ.
REQUIRES_NEW có rủi ro gì dưới tải cao?
Deadlock connection pool: transaction ngoài bị tạm dừng nhưng vẫn giữ connection, transaction mới cần connection thứ hai.
Nếu mọi thread đều ở trạng thái đó, không ai lấy được connection thứ hai và hệ thống treo đến khi timeout. Giảm thiểu: hạn chế REQUIRES_NEW, đặt pool lớn hơn số thread có thể lồng transaction, hoặc thiết kế lại để không cần lồng.
Thiết kế chức năng “đặt chỗ có giới hạn” sao cho đúng khi đồng thời?
Tuỳ mức tranh chấp; đơn giản và nhanh nhất là conditional UPDATE set seats = seats - 1 where id = ? and seats > 0 rồi kiểm tra số dòng bị ảnh hưởng.
- Cần logic nghiệp vụ phức tạp trên entity:
@Version+ retry khi tranh chấp thấp,SELECT ... FOR UPDATEvới lock timeout khi tranh chấp cao. - Luôn có unique constraint ở DB để chặn đăng ký trùng.
- Flash sale cực lớn: chuyển bộ đếm sang Redis (
DECR) hoặc hàng đợi rồi ghi DB bất đồng bộ.
Từ vựng tiếng Anh
| Term | Phát âm | Nghĩa | Ví dụ câu dùng trong phỏng vấn |
|---|---|---|---|
| derived query | /dɪˈraɪvd ˈkwɪr.i/ | truy vấn sinh từ tên method | “Derived queries are great until the method name becomes a sentence.” |
| native query | /ˈneɪ.tɪv ˈkwɪr.i/ | câu SQL thuần | “I used a native query for the upsert because JPQL can’t express it.” |
| bulk update | /bʌlk ˈʌp.deɪt/ | cập nhật hàng loạt | “A bulk update bypasses the persistence context.” |
| bind parameter | /baɪnd pəˈræm.ɪ.tər/ | tham số ràng buộc | “Bind parameters prevent SQL injection.” |
| propagation | /ˌprɑː.pəˈɡeɪ.ʃən/ | cách lan truyền transaction | “The default propagation is REQUIRED.” |
| self-invocation | /self ˌɪn.vəˈkeɪ.ʃən/ | tự gọi trong cùng class | “Self-invocation skips the proxy, so the annotation is ignored.” |
| rollback-only | /ˈroʊl.bæk ˈoʊn.li/ | bị đánh dấu chỉ được rollback | “The inner call marked the transaction as rollback-only.” |
| optimistic locking | /ˌɑːp.təˈmɪs.tɪk ˈlɑː.kɪŋ/ | khoá lạc quan | “Optimistic locking detects conflicts with a version column.” |
| pessimistic locking | /ˌpes.əˈmɪs.tɪk ˈlɑː.kɪŋ/ | khoá bi quan | “Pessimistic locking issues SELECT FOR UPDATE.” |
| lost update | /lɔːst ˈʌp.deɪt/ | mất cập nhật do ghi đè | “Without a version check, two writers cause a lost update.” |
| contention | /kənˈten.ʃən/ | tranh chấp tài nguyên | “Under high contention, optimistic retries become expensive.” |
| connection pool exhaustion | /kəˈnek.ʃən puːl ɪɡˈzɔːs.tʃən/ | cạn connection pool | “Open session in view led to connection pool exhaustion under load.” |
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.