Giới thiệu và kiến trúc Hibernate

01-gioi-thieu-kien-truc/
  docker-compose.yml           MySQL 8.4, database shop, user app (cổng 3307)
  pom.xml
  src/main/java/dev/canhdominich/hibernate/intro/
    DbConfig.java              đọc URL, user, mật khẩu từ biến môi trường
    Student.java               entity chính, khóa IDENTITY, enum lưu dạng chuỗi
    Ticket.java                entity dùng khóa SEQUENCE (allocationSize 50)
    Note.java                  entity có @DynamicUpdate
    SqlRecorder.java           StatementInspector ghi lại mọi câu SQL
    Factories.java             dựng SessionFactory bằng mã, create-drop, bật thống kê
    PersistenceContextDemo.java  thí nghiệm về Session, persistence context, trạng thái entity
    IdStrategiesDemo.java      IDENTITY, SEQUENCE và @DynamicUpdate

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>dev.canhdominich.javabackend</groupId>
    <artifactId>hibernate-gioi-thieu</artifactId>
    <version>1.0.0</version>
    <name>Hibernate - Gioi thieu va kien truc</name>

    <properties>
        <maven.compiler.release>17</maven.compiler.release>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <main.class>dev.canhdominich.hibernate.intro.PersistenceContextDemo</main.class>
        <main.arg>none</main.arg>
        <jvm.heap>-Xmx512m</jvm.heap>
        <mysql.connector.version>26.7.0</mysql.connector.version>
        <hibernate.version>7.4.13.Final</hibernate.version>
        <junit.version>6.0.3</junit.version>
        <testcontainers.version>2.0.5</testcontainers.version>
        <assertj.version>3.27.7</assertj.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>com.mysql</groupId>
            <artifactId>mysql-connector-j</artifactId>
            <version>${mysql.connector.version}</version>
        </dependency>
        <dependency>
            <groupId>org.hibernate.orm</groupId>
            <artifactId>hibernate-core</artifactId>
            <version>${hibernate.version}</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-simple</artifactId>
            <version>2.0.17</version>
        </dependency>
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter</artifactId>
            <version>${junit.version}</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.testcontainers</groupId>
            <artifactId>testcontainers-junit-jupiter</artifactId>
            <version>${testcontainers.version}</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.testcontainers</groupId>
            <artifactId>testcontainers-mysql</artifactId>
            <version>${testcontainers.version}</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.assertj</groupId>
            <artifactId>assertj-core</artifactId>
            <version>${assertj.version}</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-surefire-plugin</artifactId>
                <version>3.5.6</version>
            </plugin>
            <plugin>
                <groupId>org.codehaus.mojo</groupId>
                <artifactId>exec-maven-plugin</artifactId>
                <version>3.6.3</version>
                <configuration>
                    <executable>java</executable>
                    <arguments>
                        <argument>${jvm.heap}</argument>
                        <argument>-classpath</argument>
                        <classpath/>
                        <argument>${main.class}</argument>
                        <argument>${main.arg}</argument>
                    </arguments>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

services:
  mysql:
    image: mysql:8.4
    container_name: jdbc-lab-mysql
    environment:
      MYSQL_ROOT_PASSWORD: root_pw
      MYSQL_DATABASE: shop
      MYSQL_USER: app
      MYSQL_PASSWORD: app_pw
    ports:
      - "${MYSQL_PORT:-3307}:3306"
    healthcheck:
      test: ["CMD", "mysqladmin", "ping", "-h", "127.0.0.1", "-uroot", "-proot_pw"]
      interval: 3s
      timeout: 3s
      retries: 30

docker compose up -d
docker compose ps

package dev.canhdominich.hibernate.intro;

public record DbConfig(String url, String user, String password) {

    public static DbConfig fromEnvironment() {
        return new DbConfig(
                env("JDBC_URL", "jdbc:mysql://localhost:3307/shop"),
                env("DB_USER", "app"),
                env("DB_PASSWORD", "app_pw"));
    }

    public DbConfig withUrl(String newUrl) {
        return new DbConfig(newUrl, user, password);
    }

    public DbConfig withPassword(String newPassword) {
        return new DbConfig(url, user, newPassword);
    }

    private static String env(String name, String fallback) {
        String value = System.getenv(name);
        return value == null || value.isBlank() ? fallback : value;
    }
}

package dev.canhdominich.hibernate.intro;

import jakarta.persistence.Column;
import jakarta.persistence.Entity;
import jakarta.persistence.EnumType;
import jakarta.persistence.Enumerated;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;
import jakarta.persistence.Table;

