Cấu hình và CRUD với Hibernate

02-cau-hinh-va-crud/
  docker-compose.yml           MySQL 8.4, database shop, user app (cổng 3307)
  pom.xml
  src/main/resources/
    hibernate.cfg.xml          cấu hình dạng XML
    META-INF/persistence.xml   cấu hình theo chuẩn JPA
    lab/hibernate-lab.properties  cấu hình dạng tệp thuộc tính
  src/main/java/dev/canhdominich/hibernate/crud/
    DbConfig.java              đọc URL, user, mật khẩu từ biến môi trường
    Student.java               entity có cột email duy nhất
    SqlRecorder.java           StatementInspector ghi lại mọi câu SQL
    Configurations.java        bốn cách dựng SessionFactory và hai bộ quản lý kết nối
    UnitOfWork.java            chạy công việc trong một Session và một giao dịch
    ConfigurationDemo.java     so sánh dialect và bộ quản lý kết nối của các cách cấu hình
    SchemaDemo.java            các chế độ hbm2ddl.auto trên bảng thật
    CrudDemo.java              tạo, đọc, sửa, xóa, HQL hàng loạt, dòng không tồn tại
    TransactionPitfallsDemo.java  entity detached, quên commit, ràng buộc, rollback

<?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-cau-hinh-crud</artifactId>
    <version>1.0.0</version>
    <name>Hibernate - Cau hinh va CRUD</name>

    <properties>
        <maven.compiler.release>17</maven.compiler.release>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <main.class>dev.canhdominich.hibernate.crud.CrudDemo</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.hibernate.orm</groupId>
            <artifactId>hibernate-hikaricp</artifactId>
            <version>${hibernate.version}</version>
        </dependency>
        <dependency>
            <groupId>com.zaxxer</groupId>
            <artifactId>HikariCP</artifactId>
            <version>7.1.0</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.crud;

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.crud;

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.crud;

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, unique = true, 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 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.crud;

import jakarta.persistence.EntityManagerFactory;
import jakarta.persistence.Persistence;
import java.io.IOException;
import java.io.InputStream;
import java.util.HashMap;
import java.util.Map;
import java.util.Properties;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

public final class Configurations {

    private Configurations() {
    }

    private static Map<String, String> connection(DbConfig config) {
        Map<String, String> map = new HashMap<>();
        map.put("hibernate.connection.url", config.url());
        map.put("hibernate.connection.username", config.user());
        map.put("hibernate.connection.password", config.password());
        return map;
    }

    public static SessionFactory programmatic(DbConfig config) {
        Configuration configuration = new Configuration()
                .setProperty("hibernate.hbm2ddl.auto", "create-drop")
                .setProperty("hibernate.session_factory.statement_inspector", SqlRecorder.class.getName())
                .addAnnotatedClass(Student.class);
        connection(config).forEach(configuration::setProperty);
        return configuration.buildSessionFactory();
    }

    public static SessionFactory fromPropertiesFile(DbConfig config) throws IOException {
        Properties properties = new Properties();
        try (InputStream in = Configurations.class.getResourceAsStream("/lab/hibernate-lab.properties")) {
            properties.load(in);
        }
        Configuration configuration = new Configuration().addProperties(properties).addAnnotatedClass(Student.class);
        connection(config).forEach(configuration::setProperty);
        return configuration.buildSessionFactory();
    }

    public static SessionFactory fromCfgXml(DbConfig config) {
        Configuration configuration = new Configuration().configure();
        connection(config).forEach(configuration::setProperty);
        return configuration.buildSessionFactory();
    }

    public static EntityManagerFactory fromPersistenceXml(DbConfig config) {
        Map<String, Object> overrides = new HashMap<>(connection(config));
        return Persistence.createEntityManagerFactory("lab", overrides);
    }

