SSH与SSM学习之hibernate23——关联级别加载策略之集合关联加载策略

SSH与SSM学习之hibernate23关联级别加载策略之集合关联加载策略
一说明

二lazy和fetch的取值

true
false
extra

select
selecttrue
selectfalse

join
jointure
joinfalse

subselect
subselecttrue
subselecttrue

三配置文件 Companyhbmxml

四fetch为select lazy为 true false extra 测试
1 测试代码

2 fetch为select lazy为 true 打印结果

3 fetch为select lazy为 false 打印结果

4 fetch为select lazy为 extra 打印结果

五fetch为join lazy为 true false extra 测试
1 测试代码

2 fetch为join true false extra 打印结果

六fetch为join lazy为 true false extra 测试
1 测试代码

2 fetch为subselect lazy为true 打印结果

3 fetch为subselect lazy为false 打印结果

4 fetch为subselect lazy为extra 打印结果

SSH与SSM学习之hibernate23——关联级别加载策略之集合关联加载策略

一、说明

关联级别加载策略，其实就是在关联查询中，使用lazy和fetch的策略。

比如说我们查询一个公司，然后通过公司查询到员工这就是关联，反之亦然。

这个和我们前面的 类级别加载策略 使用上的区别是：

我们的类级别加载策略使用在 中

然后我们的关联级别是用在设置关联的地方，比如一对多我们用在中。

二、lazy和fetch的取值

lazy叫做懒加载或者延迟加载，取值如下

取值	说明
true(默认值):	延迟加载,懒加载
false:	立即加载
extra:	极其懒惰

fetch（抓取策略），决定加载策略.使用什么类型的sql语句加载集合数据。取值如下

取值	说明
select	(默认值): 单表查询加载
join:	使用多表查询加载集合
subselect:	使用子查询加载集合

下面我们分为二者的属性值两两配对（笛卡尔积）测试

第一行代表，lazy的取值

第一列代表，fetch的取值

true	false	extra
select	select,true	select,false
join	join,ture	join,false
subselect	subselect,true	subselect,true

三、配置文件 Company.hbm.xml

测试的时候，修改的就是 中的 lazy和fetch

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="com.qwm.hibernate03.domain" >
<class name="Company" table="tb_company">
<id name="id">
<generator class="native"></generator>
</id>
<property name="name" ></property>
<!--
lazy属性: 决定是否延迟加载
true(默认值): 延迟加载,懒加载
false: 立即加载
extra: 极其懒惰
fetch属性: 决定加载策略.使用什么类型的sql语句加载集合数据
select(默认值): 单表查询加载
join: 使用多表查询加载集合
subselect:使用子查询加载集合
-->
<!--测试的时候，修改的就是下面 lazy和fetch的值-->
<set name="emps" lazy="true" fetch="select">
<key column="com_id"></key>
<one-to-many class="Employee"></one-to-many>
</set>
</class>
</hibernate-mapping>

四、fetch为select , lazy为 true | false | extra 测试

4.1 测试代码

/**
* 关联级测试，集合关联
* fetch:select
* lazy:true 使用时才加载集合数据
* lazy:false 立即记载集合数据
* lazy:extra 极其懒惰.与懒加载效果基本一致. 如果只获得集合的size.只查询集合的size(count语句)
* 这里测试的是，通过公司查询公司的员工
*/
@Test
public void test3(){
Session session = HibernateUtils.openSession();
Transaction t = session.beginTransaction();
//------------------------------
//获取到公司
Company c = session.get(Company.class,1L);
System.out.println("------------第一个分割线-------------");
//获取这个公司的员工（关联）
Set<Employee> emps = c.getEmps();
System.out.println("------------第二个分割线-------------");
System.out.println(emps.size());
System.out.println("------------第三个分割线-------------");
System.out.println(emps);

//------------------------------
t.commit();
session.close();
}

4.2 fetch为select , lazy为 true 打印结果

Hibernate:
select
company0_.id as id1_0_0_,
company0_.name as name2_0_0_
from
tb_company company0_
where
company0_.id=?
------------第一个分割线-------------
------------第二个分割线-------------
Hibernate:
select
emps0_.com_id as com_id3_1_0_,
emps0_.em_id as em_id1_1_0_,
emps0_.em_id as em_id1_1_1_,
emps0_.name as name2_1_1_,
emps0_.com_id as com_id3_1_1_
from
tb_employee emps0_
where
emps0_.com_id=?
2
------------第三个分割线-------------
[Employee{em_id=2, name='周小龙'}, Employee{em_id=1, name='李晓飞'}]

我们可以看到 fetch为select , lazy为 true 的时候，我们查询公司的时候，只查询了公司的信息，没有查询员工的信息，只有使用员工的集合的时候，采取查询。使用了懒加载。

4.3 fetch为select , lazy为 false 打印结果

Hibernate:
select
company0_.id as id1_0_0_,
company0_.name as name2_0_0_
from
tb_company company0_
where
company0_.id=?
Hibernate:
select
emps0_.com_id as com_id3_1_0_,
emps0_.em_id as em_id1_1_0_,
emps0_.em_id as em_id1_1_1_,
emps0_.name as name2_1_1_,
emps0_.com_id as com_id3_1_1_
from
tb_employee emps0_
where
emps0_.com_id=?
------------第一个分割线-------------
------------第二个分割线-------------
2
------------第三个分割线-------------
[Employee{em_id=2, name='周小龙'}, Employee{em_id=1, name='李晓飞'}]

fetch为select , lazy为 false ，不使用懒加载，会直接加载数据。

4.4 fetch为select , lazy为 extra 打印结果

