lazy策略

hibernate lazy策略可以使用在：
* <class>标签上，可以取值：true/false
* <property>标签上，可以取值：true/false需要类增强工具
* <set><list>标签上，可以取值：true/false/extra
* <one-to-one><many-to-one>单端关联上，可以取值：false/proxy/noproxy

lazy概念：只有真正使用该对象时，才会创建，对于hibernate而言，正真使用的时候才会发出sql

hibernate支持lazy策略只有在session打开状态下有效

<class>标签上的lazy特性只对普通属性起作用

//model
public class Group {

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

//Group.hbm.xml
<hibernate-mapping>
	<class name="com.bjsxt.hibernate.Group" table="t_group"><!-- 默认lazy为true -->
		<id name="id">
			<generator class="native"/>
		</id>
		<property name="name" length = "10"/>
	</class>
</hibernate-mapping>


<mapping resource="com/bjsxt/hibernate/Group.hbm.xml"/>

import org.hibernate.Session;

public class InitData {

	public static void main(String[] args) {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			session.beginTransaction();

			Group group = new Group();
			group.setName("尚学堂");

			session.save(group);

			session.getTransaction().commit();
		}catch(Exception e) {
			e.printStackTrace();
			session.getTransaction().rollback();
		}finally {
			HibernateUtils.closeSession(session);
		}
	}
}


import org.hibernate.Session;

import junit.framework.TestCase;

/**
 * 运行本单元测试的条件：
 * 
 * 设置<class>标签上的lazy=true，也就是默认配置
 * 
 * @author Administrator
 * 
 */
public class ClassLazyTest extends TestCase {

	public void testLoad1() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			session.beginTransaction();

			// 不会发出sql,load支持lazy，get不支持
			Group group = (Group) session.load(Group.class, 1);// 根据主键查找

			// 不会发出sql，因为查找的ID为传入值，不需要经过数据库
			System.out.println("group.id=" + group.getId());

			// 会发出sql
			System.out.println("group.name=" + group.getName());

			session.getTransaction().commit();
		} catch (Exception e) {
			e.printStackTrace();
			session.getTransaction().rollback();
		} finally {
			HibernateUtils.closeSession(session);
		}
	}

	public void testLoad2() {
		Session session = null;
		Group group = null;
		try {
			session = HibernateUtils.getSession();
			session.beginTransaction();

			group = (Group) session.load(Group.class, 1);

			session.getTransaction().commit();
		} catch (Exception e) {
			e.printStackTrace();
			session.getTransaction().rollback();
		} finally {
			HibernateUtils.closeSession(session);
		}

		// 不能正确输出，抛出LazyInitializationException 异常，因为session已经关闭
		// hibernate支持lazy策略只有在session打开状态下有效
		System.out.println("group.name=" + group.getName());
	}
}

hibernate在集合上的lazy策略，可以取值：true/false/extra

<set name="students" inverse="true" cascade="all" lazy="extra">
			<key column="classesid"/>
			<one-to-many class="Student"/>
</set>

<class>标签上的lazy不会影响到集合上的lazy特性

public class Student {

	private int id;

	private String name;

	private Classes classes;

	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 Classes getClasses() {
		return classes;
	}

	public void setClasses(Classes classes) {
		this.classes = classes;
	}
}


import java.util.Set;

public class Classes {

	private int id;

	private String name;

	private Set<Student> 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 void setStudents(Set<Student> students) {
		this.students = students;
	}

	public Set<Student> getStudents() {
		return students;
	}
}

//Classes.hbm.xml
<hibernate-mapping package="com.bjsxt.hibernate">
	<class name="Classes" table="t_classes">
		<id name="id">
			<generator class="native"/>
		</id>
		<property name="name"/>
		<set name="students" inverse="true" cascade="all" lazy="extra">
			<key column="classesid"/>
			<one-to-many class="Student"/>
		</set>
	</class>
</hibernate-mapping>


//Student.hbm.xml
<hibernate-mapping>
	<class name="com.bjsxt.hibernate.Student" table="t_student">
		<id name="id">
			<generator class="native"/>
		</id>
		<property name="name"/>
		<many-to-one name="classes" column="classesid"/>
	</class>
</hibernate-mapping>

import org.hibernate.Session;

public class InitData {

	public static void main(String[] args) {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			session.beginTransaction();

			Classes classes = new Classes();
			classes.setName("尚学堂");
			session.save(classes);

			Student student1 = new Student();
			student1.setName("10");
			student1.setClasses(classes);
			session.save(student1);

			Student student2 = new Student();
			student2.setName("祖儿");
			student2.setClasses(classes);
			session.save(student2);

			session.getTransaction().commit();
		}catch(Exception e) {
			e.printStackTrace();
			session.getTransaction().rollback();
		}finally {
			HibernateUtils.closeSession(session);
		}
	}	
}


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

