hibernate中lazy的使用

lazy，延迟加载

Lazy的有效期：只有在session打开的时候才有效；session关闭后lazy就没效了。

lazy策略可以用在：

* <class>标签上：可以取值true/false

* <property>标签上，可以取值true/false，这个特性需要类增强

* <set>/<list>等集合上，可以取值为true/false/extra

* <one-to-one>/<many-to-one>等标签上，可以取值false/proxy/no-proxy

6.1 get和load的区别：

* get不支持延迟加载，而load支持。

* 当查询特定的数据库中不存在的数据时，get会返回null，而load则抛出异常。

6.2 类(Class)的延迟加载：

* 设置<class>标签中的lazy="true",或是保持默认（即不配置lazy属性)

* 如果lazy的属性值为true，那么在使用load方法加载数据时，只有确实用到数据的时候才会发出sql语句；这样有可能减少系统的开销。

* //不会发出查询sql

       System.out.println("group id=" + group.getId());

这里有一个问题，为什么加载主键的时候不需要发出sql语句。

6.3 集合(collection)的延迟加载：可以取值true，false，extra

* 保持集合上的lazy的默认值，此时的效果和lazy="extra"是基本一样的。

   * 设置集合上的lazy=extra,此时的效果和lazy属性的默认值是基本一样的。但是推荐使用这个属性值，因为在统计时这种情况显得比较智能。当然延迟是有效果的。

* 设置集合上的lazy=false

true:默认取值，它的意思是只有在调用这个集合获取里面的元素对象时，才发出查询语句，加载其集合元素的数据

false:取消懒加载特性，即在加载对象的同时，就发出第二条查询语句加载其关联集合的数据

extra:一种比较聪明的懒加载策略，即调用集合的size/contains等方法的时候，hibernate

并不会去加载整个集合的数据，而是发出一条聪明的SQL语句，以便获得需要的值，只有在真正需要用到这些集合元素对象数据的时候，才去发出查询语句加载所有对象的数据

6.4 Hibernate单端关联懒加载策略：即在<one-to-one>/<many-to-one>标签上可以配置

懒加载策略。可以取值为：false/proxy/no-proxy

false:取消懒加载策略，即在加载对象的同时，发出查询语句，加载其关联对象

proxy:这是hibernate对单端关联的默认懒加载策略，即只有在调用到其关联对象的方法的时候才真正发出查询语句查询其对象数据，其关联对象是代理类

no-proxy:这种懒加载特性需要对类进行增强，使用no-proxy，其关联对象不是代理类

注意：在class标签上配置的lazy属性不会影响到关联对象!!!

 

Java代码

1. <hibernate-mapping>   
2.     <class name="com.bjsxt.hibernate.Group" table="t_group">   
3.         <id name="id">   
4.             <generator class="native"/>   
5.         </id>   
6.         <property name="name"/>   
7.     </class>   
8. </hibernate-mapping>    

<hibernate-mapping>
	<class name="com.bjsxt.hibernate.Group" table="t_group">
		<id name="id">
			<generator class="native"/>
		</id>
		<property name="name"/>
	</class>
</hibernate-mapping>	

Java代码

1. package com.bjsxt.hibernate;   
2. import org.hibernate.Session;   
3.   
4. import com.bjsxt.hibernate.Group;   
5. import com.bjsxt.hibernate.HibernateUtils;   
6.   
7.   
8. public class InitData {   
9.   
10.     public static void main(String[] args) {   
11.         Session session = null;   
12.         try {   
13.             session = HibernateUtils.getSession();   
14.             session.beginTransaction();   
15.             Group group = new Group();   
16.             group.setName("java开发组");   
17.             session.save(group);   
18.             session.getTransaction().commit();   
19.         }catch(Exception e) {   
20.             e.printStackTrace();   
21.             session.getTransaction().rollback();   
22.         }finally {   
23.             HibernateUtils.closeSession(session);   
24.         }      
25.     }   
26.   
27. }  

package com.bjsxt.hibernate;
import org.hibernate.Session;

import com.bjsxt.hibernate.Group;
import com.bjsxt.hibernate.HibernateUtils;


public class InitData {

	public static void main(String[] args) {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			session.beginTransaction();
			Group group = new Group();
			group.setName("java开发组");
			session.save(group);
			session.getTransaction().commit();
		}catch(Exception e) {
			e.printStackTrace();
			session.getTransaction().rollback();
		}finally {
			HibernateUtils.closeSession(session);
		}	
	}

}

 

Java代码