    public static SessionFactory withHikari(DbConfig config, int poolSize) {
        Configuration configuration = new Configuration()
                .setProperty("hibernate.hbm2ddl.auto", "create-drop")
                .setProperty("hibernate.connection.provider_class", "org.hibernate.hikaricp.internal.HikariCPConnectionProvider")
                .setProperty("hibernate.hikari.maximumPoolSize", String.valueOf(poolSize))
                .setProperty("hibernate.session_factory.statement_inspector", SqlRecorder.class.getName())
                .addAnnotatedClass(Student.class);
        connection(config).forEach(configuration::setProperty);
        return configuration.buildSessionFactory();
    }

    public static SessionFactory withBuiltInPool(DbConfig config) {
        Configuration configuration = new Configuration()
                .setProperty("hibernate.hbm2ddl.auto", "create-drop")
                .setProperty("hibernate.connection.provider_class", "org.hibernate.engine.jdbc.connections.internal.DriverManagerConnectionProvider")
                .addAnnotatedClass(Student.class);
        connection(config).forEach(configuration::setProperty);
        return configuration.buildSessionFactory();
    }
}

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD 3.0//EN" "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
    <session-factory>
        <property name="hibernate.hbm2ddl.auto">create-drop</property>
        <property name="hibernate.session_factory.statement_inspector">dev.canhdominich.hibernate.crud.SqlRecorder</property>
        <mapping class="dev.canhdominich.hibernate.crud.Student"/>
    </session-factory>
</hibernate-configuration>

<?xml version="1.0" encoding="UTF-8"?>
<persistence xmlns="https://jakarta.ee/xml/ns/persistence" version="3.2">
    <persistence-unit name="lab">
        <class>dev.canhdominich.hibernate.crud.Student</class>
        <properties>
            <property name="hibernate.hbm2ddl.auto" value="create-drop"/>
            <property name="hibernate.session_factory.statement_inspector" value="dev.canhdominich.hibernate.crud.SqlRecorder"/>
        </properties>
    </persistence-unit>
</persistence>

hibernate.hbm2ddl.auto=create-drop
hibernate.session_factory.statement_inspector=dev.canhdominich.hibernate.crud.SqlRecorder

package dev.canhdominich.hibernate.crud;

import jakarta.persistence.EntityManagerFactory;
import org.hibernate.SessionFactory;
import org.hibernate.dialect.Dialect;
import org.hibernate.engine.jdbc.connections.spi.ConnectionProvider;
import org.hibernate.engine.spi.SessionFactoryImplementor;

public final class ConfigurationDemo {

    private ConfigurationDemo() {
    }

    public static void main(String[] args) throws Exception {
        DbConfig config = DbConfig.fromEnvironment();
        describe("programmatic Configuration       ", Configurations.programmatic(config));
        describe("hibernate.properties-style file   ", Configurations.fromPropertiesFile(config));
        describe("hibernate.cfg.xml                 ", Configurations.fromCfgXml(config));
        try (EntityManagerFactory emf = Configurations.fromPersistenceXml(config)) {
            describe("persistence.xml (JPA bootstrap)   ", emf.unwrap(SessionFactory.class));
        }
        describe("hikaricp module, pool size 7       ", Configurations.withHikari(config, 7));
        describe("built-in pool forced explicitly    ", Configurations.withBuiltInPool(config));
    }

    static void describe(String label, SessionFactory factory) {
        try (factory) {
            SessionFactoryImplementor implementor = (SessionFactoryImplementor) factory;
            Dialect dialect = implementor.getJdbcServices().getDialect();
            ConnectionProvider provider = implementor.getServiceRegistry().getService(ConnectionProvider.class);
            String detail = provider.isUnwrappableAs(com.zaxxer.hikari.HikariDataSource.class)
                    ? " maximumPoolSize=" + provider.unwrap(com.zaxxer.hikari.HikariDataSource.class).getMaximumPoolSize() : "";
            System.out.println(label + " dialect=" + dialect.getClass().getSimpleName() + " connectionProvider=" + provider.getClass().getSimpleName() + detail);
        }
    }
}

