Hibernate学习笔记 -- day11 Hibernate中的检索策略

一、实体类的检索策略

1、涉及的方法

get：查询时机是立即加载

load：查询时机是延迟加载

二、关联对象的检索策略

1、明确

谁是那个关联对象。

例如：我们根据id查询客户，该客户下的联系人就是关联对象。我们根据id查询联系人，该联系人的所属客户就是关联对象

2、查询的时机

立即加载：不管用不用，只要一调用方法，马上发起查询

延迟加载：什么时候用什么时候去查询

3、应用方式

在一对多和多对多的关系时，我们都采用延迟加载策略。

在多对一和一对一的关系时，我们都采用立即加载策略。

三、对象导航图查询中的检索策略

1、有少的，什么时候去查多的：使用延迟加载（有客户，关联的是联系人）

（1）、问题：我们查询客户时，要不要把联系人查询出来？

（2）、解决方法：用延迟加载的思想。通过配置的方式来设定当我们在需要使用时，发起真正的查询。

2、配置查询机制的方式

注意：注解和XML在一对多的情况下：默认都是延迟加载。

（1）、注解上的使用：fetch=FetchType.LAZY属性

@OneToMany(targetEntity=LinkMan.class,mappedBy="customer",fetch=FetchType.LAZY)
private Set<LinkMan> linkmans = new HashSet<LinkMan>(0);

（2）、XML上的使用：是set标签的属性.lazy="true"

在Customer.hbm.xml配置文件中的set标签上使用lazy属性。取值为true（默认值）|fasle
<set name="linkmans" table="cst_linkman" inverse="true" lazy="true">
	<key column="lkm_cust_id"></key>
	<one-to-many class="LinkMan"/>
</set>

3、有多的，什么时候去查少的：使用立即加载（有联系人，关联的客户）

（1）、问题：我们查询联系人时，要不要把客户查询出来？

（2）、解决方法：采用立即加载的思想。通过配置的方式来设定，只要查询从表实体，就把主表实体对象同时查出来。

4、配置查询机制的方式

注意：注解和XML在多对一的情况下：不一样

（1）、注解方式：默认是立即加载。

        在@OneToMany中使用fetch属性。

        取值FetchType.LAZY延迟加载，FetchType.EAGER

        立即加载使用的方式是左外连接  left outer join

//多对一关系映射：多个联系人对应客户
@ManyToOne(targetEntity=Customer.class,fetch=FetchType.EAGER)
@JoinColumn(name="lkm_cust_id",referencedColumnName="cust_id")
private Customer customer;//用它的主键，对应联系人表中的外键

（2）、XML方式：属性是在many-to-one上，

        lazy属性配置为false的时候，立即加载。

        lazy属性的默认值是proxy，它是看少的一方class标签上的lazy属性取值。

xml的配置方式：
在LinkMan.hbm.xml配置文件中的many-to-one标签上使用lazy属性。取值为proxy|fasle
false:立即加载
proxy：看客户的映射文件class标签的lazy属性取值，如果客户的class标签lazy属性是true
	   那么proxy表示延迟加载，如果是false就表示立即加载。
<many-to-one name="customer" class="Customer" column="lkm_cust_id" lazy="false"/>

四、案例演示

/**
 * hibernate中的检索策略：
 * 涉及的情况：
 * 	  实体类的检索策略：
 * 		查询的方式是OID查询：
 * 			涉及的方法：
 * 				get：查询时机是立即加载
 * 				load：查询时机是延迟加载
 *  关联对象的检索策略：
 *  	明确：谁是那个关联对象。
 *  		举例：我们根据id查询客户，该客户下的联系人就是关联对象
 *  			我们根据id查询联系人，该联系人的所属客户就是关联对象
 *  	解决的就是查询的时机问题：
 *  		立即加载：不管用不用，只要一调用方法，马上发起查询
 *  		延迟加载：什么时候用什么时候去查询
 * 		查询方式就是对象导航查询：
 * 			分为两种情况：
 * 				有少的，什么时候去查多的：使用延迟加载
 * 				有多的，什么时候去查少的：使用立即加载
 * 		配置的方式：
 * 			注解和XML在一对多的情况下：默认都是延迟加载。
 * 				注解上使用：fetch=FetchType.LAZY属性
 * 				XML上使用：是set标签的属性.lazy="true"
 * 			注解和XML在多对一的情况下：不一样
 * 				注解：
 * 					默认是立即加载。使用的方式是左外连接  left outer join
 * 				xml:属性是在many-to-one上
 * 					lazy属性配置为false的时候。立即加载。
 * 					lazy属性的默认值是proxy。
 * 							它是看少的一方class标签上的lazy属性取值。
 * 	
 *
 */
public class HibernateDemo3 {
	
	
	/**
	 * 根据客户对象获取客户下的所有联系人
	 */
	@Test
	public void test1(){
		Session s = HibernateUtil.getCurrentSession();
		Transaction tx = s.beginTransaction();
		Customer c = s.get(Customer.class,1L);
		System.out.println(c);
		System.out.println(c.getLinkmans());//延迟加载
		tx.commit();
	}
	
	/**
	 * 根据联系人对象获取所属客户
	 */
	@Test
	public void test2(){
		Session s = HibernateUtil.getCurrentSession();
		Transaction tx = s.beginTransaction();
		LinkMan l = s.get(LinkMan.class,1L);
		System.out.println(l);
		System.out.println(l.getCustomer());//立即加载
		tx.commit();
	}
}