1.   
2. package com.bjsxt.hibernate;   
3.   
4. import org.hibernate.Session;   
5.   
6. import junit.framework.TestCase;   
7.   
8. /**  
9.  * 运行本单元测试的前提条件：  
10.  * 设置<class>标签中的lazy="true",或是保持默认（即不配置lazy属性)  
11.  *   
12.  * @author Administrator  
13.  *  
14.  */  
15. public class ClassLazyTest extends TestCase {   
16.   
17.     public void testLoadGroup1() {   
18.         Session session = null;   
19.         try {   
20.             session = HibernateUtils.getSession();   
21.                
22.             //不会发出查询sql   
23.             Group group = (Group)session.load(Group.class, 1);   
24.                
25.             //不会发出查询sql   
26.             System.out.println("group id=" + group.getId());   
27.                
28.             //发出查询sql，加载数据到Group   
29.             System.out.println("group name=" + group.getName());   
30.                
31.             //不会发出查询sql   
32.             System.out.println("group name=" + group.getName());   
33.         }catch(Exception e) {   
34.             e.printStackTrace();   
35.         }finally {   
36.             HibernateUtils.closeSession(session);   
37.         }      
38.     }   
39.   
40.     public void testLoadGroup2() {   
41.         Session session = null;   
42.         Group group = null;   
43.         try {   
44.             session = HibernateUtils.getSession();   
45.                
46.             //不会发出查询sql   
47.             group = (Group)session.load(Group.class, 1);   
48.                
49.         }catch(Exception e) {   
50.             e.printStackTrace();   
51.         }finally {   
52.             HibernateUtils.closeSession(session);   
53.         }   
54.         //不能正常输出，抛出了 LazyInitializationException，因为session已经关闭了   
55.         //注意：Hibernate支持Lazy策略，只有session打开状态才有效        
56.         System.out.println("group name=" + group.getName());   
57.            
58.     }   
59.        
60.        
61. }  

package com.bjsxt.hibernate;

import org.hibernate.Session;

import junit.framework.TestCase;

/**
 * 运行本单元测试的前提条件：
 * 设置<class>标签中的lazy="true",或是保持默认（即不配置lazy属性)
 * 
 * @author Administrator
 *
 */
public class ClassLazyTest extends TestCase {

	public void testLoadGroup1() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			
			//不会发出查询sql
			Group group = (Group)session.load(Group.class, 1);
			
			//不会发出查询sql
			System.out.println("group id=" + group.getId());
			
			//发出查询sql，加载数据到Group
			System.out.println("group name=" + group.getName());
			
			//不会发出查询sql
			System.out.println("group name=" + group.getName());
		}catch(Exception e) {
			e.printStackTrace();
		}finally {
			HibernateUtils.closeSession(session);
		}	
	}

	public void testLoadGroup2() {
		Session session = null;
		Group group = null;
		try {
			session = HibernateUtils.getSession();
			
			//不会发出查询sql
			group = (Group)session.load(Group.class, 1);
			
		}catch(Exception e) {
			e.printStackTrace();
		}finally {
			HibernateUtils.closeSession(session);
		}
		//不能正常输出，抛出了 LazyInitializationException，因为session已经关闭了
		//注意：Hibernate支持Lazy策略，只有session打开状态才有效		
		System.out.println("group name=" + group.getName());
		
	}
	
	
}

---------------------------------------------------------------------
集合类测试

Java代码

1. <hibernate-mapping>   
2.     <class name="com.bjsxt.hibernate.Classes" table="t_classes">   
3.         <id name="id">   
4.             <generator class="native"/>   
5.         </id>   
6.         <property name="name"/>   
7.         <!--    
8.             <set name="students" cascade="all" order-by="id">   
9.          -->   
10.          <set name="students" lazy="extra">   
11.             <key column="classid"/>   
12.             <one-to-many class="com.bjsxt.hibernate.Student"/>   
13.         </set>   
14.     </class>   
15. </hibernate-mapping>   
16.   
17. <hibernate-mapping>   
18.     <class name="com.bjsxt.hibernate.Student" table="t_student">   
19.         <id name="id">   
20.             <generator class="native"/>   
21.         </id>   
22.         <property name="name"/>   
23.     </class>   
24. </hibernate-mapping>  

<hibernate-mapping>
	<class name="com.bjsxt.hibernate.Classes" table="t_classes">
		<id name="id">
			<generator class="native"/>
		</id>
		<property name="name"/>
		<!-- 
			<set name="students" cascade="all" order-by="id">
		 -->
		 <set name="students" lazy="extra">
			<key column="classid"/>
			<one-to-many class="com.bjsxt.hibernate.Student"/>
		</set>
	</class>