import junit.framework.TestCase;

import org.hibernate.Session;

/**
 * 保持lazy默认true
 * @author Administrator
 *
 */
public class CellectionlazyTest1 extends TestCase {


	public void testLoad1() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			session.beginTransaction();

			//不会发出sql，load支持lazy，生成代理
			Classes classes = (Classes)session.load(Classes.class, 1);

			//会发出sql,要通过数据库查班级名字
			System.out.println("classes.name=" + classes.getName());

			//不会发出sql,没有真正要用
			Set<Student> students = classes.getStudents();

			//会发出sql，真正要用于输出
			for (Iterator<Student> iter=students.iterator(); iter.hasNext();) {
				Student student = (Student)iter.next();
				System.out.println("student.name=" + student.getName());
			}
			session.getTransaction().commit();
		}catch(Exception e) {
			e.printStackTrace();
			session.getTransaction().rollback();
		}finally {
			HibernateUtils.closeSession(session);
		}
	}	

	public void testLoad2() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			session.beginTransaction();

			//不会发出sql
			Classes classes = (Classes)session.load(Classes.class, 1);

			//会发出sql
			System.out.println("classes.name=" + classes.getName());

			//不会发出sql
			Set<Student> students = classes.getStudents();

			//会发出sql,发出查询全部数据的sql
			System.out.println("student.count=" + students.size());
			session.getTransaction().commit();
		}catch(Exception e) {
			e.printStackTrace();
			session.getTransaction().rollback();
		}finally {
			HibernateUtils.closeSession(session);
		}
	}		
}


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

import junit.framework.TestCase;

import org.hibernate.Session;

/**
 * 设置<class>标签上的lazy=false
 * @author Administrator
 *
 */
public class CellectionlazyTest2 extends TestCase {


	public void testLoad1() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			session.beginTransaction();

			//会发出sql,
			Classes classes = (Classes)session.load(Classes.class, 1);

			//不会发出sql,<class>标签上的lazy=false只对普通属性起作用
			System.out.println("classes.name=" + classes.getName());

			//不会发出sql
			Set<Student> students = classes.getStudents();

			//会发出sql，<class>标签上的lazy=false对集合没有影响
			for (Iterator<Student> iter=students.iterator(); iter.hasNext();) {
				Student student = (Student)iter.next();
				System.out.println("student.name=" + student.getName());
			}
			session.getTransaction().commit();
		}catch(Exception e) {
			e.printStackTrace();
			session.getTransaction().rollback();
		}finally {
			HibernateUtils.closeSession(session);
		}
	}	
}


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

import junit.framework.TestCase;

import org.hibernate.Session;

/**
 * 设置集合<Set>上的lazy=false,其它默认
 * @author Administrator
 *
 */
public class CellectionlazyTest3 extends TestCase {


	public void testLoad1() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			session.beginTransaction();

			//不会发出sql
			Classes classes = (Classes)session.load(Classes.class, 1);

			//会发出sql查询全部普通属性,会发出两条sql分别加载Classes和Student
			System.out.println("classes.name=" + classes.getName());

			//不会发出sql
			Set<Student> students = classes.getStudents();

			//不会发出sql
			for (Iterator<Student> iter=students.iterator(); iter.hasNext();) {
				Student student = (Student)iter.next();
				System.out.println("student.name=" + student.getName());
			}
			session.getTransaction().commit();
		}catch(Exception e) {
			e.printStackTrace();
			session.getTransaction().rollback();
		}finally {
			HibernateUtils.closeSession(session);
		}
	}	

	public void testLoad2() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			session.beginTransaction();

			//不会发出sql
			Classes classes = (Classes)session.load(Classes.class, 1);

			//会发出sql,会发出两条sql分别加载Classes和Student
			System.out.println("classes.name=" + classes.getName());

			//不会发出sql
			Set<Student> students = classes.getStudents();

			//不会发出sql
			System.out.println("student.count=" + students.size());
			session.getTransaction().commit();
		}catch(Exception e) {
			e.printStackTrace();
			session.getTransaction().rollback();
		}finally {
			HibernateUtils.closeSession(session);
		}
	}		
}


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

import junit.framework.TestCase;

import org.hibernate.Session;

/**
 * 设置集合<Set>上的lazy=extra,其它默认
 * @author Administrator
 *
 */
public class CellectionlazyTest4 extends TestCase {

	public void testLoad1() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			session.beginTransaction();

