小菜鸟

java菜鸟号正在起航

0%

hibernate检索策略

发表于 更新于 分类于 阅读次数： Valine：
本文字数： 8k 阅读时长 ≈ 7 分钟

Hibernate 检索策略详解：从立即加载到连接查询的优化实践

Hibernate 的检索策略（Retrieval Strategy）决定了对象及其关联数据的加载时机和方式，直接影响数据库交互效率。合理的检索策略能减少不必要的 SQL 执行，避免 “N+1 查询” 等性能问题。本文系统解析 Hibernate 的三种核心检索策略（立即检索、延迟检索、迫切左外连接检索），结合类级别与关联级别的配置差异，详解其实现机制、适用场景及最佳实践。

检索策略的核心目标与分类

核心目标

  • 减少数据库访问次数：避免频繁执行 SQL 导致的性能损耗；
  • 按需加载数据：仅加载应用程序实际需要的对象及关联数据，避免 “加载过多”；
  • 平衡内存与性能：延迟加载减少内存占用，连接查询减少 SQL 次数，需根据业务场景权衡。

分类

Hibernate 检索策略按作用范围分为两类：

  • 类级别检索策略：控制单个实体对象的加载时机（如 load(User.class, 1L) 何时执行 SQL）；
  • 关联级别检索策略：控制关联对象的加载时机（如加载 Customer 时，其关联的 Order 集合何时加载）。

类级别的检索策略

类级别仅支持两种检索策略：立即检索和延迟检索，通过 <class> 元素的 lazy 属性配置（默认 lazy="true"，即延迟检索）。

1. 立即检索（lazy="false"）

行为特征

调用 load() 或 get() 方法时，立即执行 SQL 从数据库加载对象的所有属性（除关联对象外），返回真实对象（非代理）。

配置示例
1
2
3
4
5
6
7
<class name="User" table="t_user" lazy="false"> <!-- 立即检索 -->
    <id name="id" type="java.lang.Long">
        <column name="id"/>
        <generator class="native"/>
    </id>
    <property name="name" column="name"/>
</class>
代码验证
1
2
3
4
5
6
7
8
Session session = sessionFactory.getCurrentSession();
Transaction tx = session.beginTransaction();

// 调用load()时，因lazy="false"，立即执行SELECT * FROM t_user WHERE id=1
User user = session.load(User.class, 1L); 
System.out.println("未访问属性，已执行SQL"); // 此时SQL已执行

tx.commit();

2. 延迟检索（lazy="true"，默认值）

行为特征
  • 调用 load() 方法时，不立即执行 SQL，而是返回一个代理对象（由 CGLIB 动态生成，继承自原实体类）；
  • 代理对象仅初始化 OID（主键），其他属性为 null；
  • 当首次访问非 OID 属性（如 user.getName()）时，Hibernate 才执行 SQL 加载完整数据；
  • 若 Session 已关闭，访问代理对象的非 OID 属性会抛 LazyInitializationException（懒加载异常）。
配置示例
1
2
3
<class name="User" table="t_user" lazy="true"> <!-- 延迟检索（默认） -->
    <!-- 主键与属性配置同上 -->
</class>
代码验证
1
2
3
4
5
6
7
8
9
10
11
Session session = sessionFactory.getCurrentSession();
Transaction tx = session.beginTransaction();

// 调用load()时，不执行SQL，返回代理对象
User user = session.load(User.class, 1L); 
System.out.println("未访问属性，未执行SQL"); 

// 首次访问非OID属性，执行SQL
System.out.println(user.getName()); 

tx.commit();

3. 类级别检索策略的关键注意事项

  • get() 方法的特殊性：无论 lazy 属性如何设置，get() 方法始终采用立即检索（调用时直接执行 SQL，无代理对象）；
  • load() 方法的代理依赖：延迟检索仅对 load() 有效，且依赖 CGLIB 代理生成（需确保依赖包存在）；
  • 适用场景：
    • 立即检索：对象必须立即使用，且 Session 可能提前关闭（如 Web 层使用）；
    • 延迟检索：对象可能不被使用（如仅判断是否存在），或可在 Session 关闭前完成属性访问（如 Service 层内部处理）。

关联级别的检索策略

关联级别（如一对多、多对一）支持三种检索策略：立即检索、延迟检索、迫切左外连接检索，通过关联标签（<set>、<many-to-one> 等）的 lazy 和 fetch 属性配置。

1. 一对多与多对多关联（<set> 标签配置）

一对多（如 Customer 到 Order）和多对多（如 Student 到 Course）通过 <set> 标签的 lazy、fetch、batch-size 等属性控制检索策略。

