hibernate学习笔记16--一对一实现懒加载

 一对一的懒加载分析：

test.java

还是使用先前那个Person和IdCard的一对一例子例子

[java] view plain copy print ?

1. import hibernate.HibernateUtil;  
2.   
3. import java.util.Date;  
4.   
5. import org.hibernate.Hibernate;  
6. import org.hibernate.Session;  
7.   
8. import domain.IdCard;  
9. import domain.Person;  
10.   
11.   
12.   
13.   
14. public class test {  
15.   
16.     /** 
17.      * @param args 
18.      */  
19.     public static void main(String[] args) {  
20.         Person person = new Person();  
21.         person.setName("pf");  
22.           
23.         IdCard idCard = new IdCard();  
24.         idCard.setUsefulLife(new Date());  
25.           
26.         idCard.setPerson(person);  
27.         person.setIdCard(idCard);  
28.         HibernateUtil.add(person);  
29.         HibernateUtil.add(idCard);  
30.           
31.           
32.         HibernateUtil.get(Person.class, 1);  
33.           
34.           
35.     }  
36.       
37. }  

import hibernate.HibernateUtil; import java.util.Date; import org.hibernate.Hibernate; import org.hibernate.Session; import domain.IdCard; import domain.Person; public class test { /** * @param args */ public static void main(String[] args) { Person person = new Person(); person.setName("pf"); IdCard idCard = new IdCard(); idCard.setUsefulLife(new Date()); idCard.setPerson(person); person.setIdCard(idCard); HibernateUtil.add(person); HibernateUtil.add(idCard); HibernateUtil.get(Person.class, 1); } }

 

 

 

Hibernate: select person0_.id as id5_1_, person0_.name as name5_1_, idcard1_.id as id6_0_, idcard1_.userful_life as userful2_6_0_, idcard1_.person_id as person3_6_0_ from Person person0_ left outer join id_card idcard1_ on person0_.id=idcard1_.person_id where person0_.id=?

 

可以看到Hibernate在查询主对象的时候做了一个连接查询，而在查询身份证时候，缺只做了单表查询

Hibernate: select idcard0_.id as id6_0_, idcard0_.userful_life as userful2_6_0_, idcard0_.person_id as person3_6_0_ from id_card idcard0_ where idcard0_.id=?
从对象实际上是采用了懒加载

 

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="cn.itcast.domain">
	<class name="IdCard" table="id_Card">
		<!-- 对象标示符，类型可以不写，hibernate自己识别 -->
		<id name="id" column="id">
			<!-- 指定主键生成方式。
        native根据方言判定生成主键的方式
         -->
         	<!-- 
			 <generator class="foreign">
			 -->
			   <generator class="native">
			 <!-- id通过一个外键数据获得 -->
			<!--  <param name="property">person</param>-->
			 </generator> 
		</id>
		
		<property name="usefulLife" column="useful_Life" />
		<!-- 表示一对一的关系 ：对person属性进行映射。constrained="true" 添加约束，让id有外键关联-->
		<one-to-one name="person"  constrained="true" lazy="proxy" fetch="select" /> 
	</class>


</hibernate-mapping>

one-to-one懒加载条件：

1.lazy!=false

2.constrained=true

3.fetch=select

由于主表没有constrained属性，所以主表没有懒加载机制，只有从表有懒加载机制。

 

fetch改为join的时候，查从对象IdCard的时候也会查找Person信息

 

缺省情况lazy=propy fetch=select，这两个条件一个是访问数据库的时机，一个是访问数据库的方式。

 小结：

一对一在缺省的情况下，查询主对象时使用左连接关联的查询方法。
查询从对象（不访问主对象属性）时，不适用关联查询，使用懒加载。
主对象不使用懒加载，从对象使用懒加载。
默认都是 约束等于true就是在从对象中建立外键关系
刷新方式为select
lazy何时抓取， fetch抓取方式
fetch="join"使用关联查询他
fetch="select"使用两条select
lazy="false"不是懒加载，立刻加载他。无论访问不访问从对象中的主对象属性，都会查出来
lazy="proxy"缺省时，使用代理，在不访问从对象中的主对象属性时，不会查询主对象的。
当fetch="join"时，lazy懒加载则失效。