</hibernate-mapping>

<hibernate-mapping>
	<class name="com.bjsxt.hibernate.Student" table="t_student">
		<id name="id">
			<generator class="native"/>
		</id>
		<property name="name"/>
	</class>
</hibernate-mapping>

Java代码

1. package com.bjsxt.hibernate;   
2.   
3. import java.util.Iterator;   
4. import java.util.Set;   
5.   
6. import org.hibernate.Session;   
7.   
8. import junit.framework.TestCase;   
9.   
10. /**  
11.  * 保持lazy的默认值  
12.  * @author Administrator  
13.  *  
14.  */  
15. public class CollectionLazyTest1 extends TestCase {   
16.        
17.     public void testLoadClasses1() {   
18.         Session session = null;   
19.         try {   
20.             session = HibernateUtils.getSession();   
21.                
22.             //不会发出查询sql   
23.             Classes classes = (Classes)session.load(Classes.class, 1);   
24.                
25.             //会发出一条查询sql，加载数据到classes   
26.             System.out.println("班级：【" + classes.getName() + "】  拥有的学生：");   
27.                
28.             //不会发出查询sql   
29.             Set students = classes.getStudents();   
30.                
31.             //会发出一条查询sql，加载数据到Students   
32.             for (Iterator iter = students.iterator(); iter.hasNext();) {   
33.                 Student student = (Student)iter.next();   
34.                 System.out.println(student.getName());   
35.             }   
36.         }catch(Exception e) {   
37.             e.printStackTrace();   
38.         }finally {   
39.             HibernateUtils.closeSession(session);   
40.         }      
41.     }   
42.        
43.     public void testLoadClasses2() {   
44.         Session session = null;   
45.         try {   
46.             session = HibernateUtils.getSession();   
47.                
48.             //不会发出查询sql   
49.             Classes classes = (Classes)session.load(Classes.class, 1);   
50.                
51.             //会发出一条查询sql，加载数据到classes   
52.             System.out.println("班级：【" + classes.getName() + "】  拥有的学生总数：");   
53.   
54.             //不会发出查询sql    
55.             Set students = classes.getStudents();   
56.                
57.             //会发出一条查询sql，加载全部的数据到Students   
58.             System.out.println(students.size());   
59.                
60.         }catch(Exception e) {   
61.             e.printStackTrace();   
62.         }finally {   
63.             HibernateUtils.closeSession(session);   
64.         }      
65.     }   
66.        
67. }  

package com.bjsxt.hibernate;

import java.util.Iterator;
import java.util.Set;

import org.hibernate.Session;

import junit.framework.TestCase;

/**
 * 保持lazy的默认值
 * @author Administrator
 *
 */
public class CollectionLazyTest1 extends TestCase {
	
	public void testLoadClasses1() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			
			//不会发出查询sql
			Classes classes = (Classes)session.load(Classes.class, 1);
			
			//会发出一条查询sql，加载数据到classes
			System.out.println("班级：【" + classes.getName() + "】  拥有的学生：");
			
			//不会发出查询sql
			Set students = classes.getStudents();
			
			//会发出一条查询sql，加载数据到Students
			for (Iterator iter = students.iterator(); iter.hasNext();) {
				Student student = (Student)iter.next();
				System.out.println(student.getName());
			}
		}catch(Exception e) {
			e.printStackTrace();
		}finally {
			HibernateUtils.closeSession(session);
		}	
	}
	
	public void testLoadClasses2() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			
			//不会发出查询sql
			Classes classes = (Classes)session.load(Classes.class, 1);
			
			//会发出一条查询sql，加载数据到classes
			System.out.println("班级：【" + classes.getName() + "】  拥有的学生总数：");

			//不会发出查询sql	
			Set students = classes.getStudents();
			
			//会发出一条查询sql，加载全部的数据到Students
			System.out.println(students.size());
			
		}catch(Exception e) {
			e.printStackTrace();
		}finally {
			HibernateUtils.closeSession(session);
		}	
	}
	
}

Java代码

