Hibernate（19）什么是Hibernate的急加载？

Hibernate的急加载（Eager Loading）是一种数据加载策略，即在加载实体时立即加载其关联实体。这种方式通过一次查询获取所有相关联的数据，避免在后续访问关联数据时重复查询数据库。急加载通常用于需要频繁访问关联数据的场景，从而提高查询效率和减少数据库访问次数。

急加载的实现

在Hibernate中，急加载通过在关联关系上指定FetchType.EAGER来实现。常用于@OneToMany、@ManyToOne、@OneToOne、@ManyToMany等关联关系。

示例代码

下面是一个完整的示例，展示如何在Hibernate中使用急加载。

配置文件 `hibernate.cfg.xml`

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"/>
        <mapping class="com.example.domain.Course"/>
    </session-factory>
</hibernate-configuration>

HibernateUtil 类

java 复制代码

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 和 Course

Student 类

java 复制代码

package com.example.domain;

import javax.persistence.*;
import java.util.HashSet;
import java.util.Set;

@Entity
public class Student {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    private String name;
    private int age;

    @OneToMany(mappedBy = "student", fetch = FetchType.EAGER, cascade = CascadeType.ALL)
    private Set<Course> courses = new HashSet<>();

    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;
    }

    public Set<Course> getCourses() {
        return courses;
    }

    public void setCourses(Set<Course> courses) {
        this.courses = courses;
    }
}

Course 类

java 复制代码

package com.example.domain;

import javax.persistence.*;

@Entity
public class Course {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    private String name;

    @ManyToOne(fetch = FetchType.EAGER)
    @JoinColumn(name = "student_id")
    private Student student;

    public Course() {}

    public Course(String name, Student student) {
        this.name = name;
        this.student = student;
    }

    // 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 Student getStudent() {
        return student;
    }

    public void setStudent(Student student) {
        this.student = student;
    }
}

急加载示例代码

下面的示例展示了如何在并发环境中使用急加载。

java 复制代码

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

public class HibernateEagerLoadingExample {
    public static void main(String[] args) {
        // 获取SessionFactory
        SessionFactory sessionFactory = HibernateUtil.getSessionFactory();

        // 插入示例数据
        insertSampleData(sessionFactory);

        // 示例: 使用急加载加载数据
        Session session = null;
        Transaction transaction = null;

        try {
            session = sessionFactory.openSession();
            transaction = session.beginTransaction();

            // 获取Student对象
            Student student = session.get(Student.class, 1L);
            System.out.println("Student: " + student.getName() + ", Age: " + student.getAge());

            // 访问急加载的集合
            System.out.println("Courses: " + student.getCourses().size());
            for (Course course : student.getCourses()) {
                System.out.println("Course: " + course.getName());
            }

            transaction.commit();
        } catch (Exception e) {
            if (transaction != null) {
                transaction.rollback();
            }
            e.printStackTrace();
        } finally {
            if (session != null) {
                session.close();
            }
        }

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

    private static void insertSampleData(SessionFactory sessionFactory) {
        Session session = sessionFactory.openSession();
        Transaction transaction = session.beginTransaction();
        try {
            Student student = new Student("John Doe", 20);
            Course course1 = new Course("Mathematics", student);
            Course course2 = new Course("Physics", student);
            student.getCourses().add(course1);
            student.getCourses().add(course2);
            session.save(student);
            transaction.commit();
        } catch (Exception e) {
            if (transaction != null) {
                transaction.rollback();
            }
            e.printStackTrace();
        } finally {
            if (session != null) {
                session.close();
            }
        }
    }
}

详细解释

配置急加载 ：在实体类的关联字段上添加fetch = FetchType.EAGER注解。

java 复制代码

@OneToMany(mappedBy = "student", fetch = FetchType.EAGER, cascade = CascadeType.ALL)
private Set<Course> courses = new HashSet<>();

示例场景：
- 在一个会话中获取Student对象及其关联的Course集合。
- 急加载策略会在获取Student对象时立即加载其关联的Course集合。
- 访问Student对象的Courses集合时，不需要额外的数据库查询，因为关联的Course对象已经在加载Student对象时一起加载了。
事务管理：在事务中进行数据操作，并在操作完成后提交事务。如果操作失败，则回滚事务以确保数据一致性。

总结

急加载是一种数据加载策略，通过在加载实体时立即加载其关联实体，减少了在后续访问关联数据时的数据库查询次数。在Hibernate中，通过fetch = FetchType.EAGER注解可以方便地实现急加载。理解并正确应用急加载，可以有效地提高查询效率和减少数据库访问次数，特别是在需要频繁访问关联数据的场景中。

Hibernate（19）什么是Hibernate的急加载？

急加载的实现

示例代码

配置文件 hibernate.cfg.xml

HibernateUtil 类

实体类 Student 和 Course

Student 类

Course 类

急加载示例代码

详细解释

总结

配置文件 `hibernate.cfg.xml`