@Entity
@Table(name = "student")
public class Student {

    public enum Level {
        BASIC, ADVANCED
    }

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(name = "full_name", nullable = false, length = 100)
    private String fullName;

    @Column(nullable = false, length = 100)
    private String email;

    @Enumerated(EnumType.STRING)
    @Column(nullable = false, length = 20)
    private Level level = Level.BASIC;

    protected Student() {
    }

    public Student(String fullName, String email) {
        this.fullName = fullName;
        this.email = email;
    }

    public Long getId() {
        return id;
    }

    public String getFullName() {
        return fullName;
    }

    public void setFullName(String fullName) {
        this.fullName = fullName;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public Level getLevel() {
        return level;
    }

    public void setLevel(Level level) {
        this.level = level;
    }

    @Override
    public String toString() {
        return "Student[" + id + ", " + fullName + ", " + level + "]";
    }
}

package dev.canhdominich.hibernate.intro;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import org.hibernate.resource.jdbc.spi.StatementInspector;

public class SqlRecorder implements StatementInspector {

    private static final List<String> STATEMENTS = Collections.synchronizedList(new ArrayList<>());

    @Override
    public String inspect(String sql) {
        STATEMENTS.add(sql.replaceAll("\\s+", " ").trim());
        return sql;
    }

    public static void clear() {
        STATEMENTS.clear();
    }

    public static List<String> statements() {
        synchronized (STATEMENTS) {
            return new ArrayList<>(STATEMENTS);
        }
    }

    public static void print(String title) {
        System.out.println(title);
        List<String> list = statements();
        if (list.isEmpty()) {
            System.out.println("  (no SQL)");
        }
        list.forEach(sql -> System.out.println("  " + sql));
        clear();
    }
}

package dev.canhdominich.hibernate.intro;

import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

public final class Factories {

    private Factories() {
    }

    public static SessionFactory build(DbConfig config, Class<?>... entities) {
        Configuration configuration = new Configuration()
                .setProperty("hibernate.connection.url", config.url())
                .setProperty("hibernate.connection.username", config.user())
                .setProperty("hibernate.connection.password", config.password())
                .setProperty("hibernate.hbm2ddl.auto", "create-drop")
                .setProperty("hibernate.generate_statistics", "true")
                .setProperty("hibernate.session_factory.statement_inspector", SqlRecorder.class.getName());
        for (Class<?> entity : entities) {
            configuration.addAnnotatedClass(entity);
        }
        return configuration.buildSessionFactory();
    }

    public static SessionFactory student(DbConfig config) {
        return build(config, Student.class);
    }
}

package dev.canhdominich.hibernate.intro;

import org.hibernate.Hibernate;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;

public final class PersistenceContextDemo {

    private PersistenceContextDemo() {
    }

    public static void main(String[] args) {
        long start = System.nanoTime();
        try (SessionFactory factory = Factories.student(DbConfig.fromEnvironment())) {
            long factoryMs = (System.nanoTime() - start) / 1_000_000;
            start = System.nanoTime();
            try (Session session = factory.openSession()) {
                System.out.println("-- building the SessionFactory took more than 20 times longer than opening a Session: " + (factoryMs > 20 * ((System.nanoTime() - start) / 1_000_000 + 1)));
            }

            long id = persistAndCommit(factory);
            firstLevelCache(factory, id);
            dirtyChecking(factory, id);
            entityStates(factory, id);
            autoFlushBeforeQuery(factory, id);
            proxies(factory, id);
        }
    }

    static long persistAndCommit(SessionFactory factory) {
        try (Session session = factory.openSession()) {
            Transaction tx = session.beginTransaction();
            Student student = new Student("Nguyễn Văn An", "an@example.com");
            System.out.println("-- persist: state before = transient, id = " + student.getId());
            session.persist(student);
            SqlRecorder.print("-- SQL right after persist(), before commit (IDENTITY must know the id)");
            System.out.println("-- state after persist: managed = " + session.contains(student) + ", id = " + student.getId());
            tx.commit();
            SqlRecorder.print("-- SQL at commit");
            return student.getId();
        }
    }

    static void firstLevelCache(SessionFactory factory, long id) {
        try (Session session = factory.openSession()) {
            Student first = session.find(Student.class, id);
            Student second = session.find(Student.class, id);
            System.out.println("-- two find() calls in one Session: same object = " + (first == second));
            SqlRecorder.print("-- SQL for two find() calls");
            session.clear();
            session.find(Student.class, id);
            SqlRecorder.print("-- SQL for a find() after clear()");
        }
    }