programmatic Configuration        dialect=MySQLDialect connectionProvider=HikariCPConnectionProvider maximumPoolSize=10
hibernate.properties-style file   dialect=MySQLDialect connectionProvider=HikariCPConnectionProvider maximumPoolSize=10
hibernate.cfg.xml                 dialect=MySQLDialect connectionProvider=HikariCPConnectionProvider maximumPoolSize=10
persistence.xml (JPA bootstrap)   dialect=MySQLDialect connectionProvider=HikariCPConnectionProvider maximumPoolSize=10
hikaricp module, pool size 7      dialect=MySQLDialect connectionProvider=HikariCPConnectionProvider maximumPoolSize=7
built-in pool forced explicitly   dialect=MySQLDialect connectionProvider=DriverManagerConnectionProvider

package dev.canhdominich.hibernate.crud;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.List;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

public final class SchemaDemo {

    private static DbConfig CONFIG;

    private SchemaDemo() {
    }

    public static void main(String[] args) throws SQLException {
        run(DbConfig.fromEnvironment());
    }

    public static void run(DbConfig config) throws SQLException {
        CONFIG = config;
        System.out.println("-- no table at all");
        reset("DROP TABLE IF EXISTS student");
        attempt("none", "none");
        attempt("validate", "validate");
        System.out.println("-- an old table that lacks the column level and has an extra legacy_notes column");
        reset("DROP TABLE IF EXISTS student", "CREATE TABLE student (id BIGINT AUTO_INCREMENT PRIMARY KEY, full_name VARCHAR(100) NOT NULL, email VARCHAR(100) NOT NULL UNIQUE, legacy_notes TEXT)");
        attempt("validate", "validate");
        attempt("update", "update");
        attempt("update again", "update");
        System.out.println("-- create and create-drop");
        attempt("create", "create");
        attempt("create-drop", "create-drop");
        reset("DROP TABLE IF EXISTS student");
    }

    static void attempt(String label, String mode) throws SQLException {
        try {
            SessionFactory factory = new Configuration()
                    .setProperty("hibernate.connection.url", CONFIG.url())
                    .setProperty("hibernate.connection.username", CONFIG.user())
                    .setProperty("hibernate.connection.password", CONFIG.password())
                    .setProperty("hibernate.hbm2ddl.auto", mode)
                    .addAnnotatedClass(Student.class)
                    .buildSessionFactory();
            factory.close();
            System.out.println(String.format("%-14s started, columns after: %s", label, columns()));
        } catch (RuntimeException e) {
            Throwable root = e;
            while (root.getCause() != null && root.getCause() != root) {
                root = root.getCause();
            }
            System.out.println(String.format("%-14s FAILED %s: %s", label, root.getClass().getSimpleName(), root.getMessage()));
        }
    }

    static List<String> columns() throws SQLException {
        List<String> names = new ArrayList<>();
        try (Connection connection = open(); Statement statement = connection.createStatement(); ResultSet rs = statement.executeQuery("SELECT column_name FROM information_schema.columns WHERE table_schema = DATABASE() AND table_name = 'student' ORDER BY ordinal_position")) {
            while (rs.next()) {
                names.add(rs.getString(1));
            }
        }
        return names;
    }

    static void reset(String... statements) throws SQLException {
        try (Connection connection = open(); Statement statement = connection.createStatement()) {
            for (String sql : statements) {
                statement.execute(sql);
            }
        }
    }

    private static Connection open() throws SQLException {
        return DriverManager.getConnection(CONFIG.url(), CONFIG.user(), CONFIG.password());
    }
}

-- no table at all
none           started, columns after: []
validate       FAILED SchemaManagementException: Schema validation: missing table [student]
-- an old table that lacks the column level and has an extra legacy_notes column
validate       FAILED SchemaManagementException: Schema validation: missing column [level] in table [student]
update         started, columns after: [id, full_name, email, legacy_notes, level]
update again   started, columns after: [id, full_name, email, legacy_notes, level]
-- create and create-drop
create         started, columns after: [id, email, full_name, level]
create-drop    started, columns after: []

package dev.canhdominich.hibernate.crud;

import java.util.function.Consumer;
import java.util.function.Function;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;

public final class UnitOfWork {