Hibernate:
select
company0_.id as id1_0_0_,
company0_.name as name2_0_0_
from
tb_company company0_
where
company0_.id=?
------------第一个分割线-------------
------------第二个分割线-------------
Hibernate:
select
count(em_id)
from
tb_employee
where
com_id =?
2
------------第三个分割线-------------
Hibernate:
select
emps0_.com_id as com_id3_1_0_,
emps0_.em_id as em_id1_1_0_,
emps0_.em_id as em_id1_1_1_,
emps0_.name as name2_1_1_,
emps0_.com_id as com_id3_1_1_
from
tb_employee emps0_
where
emps0_.com_id=?
[Employee{em_id=2, name='周小龙'}, Employee{em_id=1, name='李晓飞'}]

fetch为select , lazy为 extra，极其懒惰.与懒加载效果基本一致. 如果只获得集合的size.只查询集合的size(count语句)

五、fetch为join , lazy为 true | false | extra 测试

5.1 测试代码

/**
* 关联级测试，集合关联
* fetch:join
* lazy:true|false|extra 失效，都是立即查询
* 这里测试的是，通过公司查询公司的员工
*/
@Test
public void test4(){
Session session = HibernateUtils.openSession();
Transaction t = session.beginTransaction();
//------------------------------
//获取到公司
Company c = session.get(Company.class,1L);
System.out.println("------------第一个分割线-------------");
//获取这个公司的员工（关联）
Set<Employee> emps = c.getEmps();
System.out.println("------------第二个分割线-------------");
System.out.println(emps.size());
System.out.println("------------第三个分割线-------------");
System.out.println(emps);

//------------------------------
t.commit();
session.close();
}

5.2 fetch为join , true | false | extra 打印结果

Hibernate:
select
company0_.id as id1_0_0_,
company0_.name as name2_0_0_,
emps1_.com_id as com_id3_1_1_,
emps1_.em_id as em_id1_1_1_,
emps1_.em_id as em_id1_1_2_,
emps1_.name as name2_1_2_,
emps1_.com_id as com_id3_1_2_
from
tb_company company0_
left outer join
tb_employee emps1_
on company0_.id=emps1_.com_id
where
company0_.id=?
------------第一个分割线-------------
------------第二个分割线-------------
2
------------第三个分割线-------------
[Employee{em_id=1, name='李晓飞'}, Employee{em_id=2, name='周小龙'}]

fetch使用join的情况下，lazy失效，都是直接加载数据。

六、fetch为join , lazy为 true | false | extra 测试

6.1 测试代码

6.2 fetch为subselect , lazy为true 打印结果

Hibernate:
select
company0_.id as id1_0_,
company0_.name as name2_0_
from
tb_company company0_
------------第一个分割线-------------
------------第二个分割线-------------
Company{id=1, name='百鸟公司'}
------------第三个分割线-------------
Hibernate:
select
emps0_.com_id as com_id3_1_1_,
emps0_.em_id as em_id1_1_1_,
emps0_.em_id as em_id1_1_0_,
emps0_.name as name2_1_0_,
emps0_.com_id as com_id3_1_0_
from
tb_employee emps0_
where
emps0_.com_id in (
select
company0_.id
from
tb_company company0_
)
2
------------第四个分割线-------------
[Employee{em_id=1, name='李晓飞'}, Employee{em_id=2, name='周小龙'}]

fetch为subselect , lazy为true ，首先会查询出公司的信息，不会查询员工信息。使用的员工集合的时候，会使用子查询查询出员工信息。

6.3 fetch为subselect , lazy为false 打印结果

Hibernate:
select
company0_.id as id1_0_,
company0_.name as name2_0_
from
tb_company company0_
Hibernate:
select
emps0_.com_id as com_id3_1_1_,
emps0_.em_id as em_id1_1_1_,
emps0_.em_id as em_id1_1_0_,
emps0_.name as name2_1_0_,
emps0_.com_id as com_id3_1_0_
from
tb_employee emps0_
where
emps0_.com_id in (
select
company0_.id
from
tb_company company0_
)
------------第一个分割线-------------
------------第二个分割线-------------
Company{id=1, name='百鸟公司'}
------------第三个分割线-------------
2
------------第四个分割线-------------
[Employee{em_id=1, name='李晓飞'}, Employee{em_id=2, name='周小龙'}]

fetch为subselect , lazy为false 。直接加载。首先使用查询出公司信息，然后通过子查询，查询出员工信息。

6.4 fetch为subselect , lazy为extra 打印结果

Hibernate:
select
company0_.id as id1_0_,
company0_.name as name2_0_
from
tb_company company0_
------------第一个分割线-------------
------------第二个分割线-------------
Company{id=1, name='百鸟公司'}
------------第三个分割线-------------
Hibernate:
select
count(em_id)
from
tb_employee
where
com_id =?
2
------------第四个分割线-------------
Hibernate:
select
emps0_.com_id as com_id3_1_1_,
emps0_.em_id as em_id1_1_1_,
emps0_.em_id as em_id1_1_0_,
emps0_.name as name2_1_0_,
emps0_.com_id as com_id3_1_0_
from
tb_employee emps0_
where
emps0_.com_id in (
select
company0_.id
from
tb_company company0_
)
[Employee{em_id=1, name='李晓飞'}, Employee{em_id=2, name='周小龙'}]

fetch为subselect , lazy为extra ，首先会查询出公司的信息，不会查询员工信息。使用的员工集合的时候，如果只是使用到size(),那么会使用count() 查询出个数。使用到员工集合的时候，会使用子查询查询出员工信息。