延迟加载：延迟加载（lazy load懒加载）是当在真正需要数据时，才执行SQL语句进行查询，避免了无谓的性能开销。
延迟加载分类：
01.类级别的查询策略
02.一对多和多对多关联的查询策略
03.多对一关联的查询策略
类级别的查询策略
1.类级别可选的检索策略包括立即检索和延迟检索，默认为延迟检索
1.1立即检索：立即加载检索方法指定的对象,立即发送SQL
1.2 延迟检索：延迟加载检索方法制定的对象.在使用具体的属性时，再进行加载，才发送SQL
2.无论<class>元素的lazy属性是true还是false，Session的get()方法及Query的list()方法在类级别总是使用立即检索策略
3.若<class>元素的lazy属性为true或默认值，Session的load()方法不会执行查询数据库表的SELECT语句，仅返回代理类对象的实例，该代理类实例有如下特征：
3.1 由Hibernate在运行时采用CGLIB工具动态生成
3.2 Hibernate创建代理类实例时，仅初始化其OID属性
3.3在应用程序第一次访问代理类实例的非OID属性时，Hibernate会初始化代理类实例
3.4注意：类级别检索策略仅适用于load()方法
1.创建持久化类
public class Student {
private int id;
private String name;
private int age;
private String address;
private String phone;
public int getId() {
return id;
}
public void setId(int 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 String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
public String getPhone() {
return phone;
}
public void setPhone(String phone) {
this.phone = phone;
}
}
2.创建Student.hbm.xml配置文件
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<!-- 映射文件开始 -->
<hibernate-mapping package="cn.day05lazy.entity">
<!--表名称-->
<class name="Student" table="STUDENT" schema="root" lazy="true">
<!--列名-->
<id name="id" column="ID">
<!--主键生成的策略 native：自动生成主键字段-->
<generator class="native"></generator>
</id>
<property name="name" column="NAME"></property>
<property name="age" column="AGE"></property>
<property name="address" column="ADDRESS"></property>
<property name="phone" column="PHONE"></property>
</class>
</hibernate-mapping>
3.创建hibernate.cfg.xml大配置文件
<?xml version="1.0" encoding="UTF-8"?>
<!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="connection.driver_class">oracle.jdbc.driver.OracleDriver</property>
<!-- 指定数据库链接的url，hibernate链接的数据库名 -->
<property name="connection.url">jdbc:oracle:thin:@localhost:1521:orcl</property>
<!-- 指定连接数据库的用户名 -->
<property name="connection.username">root</property>
<!-- 指定连接数据库的用户口令 -->
<property name="connection.password">root</property>
<!-- Enable Hibernate's automatic session context management -->
<property name="current_session_context_class">thread</property>
<!--格式化sql -->
<property name="format_sql ">true</property>
<!-- 打印sql 控制台-->
<property name="show_sql">true</property>
<!-- 指定数据库方言 -->
<property name="dialect">org.hibernate.dialect.Oracle10gDialect</property>
<!-- 根据需要自动创建数据库表 -->
<property name="hbm2ddl.auto">update</property>
<!--延迟加载-->
<mapping resource="cn/day05lazy/entity/Student.hbm.xml"></mapping>
</session-factory>
</hibernate-configuration>
Lazy设置为true
Load()方法测试结果：
@Test
public void test(){
Session session = HibernateUtil.getSession();
Student load = session.load(Student.class, 1);
}
Get()方法测试结果：
//类级别延迟加载
@Test
public void test(){
Session session = HibernateUtil.getSession();
Student load = session.get(Student.class, 1);
}
如果将lazy设置为false，则load()方法的延迟加载取消
//类级别延迟加载
@Test
public void test(){
Session session = HibernateUtil.getSession();
Student load = session.load(Student.class, 1);
}
一对多和多对多关联的查询策略
在映射文件中，用<set>元素来配置一对多关联及多对多关联关系。<set>元素有lazy和fetch属性
-lazy：主要决定Emps集合被初始化的时机。即到底是在加载Dept对象时就被初始化，还是在程序访问Emps集合时被初始化
01.一对多或者多对多检索策略由lazy和fetch共同确定
Lazy：决定关联对象初始化时机
Fetch：决定SQL语句构建形式
02.fetch取值
Join：迫切左外连接
Select：多条简单SQL（默认值）
Subselect：子查询
03.fetch和lazy组合
解析：fetch=”join” lazy会被忽略，迫切左外连接的立即检索
Fetch=”select” lazy=”false” 多条简单SQL立即检索
Fetch=”select” lazy=”true” 多条语句延迟检索
Fetch=”select” lazy=”extra” 多条语句及其懒惰检索
Fetch=”subselect” lazy=”false” 子查询立即检索
Fetch=”subselect” lazy=”true” 子查询延迟检索
Fetch=”subselect” lazy=”extra” 子查询及其懒惰检索
Extra:极其懒惰，只有访问集合对象的属性时才会加载，访问集合本身的属性时（例如，集合大小，生成count），不会立即加载。
注意：query的list()会忽略映射文件配置的左外连接查询，此时lazy属性重新生效。
一对多延迟加载测试
Lazy设置为true时
核心代码：
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<!-- 映射文件开始 -->
<hibernate-mapping package="cn.day04mapping.onetomany.entity">
<!--表名称-->
<class name="Dept" table="DEPT" schema="root">
<!--列名-->
<id name="deptid" column="DEPTID">
<!--主键生成的策略 native：自动生成主键字段-->
<generator class="native"></generator>
</id>
<property name="deptname" column="DEPTNAME"></property>
<!--植入set 标签 save-update 保存数据 inverse 消除多余的update语句-->
<set name="emps" cascade="save-update" inverse="true" order-by="empno desc" lazy="true">
<!--多的一方表的外键列-->
<key column="deptno"></key>
<one-to-many class="Emp"></one-to-many>
</set>
</class>
</hibernate-mapping>
//一对多
@Test
public void test01(){
Session session = cn.day04mapping.onetomany.util.HibernateUtil.getSession();
Dept dept = session.get(Dept.class, 24);
//Set<Emp> emps = dept.getEmps();
}
Lazy设置为false
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<!-- 映射文件开始 -->
<hibernate-mapping package="cn.day04mapping.onetomany.entity">
<!--表名称-->
<class name="Dept" table="DEPT" schema="root">
<!--列名-->
<id name="deptid" column="DEPTID">
<!--主键生成的策略 native：自动生成主键字段-->
<generator class="native"></generator>
</id>
<property name="deptname" column="DEPTNAME"></property>
<!--植入set 标签 save-update 保存数据 inverse 消除多余的update语句-->
<set name="emps" cascade="save-update" inverse="true" order-by="empno desc" lazy="false">
<!--多的一方表的外键列-->
<key column="deptno"></key>
<one-to-many class="Emp"></one-to-many>
</set>
</class>
</hibernate-mapping>
//一对多
@Test
public void test01(){
Session session = cn.day04mapping.onetomany.util.HibernateUtil.getSession();
Dept dept = session.get(Dept.class, 24);
//Set<Emp> emps = dept.getEmps();
}
Lazy设置为extra
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<!-- 映射文件开始 -->
<hibernate-mapping package="cn.day04mapping.onetomany.entity">
<!--表名称-->
<class name="Dept" table="DEPT" schema="root">
<!--列名-->
<id name="deptid" column="DEPTID">
<!--主键生成的策略 native：自动生成主键字段-->
<generator class="native"></generator>
</id>
<property name="deptname" column="DEPTNAME"></property>
<!--植入set 标签 save-update 保存数据 inverse 消除多余的update语句-->
<set name="emps" cascade="save-update" inverse="true" order-by="empno desc" lazy="extra">
<!--多的一方表的外键列-->
<key column="deptno"></key>
<one-to-many class="Emp"></one-to-many>
</set>
</class>
</hibernate-mapping>
//一对多
@Test
public void test01(){
Session session = cn.day04mapping.onetomany.util.HibernateUtil.getSession();
Dept dept = session.get(Dept.class, 24);
//Set<Emp> emps = dept.getEmps();
}
//一对多
@Test
public void test01(){
Session session = cn.day04mapping.onetomany.util.HibernateUtil.getSession();
Dept dept = session.get(Dept.class, 24);
Set<Emp> emps = dept.getEmps();
emps.size();
}
多对一关联的查询策略
Lazy设置为false
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<!-- 映射文件开始 -->
<hibernate-mapping package="cn.day04mapping.manytoone.entity">
<!--name:表名称 schema 操作数据库的用户名-->
<class name="Emp" table="EMP" schema="root">
<!--列名-->
<id name="empno" column="EMPNO">
<!--主键生成的策略 native：自动生成主键字段-->
<generator class="native"></generator>
</id>
<property name="ename" column="ENAME"></property>
<!--多对一 单向关联
员工是多的一方
name：Emp中植入一方的属性名称
column;数据库中外键列的值
class：植入一方的属性的类型
-->
<many-to-one name="dept" column="deptno" class="Dept" lazy="false"></many-to-one>
</class>
</hibernate-mapping>
//多对一
@Test
public void test03(){
Session session = cn.day04mapping.manytoone.util.HibernateUtil.getSession();
cn.day04mapping.manytoone.entity.Emp emp = session.get(cn.day04mapping.manytoone.entity.Emp.class, 1);
}
Lazy设置为proxy
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<!-- 映射文件开始 -->
<hibernate-mapping package="cn.day04mapping.manytoone.entity">
<!--name:表名称 schema 操作数据库的用户名-->
<class name="Emp" table="EMP" schema="root">
<!--列名-->
<id name="empno" column="EMPNO">
<!--主键生成的策略 native：自动生成主键字段-->
<generator class="native"></generator>
</id>
<property name="ename" column="ENAME"></property>
<!--多对一 单向关联
员工是多的一方
name：Emp中植入一方的属性名称
column;数据库中外键列的值
class：植入一方的属性的类型
-->
<many-to-one name="dept" column="deptno" class="Dept" lazy="proxy"></many-to-one>
</class>
</hibernate-mapping>
//多对一
@Test
public void test03(){
Session session = cn.day04mapping.manytoone.util.HibernateUtil.getSession();
cn.day04mapping.manytoone.entity.Emp emp = session.get(cn.day04mapping.manytoone.entity.Emp.class, 1);
}
Lazy设置为no-proxy
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<!-- 映射文件开始 -->
<hibernate-mapping package="cn.day04mapping.manytoone.entity">
<!--name:表名称 schema 操作数据库的用户名-->
<class name="Emp" table="EMP" schema="root">
<!--列名-->
<id name="empno" column="EMPNO">
<!--主键生成的策略 native：自动生成主键字段-->
<generator class="native"></generator>
</id>
<property name="ename" column="ENAME"></property>
<!--多对一 单向关联
员工是多的一方
name：Emp中植入一方的属性名称
column;数据库中外键列的值
class：植入一方的属性的类型
-->
<many-to-one name="dept" column="deptno" class="Dept" lazy="no-proxy"></many-to-one>
</class>
</hibernate-mapping>
//多对一
@Test
public void test03(){
Session session = cn.day04mapping.manytoone.util.HibernateUtil.getSession();
cn.day04mapping.manytoone.entity.Emp emp = session.get(cn.day04mapping.manytoone.entity.Emp.class, 1);
// emp.getDept();
}
有关延迟加载就讲到这里。