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

Tìm kiếm

Database & ORMJunior24 phút đọc

ORM và JPA: JDBC, Hibernate, entity và repository

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

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.
flowchart TB
  SD[Spring Data JPA<br/>JpaRepository, derived query] --> JPA[JPA spec<br/>EntityManager, annotations]
  JPA --> HB[Hibernate<br/>implementation]
  HB --> JDBC[JDBC + driver]

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.

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
    <groupId>com.mysql</groupId>
    <artifactId>mysql-connector-j</artifactId>
    <scope>runtime</scope>
</dependency>
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: 50
logging:
  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).

public interface CourseRepository extends JpaRepository<Course, Long> {

    List<Course> findByStatus(CourseStatus status);

    Optional<Course> findByTitleIgnoreCase(String title);

    Page<Course> findByTeacherId(Long teacherId, Pageable pageable);

    boolean existsByTitle(String title);
}
  • 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.

@Service
public 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.
src/main/resources/db/migration/
  V1__create_courses.sql
  V2__add_course_status.sql
-- V2__add_course_status.sql
ALTER 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ố.

@Entity
public 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:
@Entity
@Table(name = "teacher")
public class Teacher {
    @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(nullable = false, unique = true)
    private String username;

    @Column(nullable = false)
    private String password;            // hash, không phải mật khẩu gốc

    @Enumerated(EnumType.STRING)
    @Column(nullable = false, length = 50)
    private Status status = Status.ACTIVE;

    @CreationTimestamp
    @Column(name = "created_date", updatable = false)
    private Instant createdDate;

    @UpdateTimestamp
    @Column(name = "updated_date")
    private Instant updatedDate;

    protected Teacher() {}

    public Teacher(String username, String passwordHash) {
        this.username = username;
        this.password = passwordHash;
    }
}

Kiểm tra: đặt ddl-auto=validate và để Flyway tạo bảng; entity lệch schema thì app không khởi động, lỗi lộ ngay lúc dev thay vì lúc chạy.

Bài 2: Repository cho từng entity

Yêu cầu (diễn đạt lại): tạo một repository interface cho mỗi entity.

public interface TeacherRepository extends JpaRepository<Teacher, Long> {}
public interface UserRepository extends JpaRepository<User, Long> {
    Optional<User> findByUsername(String username);
    boolean existsByUsername(String username);
}
public interface UserCourseRepository extends JpaRepository<UserCourse, UserCourseId> {
    long countByCourseId(Long courseId);
}

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
@Service
public 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.

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.

  1. Migration thêm cột mới.
  2. Code ghi cả hai cột.
  3. Backfill dữ liệu cũ theo lô nhỏ để không khoá bảng lâu.
  4. Code đọc cột mới.
  5. Ngừng ghi cột cũ.
  6. 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.”
constructor injection /kənˈstrʌk.tər ɪnˈdʒek.ʃən/ tiêm phụ thuộc qua constructor “Constructor injection lets the fields be final.”

Tiếp theo: ORM và JPA bài 2: quan hệ entity 1-1, 1-n, n-n và mappedBy.


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.