    private UnitOfWork() {
    }

    public static <T> T inTransaction(SessionFactory factory, Function<Session, T> work) {
        try (Session session = factory.openSession()) {
            Transaction tx = session.beginTransaction();
            try {
                T result = work.apply(session);
                tx.commit();
                return result;
            } catch (RuntimeException e) {
                if (tx.isActive()) {
                    tx.rollback();
                }
                throw e;
            }
        }
    }

    public static void run(SessionFactory factory, Consumer<Session> work) {
        inTransaction(factory, session -> {
            work.accept(session);
            return null;
        });
    }
}

package dev.canhdominich.hibernate.crud;

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

public final class CrudDemo {

    private CrudDemo() {
    }

    public static void main(String[] args) {
        try (SessionFactory factory = Configurations.programmatic(DbConfig.fromEnvironment())) {
            long id = create(factory);
            read(factory, id);
            update(factory, id);
            bulkUpdateIsInvisibleToManagedEntities(factory, id);
            delete(factory, id);
            missingRows(factory, id);
        }
    }

    static long create(SessionFactory factory) {
        SqlRecorder.clear();
        long id = UnitOfWork.inTransaction(factory, session -> {
            Student student = new Student("Nguyễn Văn An", "an@example.com");
            session.persist(student);
            return student.getId();
        });
        SqlRecorder.print("-- create: persist inside one transaction");
        return id;
    }

    static void read(SessionFactory factory, long id) {
        UnitOfWork.run(factory, session -> System.out.println("-- read: " + session.find(Student.class, id)));
        SqlRecorder.print("-- SQL of the read");
    }

    static void update(SessionFactory factory, long id) {
        UnitOfWork.run(factory, session -> session.find(Student.class, id).setFullName("Nguyễn Văn An (cập nhật)"));
        SqlRecorder.print("-- update: load, change, commit");
    }

    static void bulkUpdateIsInvisibleToManagedEntities(SessionFactory factory, long id) {
        try (Session session = factory.openSession()) {
            Transaction tx = session.beginTransaction();
            Student student = session.find(Student.class, id);
            int rows = session.createMutationQuery("update Student s set s.level = :level where s.id = :id").setParameter("level", Student.Level.ADVANCED).setParameter("id", id).executeUpdate();
            System.out.println("-- HQL bulk update changed " + rows + " row; the managed object still says " + student.getLevel());
            session.refresh(student);
            System.out.println("-- after refresh() the object says " + student.getLevel());
            tx.commit();
        }
        SqlRecorder.print("-- SQL of the bulk update scenario");
    }

    static void delete(SessionFactory factory, long id) {
        UnitOfWork.run(factory, session -> session.remove(session.find(Student.class, id)));
        SqlRecorder.print("-- delete: load then remove");
    }

    static void missingRows(SessionFactory factory, long id) {
        UnitOfWork.run(factory, session -> {
            System.out.println("-- find() of a missing row returns " + session.find(Student.class, id));
            Student reference = session.getReference(Student.class, id);
            try {
                reference.getFullName();
            } catch (RuntimeException e) {
                System.out.println("-- getReference() of a missing row fails only when used: " + e.getClass().getSimpleName());
            }
        });
    }
}

-- create: persist inside one transaction
  insert into student (email,full_name,level) values (?,?,?)
-- read: Student[1, Nguyễn Văn An, BASIC]
-- SQL of the read
  select s1_0.id,s1_0.email,s1_0.full_name,s1_0.level from student s1_0 where s1_0.id=?
-- update: load, change, commit
  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=?
-- delete: load then remove
  select s1_0.id,s1_0.email,s1_0.full_name,s1_0.level from student s1_0 where s1_0.id=?
  delete from student where id=?
-- find() of a missing row returns null
-- getReference() of a missing row fails only when used: ObjectNotFoundException