    static void dirtyChecking(SessionFactory factory, long id) {
        try (Session session = factory.openSession()) {
            Transaction tx = session.beginTransaction();
            Student student = session.find(Student.class, id);
            SqlRecorder.clear();
            student.setFullName("Nguyễn Văn An (đã sửa)");
            SqlRecorder.print("-- SQL after setFullName(), before commit");
            tx.commit();
            SqlRecorder.print("-- SQL at commit (no update() call was made)");
        }
        try (Session session = factory.openSession()) {
            Transaction tx = session.beginTransaction();
            Student student = session.find(Student.class, id);
            SqlRecorder.clear();
            student.setFullName(student.getFullName());
            tx.commit();
            SqlRecorder.print("-- SQL when the value is set to what it already was");
        }
    }

    static void entityStates(SessionFactory factory, long id) {
        Student detached;
        try (Session session = factory.openSession()) {
            detached = session.find(Student.class, id);
        }
        System.out.println("-- after the Session closed: still usable as an object = " + detached.getFullName());
        detached.setEmail("changed-while-detached@example.com");
        SqlRecorder.clear();
        try (Session session = factory.openSession()) {
            Transaction tx = session.beginTransaction();
            Student merged = session.merge(detached);
            System.out.println("-- merge() returns a different object: " + (merged != detached) + ", the argument is managed: " + session.contains(detached) + ", the result is managed: " + session.contains(merged));
            tx.commit();
            SqlRecorder.print("-- SQL for merge() of a detached object");
        }
    }

    static void autoFlushBeforeQuery(SessionFactory factory, long id) {
        try (Session session = factory.openSession()) {
            Transaction tx = session.beginTransaction();
            Student student = session.find(Student.class, id);
            SqlRecorder.clear();
            student.setLevel(Student.Level.ADVANCED);
            Long advanced = session.createQuery("select count(s) from Student s where s.level = :level", Long.class).setParameter("level", Student.Level.ADVANCED).getSingleResult();
            System.out.println("-- a query after an in-memory change counts the change: " + advanced);
            SqlRecorder.print("-- SQL: the pending UPDATE is flushed before the query");
            tx.rollback();
        }
    }

    static void proxies(SessionFactory factory, long id) {
        try (Session session = factory.openSession()) {
            SqlRecorder.clear();
            Student reference = session.getReference(Student.class, id);
            System.out.println("-- getReference(): initialized = " + Hibernate.isInitialized(reference) + ", class = " + reference.getClass().getSimpleName().replaceAll("\\$.*", "") + " subclass");
            SqlRecorder.print("-- SQL after getReference()");
            System.out.println("-- reading the id does not load it, reading a field does: id = " + reference.getId());
            SqlRecorder.print("-- SQL after getId()");
            System.out.println("-- name = " + reference.getFullName());
            SqlRecorder.print("-- SQL after getFullName()");
        }
        Student orphan;
        try (Session session = factory.openSession()) {
            orphan = session.getReference(Student.class, id);
        }
        try {
            orphan.getFullName();
        } catch (RuntimeException e) {
            System.out.println("-- proxy used after its Session closed: " + e.getClass().getSimpleName());
        }
    }
}

-- persist: state before = transient, id = null
-- SQL right after persist(), before commit (IDENTITY must know the id)
  insert into student (email,full_name,level) values (?,?,?)
-- state after persist: managed = true, id = 1
-- SQL at commit
  (no SQL)

-- two find() calls in one Session: same object = true
-- SQL for two find() calls
  select s1_0.id,s1_0.email,s1_0.full_name,s1_0.level from student s1_0 where s1_0.id=?
-- SQL for a find() after clear()
  select s1_0.id,s1_0.email,s1_0.full_name,s1_0.level from student s1_0 where s1_0.id=?

-- SQL after setFullName(), before commit
  (no SQL)
-- SQL at commit (no update() call was made)
  update student set email=?,full_name=?,level=? where id=?
-- SQL when the value is set to what it already was
  (no SQL)

-- after the Session closed: still usable as an object = Nguyễn Văn An (đã sửa)
-- merge() returns a different object: true, the argument is managed: false, the result is managed: true
-- SQL for merge() of a detached object
  select s1_0.id,s1_0.email,s1_0.full_name,s1_0.level from student s1_0 where s1_0.id=?
  update student set email=?,full_name=?,level=? where id=?

-- a query after an in-memory change counts the change: 1
-- SQL: the pending UPDATE is flushed before the query
  update student set email=?,full_name=?,level=? where id=?
  select count(s1_0.id) from student s1_0 where s1_0.level=?

-- getReference(): initialized = false, class = Student subclass
-- SQL after getReference()
  (no SQL)
-- reading the id does not load it, reading a field does: id = 1
-- SQL after getId()
  (no SQL)
-- name = Nguyễn Văn An (đã sửa)
-- SQL after getFullName()
  select s1_0.id,s1_0.email,s1_0.full_name,s1_0.level from student s1_0 where s1_0.id=?
-- proxy used after its Session closed: LazyInitializationException

package dev.canhdominich.hibernate.intro;

import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;
import jakarta.persistence.SequenceGenerator;

@Entity
public class Ticket {