核心属性说明
属性 取值及作用
lazy 控制集合初始化时机： - true（默认）：延迟检索，访问集合时加载； - false：立即检索，加载主对象时同步加载集合； - extra：增强延迟检索，优化 size()/isEmpty() 等方法（仅查计数，不加载全部对象）。
fetch 控制集合加载的 SQL 形式： - select（默认）：通过单独的 SELECT 加载集合； - subselect：通过子查询（IN 语句）批量加载集合； - join：通过左外连接一次性加载主对象和集合（忽略 lazy）。
batch-size 批量加载大小，延迟 / 立即检索时，一次加载 N 个集合元素（减少 SQL 次数），如 batch-size="10"。
（1）立即检索（lazy="false"）

加载主对象时，立即执行 SQL 加载关联集合，可能导致 “加载过多” 问题。

配置示例：

1
2
3
4
5
6
7
8
9
10
<class name="Customer" table="t_customer">
    <id name="id" type="java.lang.Long">...</id>
    <property name="name" column="name"/>
    
    <!-- 一对多关联：立即检索 -->
    <set name="orders" table="t_order" lazy="false" fetch="select">
        <key column="customer_id"/>
        <one-to-many class="Order"/>
    </set>
</class>

行为：
调用 session.get(Customer.class, 1L) 时，执行：

1
2
3
4
-- 加载主对象
SELECT * FROM t_customer WHERE id=1;
-- 立即加载关联集合
SELECT * FROM t_order WHERE customer_id=1;
（2）延迟检索（lazy="true" 或 lazy="extra"）
  • lazy="true"：加载主对象时不加载集合，首次访问集合（如 customer.getOrders().iterator()）时执行 SQL；
  • lazy="extra"：增强版延迟检索，调用 size()/isEmpty() 时仅执行计数查询（SELECT COUNT(*)），不加载全部对象，适合仅需判断集合大小的场景。

配置示例：

1
2
3
4
<set name="orders" table="t_order" lazy="extra" fetch="select" batch-size="5">
    <key column="customer_id"/>
    <one-to-many class="Order"/>
</set>

行为：

1
2
3
Customer customer = session.get(Customer.class, 1L); // 仅加载客户，不加载订单
int size = customer.getOrders().size(); // 执行 SELECT COUNT(*) FROM t_order WHERE customer_id=1
customer.getOrders().iterator(); // 执行 SELECT * FROM t_order WHERE customer_id=1（批量加载5条）
（3）迫切左外连接检索（fetch="join"）

通过左外连接 SQL 一次性加载主对象和关联集合，lazy 属性被忽略（强制立即加载），减少 SQL 次数，但可能加载冗余数据。

配置示例：

1
2
3
4
<set name="orders" table="t_order" fetch="join"> <!-- 忽略lazy，强制左外连接 -->
    <key column="customer_id"/>
    <one-to-many class="Order"/>
</set>

行为：
调用 session.get(Customer.class, 1L) 时，执行单条左外连接 SQL：

1
2
3
SELECT c.*, o.* FROM t_customer c 
LEFT JOIN t_order o ON c.id = o.customer_id 
WHERE c.id=1;

注意：HQL 或 QBC 查询（如 session.createQuery("from Customer").list()）会忽略 fetch="join"，仍采用延迟检索，需通过 fetch 关键字强制连接（如 from Customer c left join fetch c.orders）。

2. 多对一与一对一关联（<many-to-one>/<one-to-one> 标签配置）

多对一（如 Order 到 Customer）和一对一（如 User 到 UserProfile）通过 <many-to-one> 或 <one-to-one> 标签的 lazy 和 fetch 属性配置。

核心属性说明
属性 取值及作用
lazy 控制关联对象初始化时机： - proxy（默认）：延迟检索，返回关联对象的代理； - no-proxy：无代理延迟检索（需字节码增强，较少用）； - false：立即检索，加载当前对象时同步加载关联对象。
fetch 控制关联对象加载的 SQL 形式： - select（默认）：通过单独的 SELECT 加载关联对象； - join：通过左外连接一次性加载当前对象和关联对象（忽略 lazy）。
batch-size 在关联对象的 <class> 标签中配置（如 Customer 的 <class batch-size="5">），批量加载关联对象，减少 SQL 次数。
（1）延迟检索（lazy="proxy"）

加载当前对象时，关联对象返回代理，首次访问关联对象的非 OID 属性时执行 SQL。

配置示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
<!-- Order.hbm.xml 多对一关联 -->
<class name="Order" table="t_order">
    <id name="id" type="java.lang.Long">...</id>
    <property name="orderNo" column="order_no"/>
    
    <many-to-one 
        name="customer" 
        class="Customer" 
        column="customer_id" 
        lazy="proxy"  <!-- 延迟检索（默认） -->
        fetch="select"/>