1. package com.bjsxt.hibernate;   
2.   
3. import java.util.Iterator;   
4. import java.util.Set;   
5.   
6. import org.hibernate.Session;   
7.   
8. import junit.framework.TestCase;   
9.   
10. /**  
11.  * 设置集合上的lazy=false  
12.  * @author Administrator  
13.  *  
14.  */  
15. public class CollectionLazyTest2 extends TestCase {   
16.        
17.     public void testLoadClasses1() {   
18.         Session session = null;   
19.         try {   
20.             session = HibernateUtils.getSession();   
21.                
22.             //不会发出查询sql   
23.             Classes classes = (Classes)session.load(Classes.class, 1);   
24.                
25.             //会发出两条查询sql，加载数据到classes和Students中   
26.             System.out.println("班级：【" + classes.getName() + "】  拥有的学生：");   
27.                
28.             //不会发出查询sql   
29.             Set students = classes.getStudents();   
30.                
31.             //不会发出查询sql   
32.             for (Iterator iter = students.iterator(); iter.hasNext();) {   
33.                 Student student = (Student)iter.next();   
34.                 System.out.println(student.getName());   
35.             }   
36.         }catch(Exception e) {   
37.             e.printStackTrace();   
38.         }finally {   
39.             HibernateUtils.closeSession(session);   
40.         }      
41.     }   
42.        
43.     public void testLoadClasses2() {   
44.         Session session = null;   
45.         try {   
46.             session = HibernateUtils.getSession();   
47.                
48.             //不会发出查询sql   
49.             Classes classes = (Classes)session.load(Classes.class, 1);   
50.                
51.             //会发出两条查询sql，加载数据到classes和Students中   
52.             System.out.println("班级：【" + classes.getName() + "】  拥有的学生总数：");   
53.   
54.             //不会发出查询sql    
55.             Set students = classes.getStudents();   
56.                
57.             //不会发出查询sql    
58.             System.out.println(students.size());   
59.                
60.         }catch(Exception e) {   
61.             e.printStackTrace();   
62.         }finally {   
63.             HibernateUtils.closeSession(session);   
64.         }      
65.     }   
66.        
67. }  

package com.bjsxt.hibernate;

import java.util.Iterator;
import java.util.Set;

import org.hibernate.Session;

import junit.framework.TestCase;

/**
 * 设置集合上的lazy=false
 * @author Administrator
 *
 */
public class CollectionLazyTest2 extends TestCase {
	
	public void testLoadClasses1() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			
			//不会发出查询sql
			Classes classes = (Classes)session.load(Classes.class, 1);
			
			//会发出两条查询sql，加载数据到classes和Students中
			System.out.println("班级：【" + classes.getName() + "】  拥有的学生：");
			
			//不会发出查询sql
			Set students = classes.getStudents();
			
			//不会发出查询sql
			for (Iterator iter = students.iterator(); iter.hasNext();) {
				Student student = (Student)iter.next();
				System.out.println(student.getName());
			}
		}catch(Exception e) {
			e.printStackTrace();
		}finally {
			HibernateUtils.closeSession(session);
		}	
	}
	
	public void testLoadClasses2() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			
			//不会发出查询sql
			Classes classes = (Classes)session.load(Classes.class, 1);
			
			//会发出两条查询sql，加载数据到classes和Students中
			System.out.println("班级：【" + classes.getName() + "】  拥有的学生总数：");

			//不会发出查询sql	
			Set students = classes.getStudents();
			
			//不会发出查询sql	
			System.out.println(students.size());
			
		}catch(Exception e) {
			e.printStackTrace();
		}finally {
			HibernateUtils.closeSession(session);
		}	
	}
	
}

 

Java代码

1. package com.bjsxt.hibernate;   
2.   
3. import java.util.Iterator;   
4. import java.util.Set;   
5.   
6. import org.hibernate.Session;   
7.   
8. import junit.framework.TestCase;   
9.   
10. /**  
11.  * 设置集合上的lazy=extra  
12.  * @author Administrator  
13.  *  
14.  */  
15. public class CollectionLazyTest3 extends TestCase {   
16.        
17.     public void testLoadClasses1() {   
18.         Session session = null;   
19.         try {   
20.             session = HibernateUtils.getSession();   
21.                
22.             //不会发出查询sql   
23.             Classes classes = (Classes)session.load(Classes.class, 1);   
24.                
25.             //会发出一条查询sql，加载数据到classes   
26.             System.out.println("班级：【" + classes.getName() + "】  拥有的学生：");   
27.                
28.             //不会发出查询sql   
29.             Set students = classes.getStudents();   
30.                
31.             //会发出一条查询sql，加载数据到students   
32.             for (Iterator iter = students.iterator(); iter.hasNext();) {   
33.                 Student student = (Student)iter.next();   
34.                 System.out.println(student.getName());   
35.             }   
36.         }catch(Exception e) {   
37.             e.printStackTrace();   
38.         }finally {   
39.             HibernateUtils.closeSession(session);   
40.         }      
41.     }   
42.        
43.     public void testLoadClasses2() {   
44.         Session session = null;   
45.         try {   
46.             session = HibernateUtils.getSession();   
47.                
48.             //不会发出查询sql   
49.             Classes classes = (Classes)session.load(Classes.class, 1);   
50.                
51.             //会发出一条查询sql，加载数据到classes   
52.             System.out.println("班级：【" + classes.getName() + "】  拥有的学生总数：");   
53.   
54.             //不会发出查询sql    
55.             Set students = classes.getStudents();   
56.   
57.             //会发出一条较为智能的查询sql，如：   
58.             //select count(id) from t_student where classid =?   
59.             System.out.println(students.size());   
60.                
61.         }catch(Exception e) {   
62.             e.printStackTrace();   
63.         }finally {   
64.             HibernateUtils.closeSession(session);   
65.         }      
66.     }   
67.        
68. }  