			//不会发出sql
			Classes classes = (Classes)session.load(Classes.class, 1);

			//会发出sql，会加载班级
			System.out.println("classes.name=" + classes.getName());

			//不会发出sql
			Set<Student> students = classes.getStudents();

			//会发出sql，加载学生
			for (Iterator<Student> iter=students.iterator(); iter.hasNext();) {
				Student student = (Student)iter.next();
				System.out.println("student.name=" + student.getName());
			}
			session.getTransaction().commit();
		}catch(Exception e) {
			e.printStackTrace();
			session.getTransaction().rollback();
		}finally {
			HibernateUtils.closeSession(session);
		}
	}	

	public void testLoad2() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			session.beginTransaction();

			//不会发出sql
			Classes classes = (Classes)session.load(Classes.class, 1);

			//会发出sql
			System.out.println("classes.name=" + classes.getName());

			//不会发出sql
			Set<Student> students = classes.getStudents();
			//会发出sql,发出一条比较智能的sql
			System.out.println("student.count=" + students.size());
			session.getTransaction().commit();
		}catch(Exception e) {
			e.printStackTrace();
			session.getTransaction().rollback();
		}finally {
			HibernateUtils.closeSession(session);
		}
	}		
}

hibernate在单端关联上的lazy策略，可以取值：false/proxy(默认)/noproxy

<class>标签上的lazy不会影响到单端关联上的lazy特性

public class User {

	private int id;

	private String name;

	private Group group;

	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 Group getGroup() {
		return group;
	}

	public void setGroup(Group group) {
		this.group = group;
	}

}


public class Group {

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

//User.hbm.xml
<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="groupid" cascade="all"/>
		 -->
		 <many-to-one name="group" column="groupid"/>
	</class>
</hibernate-mapping>


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

import org.hibernate.Session;

public class InitData {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			session.beginTransaction();

			Group group = new Group();
			group.setName("尚学堂");

			session.save(group);

			User user1 = new User();
			user1.setName("菜10");
			user1.setGroup(group);

			User user2 = new User();
			user2.setName("容祖儿");
			user2.setGroup(group);

			//可以正确存储
			session.save(user1);
			session.save(user2);
			session.getTransaction().commit();
		}catch(Exception e) {
			e.printStackTrace();
			session.getTransaction().rollback();
		}finally {
			HibernateUtils.closeSession(session);
		}
	}
}


import org.hibernate.Session;

import junit.framework.TestCase;

/**
 * 所有lazy属性默认
 * @author Administrator
 *
 */
public class SingleEndTest1 extends TestCase {

	public void testLoad1() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			session.beginTransaction();

			//不会发出sql,load支持lazy
			User user = (User)session.load(User.class, 1);

			//会发出sql，真正使用普通属性
			System.out.println("user.name=" + user.getName());

			//不会发出sql，返回代理
			Group group = user.getGroup();

			//会发出sql，真正使用group属性
			System.out.println("group.name=" + group.getName());

			session.getTransaction().commit();
		}catch(Exception e) {
			e.printStackTrace();
			session.getTransaction().rollback();
		}finally {
			HibernateUtils.closeSession(session);
		}
	}	
}


import org.hibernate.Session;

import junit.framework.TestCase;

/**
 * 将<many-to-one>中的lazy设置为false,其它默认
 * @author Administrator
 *
 */
public class SingleEndTest2 extends TestCase {

	public void testLoad1() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			session.beginTransaction();

			//不会发出sql
			User user = (User)session.load(User.class, 1);

			//会发出sql，发出两条sql分别加载User和Group
			System.out.println("user.name=" + user.getName());

			//不会发出sql
			Group group = user.getGroup();

			//不会发出sql,上面已经查询了
			System.out.println("group.name=" + group.getName());

			session.getTransaction().commit();
		}catch(Exception e) {
			e.printStackTrace();
			session.getTransaction().rollback();
		}finally {
			HibernateUtils.closeSession(session);
		}
	}
}


import org.hibernate.Session;

import junit.framework.TestCase;

/**
 * <class>标签上的lazy=false,其它默认
 * @author Administrator
 *
 */
public class SingleEndTest3 extends TestCase {

	public void testLoad1() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			session.beginTransaction();

			//会发出sql
			User user = (User)session.load(User.class, 1);

			//不会发出sql
			System.out.println("user.name=" + user.getName());

			//不会发出sql
			Group group = user.getGroup();

			//会发出sql
			System.out.println("group.name=" + group.getName());

			session.getTransaction().commit();
		}catch(Exception e) {
			e.printStackTrace();
			session.getTransaction().rollback();
		}finally {
			HibernateUtils.closeSession(session);
		}
	}
}