</class>

<!-- Customer.hbm.xml 配置批量加载 -->
<class name="Customer" table="t_customer" batch-size="5"> <!-- 一次加载5个Customer代理 -->
    ...
</class>

行为：

1
2
3
Order order = session.get(Order.class, 1L); // 加载订单，客户为代理（未执行SQL）
Customer customer = order.getCustomer(); // 仍未执行SQL
System.out.println(customer.getName()); // 执行 SELECT * FROM t_customer WHERE id=?

若同时加载多个 Order 并访问其 Customer，batch-size="5" 会触发批量查询：

1
SELECT * FROM t_customer WHERE id IN (1,2,3,4,5); -- 一次加载5个客户，减少SQL次数
（2）立即检索（lazy="false"）

加载当前对象时，立即执行 SQL 加载关联对象，无代理对象。

配置示例：

1
2
3
4
5
<many-to-one 
    name="customer" 
    class="Customer" 
    column="customer_id" 
    lazy="false"/> <!-- 立即检索 -->

行为：
调用 session.get(Order.class, 1L) 时，执行两条 SQL：

1
2
SELECT * FROM t_order WHERE id=1;
SELECT * FROM t_customer WHERE id=?; -- 立即加载关联客户
（3）迫切左外连接检索（fetch="join"）

通过左外连接 SQL 一次性加载当前对象和关联对象，lazy 属性被忽略。

配置示例：

1
2
3
4
5
<many-to-one 
    name="customer" 
    class="Customer" 
    column="customer_id" 
    fetch="join"/> <!-- 左外连接检索 -->

行为：
调用 session.get(Order.class, 1L) 时，执行单条左外连接 SQL：

1
2
3
SELECT o.*, c.* FROM t_order o 
LEFT JOIN t_customer c ON o.customer_id = c.id 
WHERE o.id=1;

检索策略的性能优化与最佳实践

1. 避免 “N+1 查询” 问题

  • 问题描述：加载 N 个主对象时，若每个主对象的关联集合都触发一次 SQL 查询，共产生 1（加载主对象）+ N（加载集合）次查询，即 “N+1 问题”；
  • 解决方案：
    • 一对多关联：使用 fetch="subselect"（子查询批量加载）或 batch-size（批量加载）；
    • 多对一关联：在关联对象的 <class> 中配置 batch-size，批量加载关联对象。

2. 合理设置 batch-size

  • 一对多：在 <set> 中设置 batch-size="10"（一次加载 10 个集合元素）；
  • 多对一：在关联对象的 <class> 中设置 batch-size="10"（一次加载 10 个关联对象）；
  • 建议值：5~20（根据内存和数据库性能调整，过大可能增加单次查询压力）。

3. 控制连接查询深度

Hibernate 通过 hibernate.max_fetch_depth 配置限制外连接查询的深度（默认值为 2），避免多表连接过深导致的性能下降：

1
2
<!-- hibernate.cfg.xml -->
<property name="hibernate.max_fetch_depth">3</property> <!-- 最大连接深度为3 -->

4. 检索策略选择指南

关联场景 推荐策略 适用场景
一对多（集合） lazy="extra" + fetch="select" + batch-size 集合大且不常访问，或仅需判断大小
一对多（集合） fetch="join"（HQL 需显式 join fetch） 集合小且必访问，减少 SQL 次数
多对一（单对象） lazy="proxy" + fetch="select" + batch-size 关联对象不常访问，批量加载优化
多对一（单对象） fetch="join" 关联对象必访问，且对象小

5. 处理懒加载异常（LazyInitializationException）

  • 原因：Session 关闭后访问延迟加载的代理对象；
  • 解决方案：
    1. 在 Session 关闭前提前初始化关联对象（Hibernate.initialize(customer.getOrders())）；
    2. 使用 “Open Session In View” 模式（Web 应用中延长 Session 至视图渲染完成）；
    3. 改用立即检索或迫切左外连接检索（适合关联对象必用的场景）。

总结

Hibernate 检索策略的核心是平衡 “加载时机” 与 “数据量”，关键在于根据业务场景选择合适的策略：

  • 类级别：默认延迟检索（lazy="true"），load() 方法返回代理，get() 始终立即加载；
  • 关联级别：一对多 / 多对多优先用延迟检索 + 批量加载，多对一 / 一对一优先用代理延迟 + 批量加载，必要时通过连接查询减少 SQL 次数
相关文章

欢迎关注我的其它发布渠道