package com.bjsxt.hibernate;

import java.util.Iterator;
import java.util.Set;

import org.hibernate.Session;

import junit.framework.TestCase;

/**
 * 设置集合上的lazy=extra
 * @author Administrator
 *
 */
public class CollectionLazyTest3 extends TestCase {
	
	public void testLoadClasses1() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			
			//不会发出查询sql
			Classes classes = (Classes)session.load(Classes.class, 1);
			
			//会发出一条查询sql，加载数据到classes
			System.out.println("班级：【" + classes.getName() + "】  拥有的学生：");
			
			//不会发出查询sql
			Set students = classes.getStudents();
			
			//会发出一条查询sql，加载数据到students
			for (Iterator iter = students.iterator(); iter.hasNext();) {
				Student student = (Student)iter.next();
				System.out.println(student.getName());
			}
		}catch(Exception e) {
			e.printStackTrace();
		}finally {
			HibernateUtils.closeSession(session);
		}	
	}
	
	public void testLoadClasses2() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			
			//不会发出查询sql
			Classes classes = (Classes)session.load(Classes.class, 1);
			
			//会发出一条查询sql，加载数据到classes
			System.out.println("班级：【" + classes.getName() + "】  拥有的学生总数：");

			//不会发出查询sql	
			Set students = classes.getStudents();

			//会发出一条较为智能的查询sql，如：
			//select count(id) from t_student where classid =?
			System.out.println(students.size());
			
		}catch(Exception e) {
			e.printStackTrace();
		}finally {
			HibernateUtils.closeSession(session);
		}	
	}
	
}

----------------------------------------------------------------

单端关联加载

Java代码

1.   
2. <hibernate-mapping>   
3.     <class name="com.bjsxt.hibernate.Group" table="t_group">   
4.         <id name="id">   
5.             <generator class="native"/>   
6.         </id>   
7.         <property name="name"/>   
8.     </class>   
9. </hibernate-mapping>   
10.   
11. <hibernate-mapping>   
12.     <class name="com.bjsxt.hibernate.User" table="t_user" >   
13.         <id name="id">   
14.             <generator class="native"/>   
15.         </id>   
16.         <property name="name"/>   
17.         <!--   
18.         <many-to-one name="group" column="relatedGroup" />   
19.          -->   
20.            
21.         <many-to-one name="group" column="relatedGroup"/>    
22.     </class>   
23. </hibernate-mapping>        

<hibernate-mapping>
	<class name="com.bjsxt.hibernate.Group" table="t_group">
		<id name="id">
			<generator class="native"/>
		</id>
		<property name="name"/>
	</class>
</hibernate-mapping>

<hibernate-mapping>
	<class name="com.bjsxt.hibernate.User" table="t_user" >
		<id name="id">
			<generator class="native"/>
		</id>
		<property name="name"/>
		<!--
		<many-to-one name="group" column="relatedGroup" />
		 -->
		
		<many-to-one name="group" column="relatedGroup"/> 
	</class>
</hibernate-mapping>		

Java代码

1. package com.bjsxt.hibernate;   
2.   
3. import org.hibernate.Session;   
4.   
5. import junit.framework.TestCase;   
6.   
7. /**  
8.  * 所有lazy的属性默认  
9.  * @author Administrator  
10.  *  
11.  */  
12. public class SingleEndTest1 extends TestCase {   
13.   
14.     public void testLoadUser() {   
15.         Session session = null;   
16.         try {   
17.             session = HibernateUtils.getSession();   
18.                
19.             //不会发出查询sql   
20.             User user = (User)session.load(User.class, 2);   
21.                
22.             //会发出一条查询sql，转载数据到User   
23.             System.out.println("user name=" + user.getName());   
24.                
25.             //不会发出查询sql   
26.             Group group = user.getGroup();   
27.