Hibernate（9）什么是Hibernate的Transaction？

Hibernate的Transaction接口用于管理数据库事务。事务是数据库操作的一个逻辑单元，它确保要么所有操作都成功，要么所有操作都回滚，从而保证数据的一致性和完整性。在Hibernate中，事务管理主要是通过Transaction接口实现的，通常与Session对象一起使用。

主要功能

1. 开始事务 ：通过beginTransaction方法开始一个新的事务。
2. 提交事务 ：通过commit方法提交当前事务，将所有更改持久化到数据库中。
3. 回滚事务 ：通过rollback方法回滚当前事务，撤销所有未提交的更改。
4. 事务状态查询 ：提供查询事务状态的方法，如isActive。

使用示例

以下是一个详细的代码示例，展示如何在Hibernate中使用Transaction接口进行CRUD操作。

hibernate.cfg.xml 配置

<!DOCTYPE hibernate-configuration PUBLIC
        "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
        "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
    <session-factory>
        <!-- 数据库连接配置 -->
        <property name="hibernate.connection.driver_class">com.mysql.cj.jdbc.Driver</property>
        <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/your_database</property>
        <property name="hibernate.connection.username">your_username</property>
        <property name="hibernate.connection.password">your_password</property>

        <!-- Hibernate 属性配置 -->
        <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
        <property name="hibernate.show_sql">true</property>
        <property name="hibernate.format_sql">true</property>
        <property name="hibernate.hbm2ddl.auto">update</property>

        <!-- 映射类配置 -->
        <mapping class="com.example.domain.Student"/>
    </session-factory>
</hibernate-configuration>

HibernateUtil 类

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

public class HibernateUtil {
    private static final SessionFactory sessionFactory;

    static {
        try {
            // 从配置文件创建SessionFactory
            sessionFactory = new Configuration().configure("hibernate.cfg.xml").buildSessionFactory();
        } catch (Throwable ex) {
            // 记录启动失败的错误
            System.err.println("Initial SessionFactory creation failed." + ex);
            throw new ExceptionInInitializerError(ex);
        }
    }

    public static SessionFactory getSessionFactory() {
        return sessionFactory;
    }
}

实体类 Student

public class Student {
    private Long id;
    private String name;
    private int age;

    public Student() {}

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // getters 和 setters
    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

使用事务进行CRUD操作

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

public class HibernateExample {
    public static void main(String[] args) {
        // 获取SessionFactory
        SessionFactory sessionFactory = HibernateUtil.getSessionFactory();
        // 打开一个新的Session
        Session session = sessionFactory.openSession();

        Transaction transaction = null;
        try {
            // 启动事务
            transaction = session.beginTransaction();

            // 创建并保存Student对象
            Student student = new Student("John Doe", 20);
            session.save(student); // 保存对象

            // 提交事务
            transaction.commit();
        } catch (Exception e) {
            if (transaction != null) {
                transaction.rollback(); // 回滚事务
            }
            e.printStackTrace();
        } finally {
            session.close(); // 关闭Session
        }

        // 读取、更新和删除操作
        try {
            // 打开一个新的Session
            session = sessionFactory.openSession();
            // 启动事务
            transaction = session.beginTransaction();

            // 读取Student对象
            Student retrievedStudent = session.get(Student.class, student.getId());
            System.out.println("Retrieved Student: " + retrievedStudent.getName() + ", Age: " + retrievedStudent.getAge());

            // 更新Student对象
            retrievedStudent.setAge(21);
            session.update(retrievedStudent); // 更新对象

            // 删除Student对象
            session.delete(retrievedStudent); // 删除对象

            // 提交事务
            transaction.commit();
        } catch (Exception e) {
            if (transaction != null) {
                transaction.rollback(); // 回滚事务
            }
            e.printStackTrace();
        } finally {
            session.close(); // 关闭Session
        }

        // 关闭SessionFactory
        sessionFactory.close();
    }
}

详细解释

1. 获取SessionFactory ：从HibernateUtil类中获取单例的SessionFactory实例。
2. 打开Session ：通过sessionFactory.openSession()方法打开一个新的Session对象。
3. 启动事务 ：通过session.beginTransaction()方法开始一个新的事务。
4. CRUD操作 ：
   • 创建并保存对象 ：创建一个Student对象，并使用session.save(student)方法将其保存到数据库中。
   • 提交事务 ：使用transaction.commit()方法提交事务，将所有更改持久化到数据库中。
   • 读取对象 ：通过session.get(Student.class, student.getId())方法从数据库中读取对象。
   • 更新对象 ：修改对象属性后，使用session.update(retrievedStudent)方法更新数据库中的记录。
   • 删除对象 ：使用session.delete(retrievedStudent)方法从数据库中删除对象。
5. 回滚事务 ：在捕获异常的情况下，如果事务未提交，使用transaction.rollback()方法回滚事务，撤销所有未提交的更改。
6. 关闭Session ：在finally块中通过session.close()方法关闭Session。
7. 关闭SessionFactory ：在应用程序结束时，通过sessionFactory.close()方法关闭SessionFactory。

事务管理的注意事项

1. 嵌套事务：Hibernate不直接支持嵌套事务，维护嵌套事务的状态需要额外的管理。
2. 自动提交：确保在使用事务时，设置数据库连接的自动提交模式为false，以便手动管理事务。
3. 异常处理：在事务操作中，应当妥善处理异常，在捕获异常后回滚事务以保证数据的一致性。

总结

Hibernate的Transaction接口提供了对数据库事务的管理功能，使得应用程序能够保证数据操作的一致性和完整性。通过详细的配置和正确的使用Transaction接口，可以高效地进行数据库操作，确保应用程序的稳定性和可靠性。