Cả bài trong một trang: ý chính, sơ đồ, điểm phỏng vấn.
ORM và JPA: JDBC, Hibernate, entity và repository
1ORM giải quyết gì
ArrayList mất dữ liệu khi restart và không chia sẻ được giữa các instance. Database giải quyết, nhưng object và bảng không khớp nhau; ORM tự chuyển object ↔ dòng theo cả hai chiều.
Java
Relational
Identity ==, equals
primary key
course.getTeacher()
khoá ngoại + JOIN
Kế thừa
không có
2Các tầng bên dưới
JPA là đặc tả, không tự chạy; Hibernate là implementation mặc định; Spring Data JPA sinh repository từ interface.
Viết repository.save(entity) thì dễ, nhưng dùng đúng trên production cần hiểu các tầng bên dưới: JDBC, connection pool, JPA, Hibernate và Spring Data. Đọc xong, bạn định nghĩa được entity, repository, service, và tránh được ba nguồn sự cố thật: pool cạn, schema do ddl-auto quản lý, equals/hashCode sai. Chỉ cần Java và SQL cơ bản (xem cụm Database); quan hệ entity ở bài 2, JPQL, @Transactional và locking ở bài 5.
1. Đặt vấn đề: vì sao cần database
Ý chính: lưu dữ liệu trong ArrayList thì mất khi restart, bị giới hạn bởi RAM và không chia sẻ được giữa các instance. Database giải quyết cả ba, cộng thêm truy cập đồng thời an toàn và truy vấn linh hoạt.
Ví dụ app khách sạn (hoặc khoá học) giữ phòng, nhân viên, khách trong ArrayList:
Mất dữ liệu khi crash hoặc restart, vì RAM là bộ nhớ tạm.
Giới hạn dung lượng: RAM nhỏ và đắt hơn ổ đĩa nhiều.
Không mở rộng được: hai instance sau load balancer mỗi bên giữ một bản dữ liệu riêng, không đồng bộ.
Thiếu truy cập đồng thời an toàn (transaction, khoá) và truy vấn linh hoạt (lọc, join, tổng hợp).
flowchart LR
A[Spring Boot app] --> R[Repository / JPA]
R --> H[Hibernate]
H --> J[JDBC API]
J --> D[Database driver<br/>mysql-connector-j]
D -->|giao thức mạng của MySQL| DB[(MySQL)]
2. Thuật ngữ
Ý chính: driver nói chuyện với DB, JDBC là interface chuẩn trên driver, ORM chuyển object ↔ dòng, JPA là đặc tả của ORM trong Java, Hibernate là bản cài đặt của JPA.
2.1. Database driver và JDBC
Ý chính: driver lo giao thức mạng riêng của từng DB; JDBC là bộ interface chuẩn mà mọi driver hiện thực, nên code phía trên không phụ thuộc DB cụ thể.
Driver lo: giao thức, bảo mật (xác thực, TLS), xử lý lỗi (mã lỗi, mất kết nối), hiệu năng (prepared statement, nén, batch).
JDBC: Connection, PreparedStatement, ResultSet. Mỗi DB có driver riêng (mysql-connector-j, postgresql).
Connection pool (slide không nhắc nhưng production luôn có; Spring Boot mặc định dùng HikariCP): mở TCP + xác thực tốn vài ms đến vài chục ms, nên pool giữ sẵn kết nối để dùng lại. Pool quá nhỏ thì request chờ, quá lớn thì DB quá tải.
JDBC thuần: tự viết SQL, tự map ResultSet, tự quản lý kết nối, lặp lại hàng trăm lần. Đó là lý do ORM ra đời:
String sql = "SELECT id, title, price FROM courses WHERE teacher_id = ?";try (Connection conn = dataSource.getConnection(); PreparedStatement ps = conn.prepareStatement(sql)) { ps.setLong(1, teacherId); try (ResultSet rs = ps.executeQuery()) { List<Course> result = new ArrayList<>(); while (rs.next()) { result.add(new Course(rs.getLong("id"), rs.getString("title"), rs.getBigDecimal("price"))); } return result; }}
2.2. ORM
Ý chính:ORM (Object-Relational Mapping) tự động chuyển giữa object Java và dòng trong bảng, theo cả hai chiều. Nó tồn tại vì hai mô hình không khớp nhau (object-relational impedance mismatch).
Java
Relational
Object có identity (==) và equality (equals)
Dòng định danh bằng primary key
Tham chiếu course.getTeacher()
Khoá ngoại teacher_id + JOIN
Collection teacher.getCourses()
Không có, phải query ngược theo FK
Kế thừa
Không có khái niệm kế thừa
Duyệt đồ thị object tự do
Mỗi lần “đi” là một truy vấn
2.3. JPA và Hibernate
Ý chính: JPA là đặc tả (interface + annotation), không tự chạy. Hibernate là implementation mặc định trong Spring Boot. Spring Data JPA nằm trên cùng, sinh repository từ interface.
JPA (Java Persistence API, nay là Jakarta Persistence): EntityManager, @Entity, @OneToMany… mô tả cách ánh xạ và thao tác.
Hibernate: implementation phổ biến nhất. Các bản khác: EclipseLink, OpenJPA.
Spring Data JPA: sinh repository, sinh query từ tên method, phân trang.
Từ Spring Boot 3, package là jakarta.persistence.*; code cũ dùng javax.persistence.* không biên dịch được trên Boot 3+.
Chức năng chính của JPA/Hibernate:
ORM: ánh xạ entity với bảng.
JPQL: truy vấn trên entity, Hibernate dịch sang SQL của DB đang dùng (chi tiết ở bài 5 của cụm).
Tự tạo bảng (spring.jpa.hibernate.ddl-auto): tiện khi học, không dùng update/create ở production (xem mục 3.7).
Tối ưu hiệu năng: cache cấp 1 (persistence context — vùng nhớ Hibernate giữ các entity đã load trong một transaction), cache cấp 2, lazy loading, batch, dirty checking (tự phát hiện field đổi để sinh UPDATE).
Tích hợp Spring: transaction khai báo, repository, exception translation.
3. Thực hành cơ bản
Ý chính: cần hai dependency, một entity, một interface repository và một service có @Transactional. Dễ sai ở: chiến lược id, kích thước pool, quản lý schema, equals/hashCode.
3.1. Cài đặt
Ý chính: thêm starter Spring Data JPA và driver MySQL, khai báo datasource trong application.yml; Spring Boot tự suy ra driver class và (từ Hibernate 6) cả dialect.
spring: datasource: url: jdbc:mysql://localhost:3306/elearning username: app password: ${DB_PASSWORD} # lấy từ biến môi trường, không commit mật khẩu hikari: maximum-pool-size: 10 jpa: hibernate: ddl-auto: validate # dev có thể dùng update, prod thì validate + Flyway open-in-view: false # xem bài 5 của cụm properties: hibernate: jdbc.batch_size: 50 default_batch_fetch_size: 50logging: level: org.hibernate.SQL: debug # in câu SQL khi dev
driver-class-name thường không cần: Spring Boot suy ra từ URL.
3.2. Định nghĩa entity
Ý chính: entity là class có @Entity, @Id và constructor không tham số. Ba lựa chọn quan trọng nhất: chiến lược sinh id, enum lưu bằng STRING, và không dùng Lombok @Data.
import jakarta.persistence.*;@Entity@Table(name = "courses")public class Course { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Long id; @Column(nullable = false, length = 200) private String title; @Column(precision = 12, scale = 2) private BigDecimal price; @Enumerated(EnumType.STRING) private CourseStatus status; @Transient private int viewCountInMemory; // không lưu xuống DB protected Course() {} // JPA cần constructor không tham số public Course(String title, BigDecimal price) { this.title = title; this.price = price; this.status = CourseStatus.DRAFT; } // getter, method nghiệp vụ...}
Annotation / quy tắc
Ý nghĩa
@Entity
Class do JPA quản lý
@Id
Primary key, bắt buộc
@Table
Tên bảng; bỏ trống thì Spring Boot đổi CourseCategory thành course_category
@Transient
Field không lưu xuống DB
Constructor không tham số
Hibernate tạo object bằng reflection khi đọc DB. protected là đủ và tốt hơn public, vì ngăn code khác tạo object rỗng
Không final (class và method)
Hibernate tạo proxy (subclass) cho lazy loading
3.3. Định nghĩa repository
Ý chính: khai báo interface kế thừa JpaRepository<Entity, KiểuId>; Spring Data sinh implementation lúc khởi động và sinh query từ tên method (derived query).
Implementation là một proxy dựa trên SimpleJpaRepository, có sẵn save, findById, findAll, deleteById, phân trang, sắp xếp.
Derived query: Spring Data phân tích tên như findByStatus thành JPQL.
Slide bảo đánh dấu @Repository; với interface kế thừa JpaRepository thì không cần (Spring Data tự phát hiện, exception translation có sẵn). @Repository chỉ cần cho class DAO tự viết.
save() gọi persist khi entity được coi là mới (thường là id null), ngược lại gọi merge, tức copy toàn bộ state lên dòng DB. Bind form thẳng vào entity rồi save() là cột nào không có trên form thành null: xem bài form binding và validation.
3.4. Định nghĩa service
Ý chính: service chứa nghiệp vụ và ranh giới transaction (@Transactional), nhận dependency qua constructor.
@Servicepublic class CourseService { private final CourseRepository courseRepository; public CourseService(CourseRepository courseRepository) { // constructor injection this.courseRepository = courseRepository; } @Transactional public CourseResponse create(CreateCourseRequest req) { if (courseRepository.existsByTitle(req.title())) { throw new DuplicateCourseException(req.title()); } Course saved = courseRepository.save(new Course(req.title(), req.price())); return CourseResponse.from(saved); } @Transactional(readOnly = true) public CourseResponse get(long id) { return courseRepository.findById(id) .map(CourseResponse::from) .orElseThrow(() -> new CourseNotFoundException(id)); }}
Slide dùng @Autowired trên field; nên dùng constructor injection: field final được, không có trạng thái “chưa inject”, test không cần Spring, class quá nhiều dependency lộ ngay ở constructor. Có một constructor thì không cần @Autowired. Xem IoC và Dependency Injection.
3.5. Các tầng: Controller, DTO, Service, Repository, Entity
Ý chính: DTO đi giữa Client, Controller và Service; entity đi giữa Service, Repository và DB. Service là nơi duy nhất thấy cả hai, nên map entity sang DTO ở đây, khi transaction còn mở.
Thành phần
Việc của nó
Làm việc với
Controller
Nhận HTTP request, map endpoint (@GetMapping…), validate input, gọi service, trả response. Không chứa nghiệp vụ.
DTO
DTO (Data Transfer Object)
Chở dữ liệu giữa client và server, giữa controller và service. Chỉ chứa field use case cần, để không lộ field nhạy cảm của entity (mật khẩu, trạng thái nội bộ).
Controller, Service
Service
Nghiệp vụ, ranh giới transaction, gọi repository, chuyển entity ↔ DTO.
DTO ở trên, entity ở dưới
Repository
Truy vấn và thay đổi dữ liệu.
Entity
Entity
Class ánh xạ một bảng.
Repository, ORM
flowchart LR
C[Client] <-->|JSON = DTO| CT[Controller]
CT <-->|DTO| SV[Service]
SV <-->|Entity| RP[Repository]
RP <-->|"Entity ↔ SQL (Hibernate)"| DB[(Database)]
public record CourseResponse(Long id, String title, String teacherName) { static CourseResponse from(Course c) { return new CourseResponse(c.getId(), c.getTitle(), c.getTeacher().getName()); }}@Transactional(readOnly = true)public CourseResponse get(long id) { // trong CourseService return courseRepository.findById(id) .map(CourseResponse::from) // chạm quan hệ LAZY lúc session còn mở .orElseThrow(() -> new CourseNotFoundException(id));}
Vì sao không trả thẳng entity (lộ password, vòng lặp JSON với quan hệ hai chiều, lỗi proxy LAZY) có ví dụ chạy thật ở bài 3 của cụm. Cấu trúc package của một dự án hoàn chỉnh ở Thiết kế REST API với Spring Boot (mục 4.1).
3.6. Connection pool: cấu hình HikariCP
Ý chính: Spring giữ connection suốt cả transaction, không chỉ lúc chạy SQL. Vì vậy transaction ngắn quan trọng hơn pool lớn, và pool lớn không làm DB nhanh hơn.
Spring lấy connection khi transaction bắt đầu (hoặc khi repository query ngoài transaction), trả lại khi transaction kết thúc.
DB chỉ chạy song song thật cỡ số core CPU (cộng thời gian chờ đĩa); vượt quá thì các connection chỉ tranh CPU, lock, bộ nhớ.
Kích thước pool là cho toàn hệ thống, phải chia cho số instance ứng dụng.
Bảng tham số HikariCP, công thức chọn kích thước và metric cần xem
Tham số (spring.datasource.hikari.*)
Mặc định
Ý nghĩa
maximum-pool-size
10
Số connection tối đa, gồm cả connection đang rảnh
minimum-idle
bằng maximum-pool-size
HikariCP khuyên để mặc định: pool kích thước cố định
connection-timeout
30000 ms
Chờ lấy connection quá lâu thì ném SQLTransientConnectionException
max-lifetime
1800000 ms (30 phút)
Đóng và thay connection cũ; nên ngắn hơn timeout phía DB hoặc proxy/firewall vài phút
Công thức khởi điểm của HikariCP: connections = core_count * 2 + effective_spindle_count. DB 8 core chạy SSD thì khoảng 16-20 connection cho toàn hệ thống. 10 pod, mỗi pod pool 20 là 200 connection tới cùng một DB, vượt max_connections mặc định của MySQL (151).
Trước khi tăng pool, xem metric hikaricp.connections.pending và hikaricp.connections.acquire (Micrometer qua Actuator) để biết request có thực sự đang chờ connection không.
3.7. Quản lý schema: Flyway thay vì ddl-auto
Ý chính: production dùng migration có version (Flyway/Liquibase): mỗi thay đổi schema là một file SQL đánh số, review như code, chạy đúng một lần mỗi môi trường. Hibernate chỉ đặt ddl-auto=validate.
ddl-auto có các giá trị none, validate, update, create, create-drop. Spring Boot mặc định create-drop với DB nhúng (H2) khi không có Flyway/Liquibase, và none với DB thật.
Flyway ghi lịch sử vào bảng flyway_schema_history, kèm checksum (mã kiểm tra nội dung) của từng file.
Thêm org.flywaydb:flyway-core (MySQL thêm flyway-mysql); Spring Boot chạy migration lúc khởi động, trước khi Hibernate validate.
-- V2__add_course_status.sqlALTER TABLE courses ADD COLUMN status VARCHAR(20) NOT NULL DEFAULT 'DRAFT';CREATE INDEX idx_courses_status ON courses (status);
3.8. equals và hashCode cho entity
Ý chính: entity hay nằm trong Set, nên equals/hashCode phải đúng ở mọi trạng thái: trước persist (id null), sau persist, và khi là proxy. Có natural key bất biến thì dùng nó; chỉ có id tự sinh thì equals theo id, hashCode hằng số.
@Entitypublic class Course { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Long id; // ... public Long getId() { return id; } @Override public boolean equals(Object o) { if (this == o) return true; if (!(o instanceof Course other)) return false; // proxy là subclass nên instanceof vẫn đúng return id != null && id.equals(other.getId()); // đọc qua getter, không đọc other.id } @Override public int hashCode() { return Course.class.hashCode(); // hằng số: không đổi trước và sau persist, giống nhau cho proxy }}
Hai entity transient (id null) chỉ bằng nhau khi là cùng một object.
Natural key bất biến (ISBN, mã khoá học do nghiệp vụ cấp, email không cho đổi) tốt hơn cách trên, dùng cho cả equals và hashCode.
Vì sao hashCode hằng số chấp nhận được, và bẫy proxy trong equals
hashCode hằng số nên object không “lạc” bucket khi id được gán sau persist. Đổi lại mọi entity cùng class rơi vào cùng bucket, HashSet lớn thành tìm tuyến tính; chấp nhận được vì collection entity trong bộ nhớ thường nhỏ. Dùng Course.class.hashCode() thay vì getClass().hashCode(), vì class của proxy khác class entity.
Bài tập
Các bài tập của ba buổi ORM đều xây trên pet project E-Learning (một bản khoá học khác dùng đề quản lý khách sạn với Hotel, Room, Employee; cách làm giống hệt). Đề đầy đủ ở bài Pet project thực hành.
Bài 1: Tạo entity cho các bảng
Yêu cầu (diễn đạt lại): với mỗi bảng trong thiết kế database của pet project, tạo một entity tương ứng.
Lời giải Bài 1: danh sách entity và entity Teacher
Theo schema E-Learning của khoá (dựng lại đầy đủ ở bài 3 của cụm), tạo User, FullName, Admin, Teacher, Course, Chapter, Lesson, UserCourse, UserCourseLesson, Address.
Mỗi entity có @Id + @GeneratedValue (riêng UserCourse dùng khoá ghép @EmbeddedId) và constructor protected không tham số.
Cột trạng thái và loại bài học là enum lưu bằng EnumType.STRING.
Tránh tên cột order vì đụng từ khoá SQL.
Buổi này chưa cần khai báo quan hệ (đó là Bài 4). Ví dụ Teacher, bảng không có khoá ngoại:
Không phải entity nào cũng cần repository riêng: entity con chỉ sống trong aggregate (như FullName cascade từ User) thao tác qua entity cha. Đây là tư tưởng aggregate root của DDD.
Bài 3: Thay dữ liệu giả trong API bằng dữ liệu thật (CRUD)
Yêu cầu (diễn đạt lại): các endpoint đã định nghĩa ở bài REST (đang trả lại input) giờ phải đọc ghi database thật. Bản khoá học thứ hai yêu cầu tương tự: CRUD đầy đủ cho từng thực thể chính (khách sạn, phòng, nhân viên…).
Lời giải Bài 3: CourseService với CRUD
@Servicepublic class CourseService { private final CourseRepository courseRepository; private final TeacherRepository teacherRepository; public CourseService(CourseRepository courseRepository, TeacherRepository teacherRepository) { this.courseRepository = courseRepository; this.teacherRepository = teacherRepository; } @Transactional public CourseResponse create(CourseRequest req) { // getReferenceById trả về proxy, không SELECT teacher; chỉ cần id để ghi FK. // Nếu teacher không tồn tại, FK constraint sẽ báo lỗi khi INSERT. Teacher teacher = teacherRepository.getReferenceById(req.teacherId()); Course course = new Course(req.name(), req.description()); teacher.addCourse(course); return CourseResponse.from(courseRepository.save(course)); } @Transactional(readOnly = true) public Page<CourseResponse> search(Pageable pageable) { return courseRepository.findAll(pageable).map(CourseResponse::from); } @Transactional public CourseResponse update(long id, CourseRequest req) { Course course = courseRepository.findById(id) .orElseThrow(() -> new CourseNotFoundException(id)); course.update(req.name(), req.description()); // dirty checking lo UPDATE return CourseResponse.from(course); } @Transactional public void delete(long id) { if (!courseRepository.existsById(id)) throw new CourseNotFoundException(id); courseRepository.deleteById(id); }}
Điểm đáng chú ý:
update không gọi save (dirty checking).
create dùng getReferenceById để khỏi tốn một SELECT.
search có phân trang ngay từ đầu.
Lỗi không tìm thấy được ném ra để @RestControllerAdvice chuyển thành 404.
CourseResponse.from đọc course.getTeacher().getName() trong search sẽ gây N+1, nên bật default_batch_fetch_size hoặc dùng projection (xem bài 4 của cụm).
Ghi nhớ
Giải thích được JPA, Hibernate và Spring Data JPA mỗi cái đứng ở tầng nào.
Biết vì sao IDENTITY làm mất batch insert và khi nào chọn SEQUENCE hay UUID v7.
Giải thích được vì sao pool lớn không làm DB nhanh hơn, và vì sao gọi HTTP trong @Transactional làm cạn pool.
Biết vì sao production dùng Flyway + validate, và chuyện gì xảy ra khi sửa migration đã chạy.
Viết được equals/hashCode an toàn cho entity chỉ có id tự sinh.
Câu hỏi phỏng vấn
Junior
JPA và Hibernate khác nhau thế nào?
JPA là đặc tả, Hibernate là một implementation của đặc tả đó.
JPA (Jakarta Persistence) là bộ interface và annotation định nghĩa cách ánh xạ object với bảng. Hibernate cài đặt nó và có thêm tính năng riêng. Code viết theo API JPA có thể đổi sang implementation khác như EclipseLink. Spring Data JPA là lớp trên cùng, sinh repository.
Vì sao entity cần constructor không tham số?
Vì Hibernate tạo object bằng reflection khi đọc từ DB rồi mới gán field.
Constructor có thể là protected để code bên ngoài không tạo được object rỗng. Hibernate cũng tạo proxy (subclass) cho lazy loading, nên class không được final.
Vì sao không nên dùng ddl-auto=update ở production?
Vì nó không xoá hay đổi tên cột, không migrate dữ liệu, không có lịch sử và không review được.
Đổi tên field chỉ thêm cột mới, dữ liệu nằm lại ở cột cũ; schema các môi trường có thể lệch nhau. Production dùng migration có version (Flyway, Liquibase) chạy lúc deploy, còn Hibernate đặt ddl-auto=validate để chỉ kiểm tra entity khớp schema.
Mid
Derived query là gì? Khi nào nên chuyển sang @Query?
Derived query là query Spring Data sinh từ tên method; chuyển sang @Query khi tên quá dài hoặc cần thứ tên method không diễn đạt được.
Spring Data phân tích tên như findByStatusAndTeacherId thành JPQL lúc khởi động (sai tên field là app không khởi động, nên lỗi lộ sớm). Hợp với một hai điều kiện. Chuyển sang @Query khi cần join hoặc fetch join, DTO projection, bulk update/delete, hoặc tính năng riêng của DB (native query). Điều kiện lọc động thì dùng Specification hoặc Querydsl.
findById và getReferenceById khác nhau thế nào?
findById SELECT ngay và trả Optional; getReferenceById trả proxy chỉ có id, không query.
findById (hoặc lấy từ persistence context) cho biết chắc dòng tồn tại. getReferenceById dùng khi chỉ cần gán khoá ngoại để tiết kiệm một SELECT. Nếu id không tồn tại, lỗi chỉ xuất hiện khi chạm field của proxy (EntityNotFoundException) hoặc khi INSERT vi phạm FK.
Connection pool là gì? Pool 10 connection phục vụ được bao nhiêu request?
Pool giữ sẵn connection đã mở để dùng lại; số request phục vụ được phụ thuộc thời gian mỗi transaction giữ connection, không chỉ con số 10.
Pool tránh chi phí mở TCP + đăng nhập cho mỗi request. Tối đa 10 transaction giữ connection cùng lúc; request khác chờ tới connection-timeout. Theo định luật Little, mỗi transaction giữ 20 ms thì 10 connection phục vụ khoảng 500 transaction/giây. Vì vậy giữ transaction ngắn quan trọng hơn tăng pool, và pool lớn quá làm DB quá tải.
Hibernate, JdbcTemplate và MyBatis khác nhau thế nào? Khi nào chọn cái nào?
Hibernate/JPA là ORM: bạn làm việc với entity, framework sinh SQL, theo dõi thay đổi và quản lý quan hệ. JdbcTemplate và MyBatis là SQL mapper: bạn tự viết SQL, framework chỉ bind tham số và map kết quả sang object.
Hibernate / JPA
MyBatis
JdbcTemplate
Ai viết SQL
framework (JPQL, derived query)
bạn, trong XML hoặc annotation
bạn, trong code Java
Dirty checking, cascade, lazy loading
có
không
không
Rủi ro chính
SQL ngầm: N+1, flush bất ngờ
SQL dài, phải tự bảo trì
nhiều code lặp
Hợp với
CRUD, domain model nhiều quy tắc
truy vấn phức tạp, báo cáo, schema có sẵn
vài câu đơn giản, batch
Trong một dự án Spring Boot mình thường dùng JPA cho phần ghi theo aggregate. Truy vấn đọc phức tạp (báo cáo, window function) đi bằng native query, JdbcTemplate hoặc jOOQ. Cả ba đều chống SQL injection như nhau nếu dùng bind parameter; khác nhau ở chỗ bạn nhìn thấy SQL rõ đến đâu.
Senior
Vì sao GenerationType.IDENTITY làm mất batch insert? Bạn chọn chiến lược id nào?
Vì id chỉ có sau khi INSERT chạy, mà Hibernate cần id ngay lúc persist, nên phải INSERT từng câu.
Hibernate cần id để đưa entity vào persistence context. SEQUENCE với pooled optimizer lấy trước một khối id nên batch được; đó là lựa chọn tốt nhất trên PostgreSQL/Oracle. Trên MySQL thường vẫn dùng IDENTITY và chấp nhận, hoặc sinh id ở ứng dụng có thứ tự thời gian (UUID v7, Snowflake) để không phân mảnh index, kèm Persistable để save không SELECT thừa.
Bạn cài đặt equals/hashCode cho entity JPA thế nào?
Ưu tiên natural key bất biến; nếu chỉ có id tự sinh thì equals theo id khác null, hashCode hằng số theo class.
equals trả true khi cùng object, hoặc khi id khác null và bằng id của object kia. Đọc qua getter vì proxy có field rỗng, kiểm tra kiểu bằng instanceof vì proxy là subclass. hashCode hằng số để không đổi khi id được gán sau persist. Không dùng Lombok @Data/@EqualsAndHashCode mặc định vì nó dùng mọi field, kể cả quan hệ lazy.
Đổi tên một cột trên bảng lớn mà không downtime thế nào?
Dùng expand/contract qua nhiều release, vì khi rolling deploy hai phiên bản code chạy cùng lúc nên schema phải hợp với cả hai.
Migration thêm cột mới.
Code ghi cả hai cột.
Backfill dữ liệu cũ theo lô nhỏ để không khoá bảng lâu.
Code đọc cột mới.
Ngừng ghi cột cũ.
Migration xoá cột cũ ở release sau.
Với MySQL, kiểm tra ALTER TABLE có chạy online (ALGORITHM=INSTANT/INPLACE) không, hoặc dùng gh-ost/pt-online-schema-change cho bảng rất lớn.
Từ vựng tiếng Anh
Term
Phát âm
Nghĩa
Ví dụ câu dùng trong phỏng vấn
entity
/ˈen.tə.ti/
thực thể
“Each entity maps to one table.”
impedance mismatch
/ɪmˈpiː.dəns ˈmɪs.mætʃ/
độ vênh giữa hai mô hình
“ORM exists because of the object-relational impedance mismatch.”
database driver
/ˈdeɪ.tə.beɪs ˈdraɪ.vər/
thư viện nói chuyện với DB
“The driver implements JDBC and speaks the MySQL wire protocol.”
specification
/ˌspes.ə.fəˈkeɪ.ʃən/
đặc tả
“JPA is a specification; Hibernate is one implementation of it.”
connection pool
/kəˈnek.ʃən puːl/
nhóm kết nối dùng lại
“HikariCP keeps a pool of ready connections.”
pool exhaustion
/puːl ɪɡˈzɔːs.tʃən/
cạn connection trong pool
“Slow HTTP calls inside transactions caused pool exhaustion.”
derived query
/dɪˈraɪvd ˈkwɪr.i/
query sinh từ tên method
“Derived queries are fine until the method name gets too long.”
schema migration
/ˈskiː.mə maɪˈɡreɪ.ʃən/
thay đổi schema có version
“Every schema change ships as a versioned Flyway migration.”
proxy
/ˈprɑːk.si/
object đại diện do Hibernate sinh
“getReferenceById returns a proxy without hitting the database.”
natural key
/ˈnætʃ.ər.əl kiː/
khoá tự nhiên từ nghiệp vụ
“If there’s an immutable natural key, I base equals and hashCode on it.”