Hibernate lazy加载FOR Connection

Hibernate集合属性的懒加载策略：

在集合属性上，可以配置懒加载策略，取值为：true/false/extra

true:默认取值，它的意思是只有在调用这个集合获取里面的元素对象时，才发出查询语句，加载其
     集合元素的数据
false:取消懒加载特性，即在加载对象的同时，就发出第二条查询语句加载其关联集合的数据
extra:一种比较聪明的懒加载策略，即调用集合的size/contains等方法的时候，hibernate
      并不会去加载整个集合的数据，而是发出一条聪明的SQL语句，以便获得需要的值，只有在
      真正需要用到这些集合元素对象数据的时候，才去发出查询语句加载所有对象的数据

 

 

以下以单向一对多映射为基础。对一方的set进行lazy的相关设置，来进行测试。

如下：

package com.bjsxt.hibernate;

import java.util.Set;

public class Classes {
	
	private int id;
	
	private String name;
	
	private Set students;
	
	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 Set getStudents() {
		return students;
	}

	public void setStudents(Set students) {
		this.students = students;
	}
	
	
}

 

package com.bjsxt.hibernate;

public class Student {
	
	private int id;
	
	private String name;

	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;
	}
}

 

 

Classes.hbm.xml

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC 
	"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
	"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<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>

 

Student.hbm.xml

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC 
	"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
	"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
	<class name="com.bjsxt.hibernate.Student" table="t_student">
		<id name="id">
			<generator class="native"/>
		</id>
		<property name="name"/>
	</class>
</hibernate-mapping>

 

 

以上配置了一对多映射。

由于集合下在LAZY有三个属性值true/false/extra可以设置，下面我们分别进行测试。

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

 

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);
		}	
	}
	
}

 上面两个方法执行的结果为：

testLoadClasses1结果：

Hibernate: select classes0_.id as id0_0_, classes0_.name as name0_0_ from t_classes classes0_ where classes0_.id=?
班级：【班级】  拥有的学生：
Hibernate: select students0_.classid as classid0_1_, students0_.id as id1_, students0_.id as id1_0_, students0_.name as name1_0_ from t_student students0_ where students0_.classid=?
学生_6
学生_9
学生_2
学生_0
学生_4
学生_1
学生_8
学生_7
学生_5
学生_3

 

testLoadClasses2结果：

Hibernate: select classes0_.id as id0_0_, classes0_.name as name0_0_ from t_classes classes0_ where classes0_.id=?
班级：【班级】  拥有的学生总数：
Hibernate: select students0_.classid as classid0_1_, students0_.id as id1_, students0_.id as id1_0_, students0_.name as name1_0_ from t_student students0_ where students0_.classid=?
10

 

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

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);
		}	
	}
	
}

 这里在testLoadClasses1方法当调用classes.getName()时注意，此时才发出两条SQL，如下 ：

Hibernate: select classes0_.id as id0_0_, classes0_.name as name0_0_ from t_classes classes0_ where classes0_.id=?
Hibernate: select students0_.classid as classid0_1_, students0_.id as id1_, students0_.id as id1_0_, students0_.name as name1_0_ from t_student students0_ where students0_.classid=?
班级：【班级】  拥有的学生：
学生_3
学生_9
学生_4
学生_6
学生_5
学生_1
学生_8
学生_0
学生_2
学生_7

 而testLoadClasses2的结果也是如下：注意这两个SQL也是在调用classes.getName时发出的，后面打印出students.size没有再次发出SQL。这也正好说明：在加载对象的同时，就发出第二条查询语句加载其关联集合的数据

Hibernate: select classes0_.id as id0_0_, classes0_.name as name0_0_ from t_classes classes0_ where classes0_.id=?
Hibernate: select students0_.classid as classid0_1_, students0_.id as id1_, students0_.id as id1_0_, students0_.name as name1_0_ from t_student students0_ where students0_.classid=?
班级：【班级】  拥有的学生总数：
10

 

 

3、extra:一种比较聪明的懒加载策略，即调用集合的size/contains等方法的时候，hibernate
      并不会去加载整个集合的数据，而是发出一条聪明的SQL语句，以便获得需要的值，只有在
      真正需要用到这些集合元素对象数据的时候，才去发出查询语句加载所有对象的数据

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);
		}	
	}
	
	public void testLoadClasses3() {
		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
			for (Iterator iter = students.iterator(); iter.hasNext();) {
				Student student = (Student)iter.next();
				System.out.println(student.getName());
			}
			
			//因为前面已经迭代出了所有的数据，所以以下不发出sql，与testLoadClasses2的不同就是打印总数之前是否有迭代。
			System.out.println(students.size());
			
		}catch(Exception e) {
			e.printStackTrace();
		}finally {
			HibernateUtils.closeSession(session);
		}	
	}
	
}

 

testLoadClasses1结果：

Hibernate: select classes0_.id as id0_0_, classes0_.name as name0_0_ from t_classes classes0_ where classes0_.id=?
班级：【班级】  拥有的学生：
Hibernate: select students0_.classid as classid0_1_, students0_.id as id1_, students0_.id as id1_0_, students0_.name as name1_0_ from t_student students0_ where students0_.classid=?
学生_2
学生_8
学生_3
学生_5
学生_4
学生_9
学生_0
学生_7
学生_1
学生_6

 testLoadClasses2结果：

Hibernate: select classes0_.id as id0_0_, classes0_.name as name0_0_ from t_classes classes0_ where classes0_.id=?
班级：【班级】  拥有的学生总数：
Hibernate: select count(id) from t_student where classid =?
10

 

 

可以看到当LAZY＝“extra”的时候会比较智能，即students.size()的时候，会调用select count(id) from t_student where classid =?
求总数。

比较三种值设置间的区别与联系，显然第三种方法更为优化