Hibernate（27）Hibernate的查询策略是什么？

Victor3562026-01-07 20:02

Hibernate的查询策略

Hibernate的查询策略决定了如何从数据库中检索数据。它包括多种策略，如即时加载（Eager Loading）、延迟加载（Lazy Loading）和批量检索（Batch Fetching）等。这些策略可以显著影响应用程序的性能和内存使用，因此了解和选择合适的查询策略非常重要。

主要查询策略

  1. 即时加载（Eager Loading）：在加载实体时，同时加载其关联的实体。
  2. 延迟加载（Lazy Loading）：只有在访问关联实体时，才加载该实体。
  3. 批量检索（Batch Fetching）：在一次查询中加载多个关联的实体。

配置查询策略的方式

  1. 在映射文件或注解中配置。
  2. 在查询中指定（如HQL或Criteria查询）。

示例代码

配置文件 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.Person"/>
        <mapping class="com.example.domain.Address"/>
    </session-factory>
</hibernate-configuration>

实体类 Person 和 Address

Person类
java 复制代码 
package com.example.domain;

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

@Entity
@Table(name = "person")
public class Person {

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

    @Column(name = "name")
    private String name;

    @Column(name = "age")
    private int age;

    @OneToMany(mappedBy = "person", fetch = FetchType.LAZY, cascade = CascadeType.ALL)
    private Set<Address> addresses = new HashSet<>();

    public Person() {}

    public Person(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<Address> getAddresses() {
        return addresses;
    }

    public void setAddresses(Set<Address> addresses) {
        this.addresses = addresses;
    }
}
Address类
java 复制代码 
package com.example.domain;

import javax.persistence.*;

@Entity
@Table(name = "address")
public class Address {

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

    @Column(name = "street")
    private String street;

    @ManyToOne
    @JoinColumn(name = "person_id", nullable = false)
    private Person person;

    public Address() {}

    public Address(String street, Person person) {
        this.street = street;
        this.person = person;
    }

    // Getters 和 Setters
    
    public Long getId() {
        return id;
    }

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

    public String getStreet() {
        return street;
    }

    public void setStreet(String street) {
        this.street = street;
    }

    public Person getPerson() {
        return person;
    }

    public void setPerson(Person person) {
        this.person = person;
    }
}

即时加载和延迟加载示例

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

即时加载示例

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();

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

        // 即时加载示例
        eagerLoadingExample(sessionFactory);

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

    private static void insertData(SessionFactory sessionFactory) {
        Session session = sessionFactory.openSession();
        Transaction transaction = session.beginTransaction();
        try {
            Person person = new Person("John Doe", 30);
            Address address1 = new Address("123 Street", person);
            Address address2 = new Address("456 Avenue", person);
            person.getAddresses().add(address1);
            person.getAddresses().add(address2);

            session.save(person);
            transaction.commit();
            System.out.println("Inserted Person and Addresses");
        } catch (Exception e) {
            if (transaction != null) {
                transaction.rollback();
            }
            e.printStackTrace();
        } finally {
            if (session != null) {
                session.close();
            }
        }
    }

    private static void eagerLoadingExample(SessionFactory sessionFactory) {
        Session session = sessionFactory.openSession();
        try {
            // 获取Person实体，并同时加载其关联的Address实体（即时加载）
            Person person = session.get(Person.class, 1L);
            if (person != null) {
                System.out.println("Person: " + person.getName());
                for (Address address : person.getAddresses()) {
                    System.out.println("Address: " + address.getStreet());
                }
            } else {
                System.out.println("No Person found with ID 1");
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (session != null) {
                session.close();
            }
        }
    }
}

延迟加载示例

java 复制代码 
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;

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

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

        // 延迟加载示例
        lazyLoadingExample(sessionFactory);

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

    private static void insertData(SessionFactory sessionFactory) {
        Session session = sessionFactory.openSession();
        Transaction transaction = session.beginTransaction();
        try {
            Person person = new Person("John Doe", 30);
            Address address1 = new Address("123 Street", person);
            Address address2 = new Address("456 Avenue", person);
            person.getAddresses().add(address1);
            person.getAddresses().add(address2);

            session.save(person);
            transaction.commit();
            System.out.println("Inserted Person and Addresses");
        } catch (Exception e) {
            if (transaction != null) {
                transaction.rollback();
            }
            e.printStackTrace();
        } finally {
            if (session != null) {
                session.close();
            }
        }
    }

    private static void lazyLoadingExample(SessionFactory sessionFactory) {
        Session session = sessionFactory.openSession();
        try {
            // 获取Person实体，此时不会立即加载其关联的Address实体（延迟加载）
            Person person = session.get(Person.class, 1L);
            if (person != null) {
                System.out.println("Person: " + person.getName());
                // 访问关联的Address实体时才会触发加载
                for (Address address : person.getAddresses()) {
                    System.out.println("Address: " + address.getStreet());
                }
            } else {
                System.out.println("No Person found with ID 1");
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (session != null) {
                session.close();
            }
        }
    }
}

批量检索示例

批量检索通过在查询中使用@BatchSize注解或Hibernate的配置文件中的相应属性来实现。

java 复制代码 
package com.example.domain;

import org.hibernate.annotations.BatchSize;

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

@Entity
@Table(name = "person")
@BatchSize(size = 10)
public class Person {
相关推荐
Java天梯之路3 小时前
Spring Boot 钩子全集实战（七）：BeanFactoryPostProcessor详解
java·spring boot·后端
wr2005143 小时前
第二次作业，渗透
java·后端·spring
短剑重铸之日3 小时前
《SpringCloud实用版》生产部署：Docker + Kubernetes + GraalVM 原生镜像 完整方案
后端·spring cloud·docker·kubernetes·graalvm
爬山算法4 小时前
Hibernate（67）如何在云环境中使用Hibernate？
java·后端·hibernate
女王大人万岁5 小时前
Go标准库 io与os库详解
服务器·开发语言·后端·golang
露天赏雪5 小时前
Java 高并发编程实战：从线程池到分布式锁，解决生产环境并发问题
java·开发语言·spring boot·分布式·后端·mysql
短剑重铸之日6 小时前
《SpringCloud实用版》 Seata 分布式事务实战：AT / TCC / Saga /XA
后端·spring·spring cloud·seata·分布式事务
FAFU_kyp6 小时前
RISC0_ZERO项目在macOs上生成链上证明避坑
开发语言·后端·学习·macos·rust
qq_12498707536 小时前
基于springboot的会议室预订系统设计与实现（源码+论文+部署+安装）
java·vue.js·spring boot·后端·信息可视化·毕业设计·计算机毕业设计
女王大人万岁7 小时前
Go语言time库核心用法与实战避坑
服务器·开发语言·后端·golang
热门推荐
01GitHub 镜像站点02OpenCode 入门教程：介绍 · 安装 · 配置第三方 API (如 Claude)03Clawdbot 中文汉化版 接入微信、飞书04一种新的LCA算法05【网络安全测试】Burp Suite工具使用说明、配置及常见问题（有关必回）06Claude Code Skills 实用使用手册07在Trae中使用Pencil MCP08零门槛部署本地 AI 助手：Clawdbot/Meltbot 部署深度保姆级教程09struts2 XML外部实体注入漏洞复现（CVE-2025-68493）10UV安装并设置国内源