-- HQL bulk update changed 1 row; the managed object still says BASIC
-- after refresh() the object says ADVANCED
-- SQL of the bulk update scenario
  select s1_0.id,s1_0.email,s1_0.full_name,s1_0.level from student s1_0 where s1_0.id=?
  update student s1_0 set level=? where s1_0.id=?
  select s1_0.id,s1_0.email,s1_0.full_name,s1_0.level from student s1_0 where s1_0.id=?

package dev.canhdominich.hibernate.crud;

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

public final class TransactionPitfallsDemo {

    private TransactionPitfallsDemo() {
    }

    public static void main(String[] args) {
        try (SessionFactory factory = Configurations.programmatic(DbConfig.fromEnvironment())) {
            reset(factory);
            detachedObjects(factory);
            reset(factory);
            forgottenCommit(factory);
            constraintViolation(factory);
            rollbackKeepsMemoryState(factory);
        }
    }

    static void reset(SessionFactory factory) {
        UnitOfWork.run(factory, session -> {
            session.createMutationQuery("delete from Student").executeUpdate();
            session.persist(new Student("An", "an@example.com"));
        });
    }

    static long rows(SessionFactory factory) {
        try (Session session = factory.openSession()) {
            return session.createQuery("select count(s) from Student s", Long.class).getSingleResult();
        }
    }

    static void detachedObjects(SessionFactory factory) {
        Student detached;
        try (Session session = factory.openSession()) {
            detached = session.createQuery("from Student", Student.class).getSingleResult();
        }
        try {
            UnitOfWork.run(factory, session -> session.persist(detached));
        } catch (RuntimeException e) {
            System.out.println("-- persist(detached): " + e.getClass().getSimpleName() + ": " + e.getMessage());
        }
        try {
            UnitOfWork.run(factory, session -> session.remove(detached));
            System.out.println("-- remove(detached): no exception, rows left = " + rows(factory));
        } catch (RuntimeException e) {
            System.out.println("-- remove(detached): " + e.getClass().getSimpleName() + ": " + e.getMessage());
        }
    }

    static void forgottenCommit(SessionFactory factory) {
        try (Session session = factory.openSession()) {
            session.beginTransaction();
            session.persist(new Student("Forgotten", "forgotten@example.com"));
        }
        try (Session session = factory.openSession()) {
            Long count = session.createQuery("select count(s) from Student s where s.email = 'forgotten@example.com'", Long.class).getSingleResult();
            System.out.println("-- a Session closed without commit: rows stored = " + count);
        }
    }

    static void constraintViolation(SessionFactory factory) {
        try (Session session = factory.openSession()) {
            Transaction tx = session.beginTransaction();
            try {
                session.persist(new Student("Duplicate", "an@example.com"));
                tx.commit();
            } catch (RuntimeException e) {
                System.out.println("-- duplicate email, raised by persist() because IDENTITY inserts at once: " + e.getClass().getSimpleName() + ", cause " + e.getCause().getClass().getSimpleName());
                System.out.println("-- transaction status after the failure: " + tx.getStatus() + ", active = " + tx.isActive());
            }
        }
    }

    static void rollbackKeepsMemoryState(SessionFactory factory) {
        try (Session session = factory.openSession()) {
            Transaction tx = session.beginTransaction();
            Student student = session.createQuery("from Student s where s.email = 'an@example.com'", Student.class).getSingleResult();
            student.setFullName("Changed then rolled back");
            tx.rollback();
            System.out.println("-- after rollback the object in memory still says: " + student.getFullName());
        }
        try (Session session = factory.openSession()) {
            System.out.println("-- and the database says: " + session.createQuery("from Student s where s.email = 'an@example.com'", Student.class).getSingleResult().getFullName());
        }
    }
}

-- persist(detached): EntityExistsException: Detached entity passed to persist: dev.canhdominich.hibernate.crud.Student
-- remove(detached): no exception, rows left = 0
-- a Session closed without commit: rows stored = 0
-- duplicate email, raised by persist() because IDENTITY inserts at once: ConstraintViolationException, cause SQLIntegrityConstraintViolationException
-- transaction status after the failure: MARKED_ROLLBACK, active = true
-- after rollback the object in memory still says: Changed then rolled back
-- and the database says: An