    @Id
    @GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "ticket_seq")
    @SequenceGenerator(name = "ticket_seq", sequenceName = "ticket_seq", allocationSize = 50)
    private Long id;

    private String subject;

    protected Ticket() {
    }

    public Ticket(String subject) {
        this.subject = subject;
    }

    public Long getId() {
        return id;
    }
}

package dev.canhdominich.hibernate.intro;

import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;
import org.hibernate.annotations.DynamicUpdate;

@Entity
@DynamicUpdate
public class Note {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String title;

    private String body;

    protected Note() {
    }

    public Note(String title, String body) {
        this.title = title;
        this.body = body;
    }

    public Long getId() {
        return id;
    }

    public void setTitle(String title) {
        this.title = title;
    }
}

package dev.canhdominich.hibernate.intro;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;

public final class IdStrategiesDemo {

    private IdStrategiesDemo() {
    }

    public static void main(String[] args) {
        try (SessionFactory factory = Factories.build(DbConfig.fromEnvironment(), Student.class, Ticket.class, Note.class)) {
            SqlRecorder.clear();
            try (Session session = factory.openSession()) {
                Transaction tx = session.beginTransaction();
                for (int i = 1; i <= 3; i++) {
                    session.persist(new Student("Student " + i, "s" + i + "@example.com"));
                }
                SqlRecorder.print("-- IDENTITY: three persist() calls, nothing committed yet");
                tx.commit();
            }
            try (Session session = factory.openSession()) {
                Transaction tx = session.beginTransaction();
                long before = factory.getStatistics().getPrepareStatementCount();
                for (int i = 1; i <= 3; i++) {
                    session.persist(new Ticket("Ticket " + i));
                }
                SqlRecorder.print("-- SEQUENCE (allocationSize 50): three persist() calls, nothing committed yet");
                System.out.println("-- JDBC statements prepared during those three persist() calls: " + (factory.getStatistics().getPrepareStatementCount() - before) + " (reading the id generator)");
                System.out.println("-- MySQL has no sequences, Hibernate keeps the counter in a table: " + session.createNativeQuery("select table_name from information_schema.tables where table_schema = database() and table_name = 'ticket_seq'", String.class).getResultList());
                SqlRecorder.clear();
                tx.commit();
                SqlRecorder.print("-- SEQUENCE: SQL at commit");
            }
            try (Session session = factory.openSession()) {
                Transaction tx = session.beginTransaction();
                Note note = new Note("first title", "a long body that did not change");
                session.persist(note);
                tx.commit();
                SqlRecorder.clear();
                tx = session.beginTransaction();
                session.find(Note.class, note.getId()).setTitle("second title");
                tx.commit();
                SqlRecorder.print("-- @DynamicUpdate: only the changed column is in the UPDATE");
            }
        }
    }
}

-- IDENTITY: three persist() calls, nothing committed yet
  insert into student (email,full_name,level) values (?,?,?)
  insert into student (email,full_name,level) values (?,?,?)
  insert into student (email,full_name,level) values (?,?,?)
-- SEQUENCE (allocationSize 50): three persist() calls, nothing committed yet
  (no SQL)
-- JDBC statements prepared during those three persist() calls: 4 (reading the id generator)
-- MySQL has no sequences, Hibernate keeps the counter in a table: [ticket_seq]
-- SEQUENCE: SQL at commit
  insert into Ticket (subject,id) values (?,?)
  insert into Ticket (subject,id) values (?,?)
  insert into Ticket (subject,id) values (?,?)
-- @DynamicUpdate: only the changed column is in the UPDATE
  update Note set title=? where id=?