13. Hibernate lazy策略

Hibernate lazy策略可以使用在(hibernate3.0默认为true)：

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

              只会影响到类的普通属性，即使设置为false，类中的集合属性默认情况下仍然采用延时加载

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

              需要类增强工具,通过改变字节码来实现，属性的延时加载，常用于clob和blob大对象的延时加载

       * <set><list>标签上，可以取值：true/false/extra

       * <one-to-one><many-to-one>单端关联上，可以取值：false/proxy/noproxy

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

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

测试用例：

1：

public void testLoad() {

              Session session = null;

              try {

                     session = HibernateUtils.getSession();

                     session.beginTransaction();

                    

                     //不会发出sql

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

                    

                     //不会发出sql

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

              }

       }           

2.

public void testLoad() {

              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打开状态下有效

                   //openSessionInView

              System.out.println("group.name=" + group.getName());

       }    

3.（Classes和Student的定义见多对多关联映射）

public void testLoad() {

              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，赋值一个persistentSet的代理对象

                     Set students = classes.getStudents();

                    

                     //会发出sql

                     for (Iterator 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);

              }

       }    

4. （Classes和Student的定义见多对多关联映射）

       public void testLoad() {

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

              }

       }

5. （Classes和Student的定义见多对多关联映射）

       设置条件：设置<class>标签上的lazy=false

       public void testLoad() {

              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 students = classes.getStudents();

                    

                     //会发出sql，设置<class>标签上的lazy=false

                     //<class>标签上的lazy设置，只会影响到类的普通属性，不会影响到集合属性

 

                     for (Iterator 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);

              }

       }

6. （Classes和Student的定义见多对多关联映射）

       设置条件：设置集合<set>上的lazy=false,其它默认

public void testLoad() {

              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 students = classes.getStudents();

                    

                     //不会发出sql

                     for (Iterator 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);

              }

       }    

7. （Classes和Student的定义见多对多关联映射）

       设置条件：设置集合<set>上的lazy=false,其它默认

public void testLoad() {

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

              }

       }    

8. （Classes和Student的定义见多对多关联映射）

       设置条件：设置集合<set>上的lazy=extra,其它默认

public void testLoad() {

              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 students = classes.getStudents();

                    

                     //会发出sql

                     for (Iterator 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);

              }

       }    

9. （Classes和Student的定义见多对多关联映射）

       设置条件：设置集合<set>上的lazy=extra,其它默认

public void testLoad() {

              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 students = classes.getStudents();

                     //会发出sql,发出一条比较智能的sql

                            //select count(id) from t_student where classesid = ?

                     System.out.println("student.count=" + students.size());

                     session.getTransaction().commit();

              }catch(Exception e) {

                     e.printStackTrace();

                     session.getTransaction().rollback();

              }finally {

                     HibernateUtils.closeSession(session);

              }

       }    

10. （Group和User的定义见多对多关联映射）

       设置条件：将<many-to-one>中的lazy设置为false,其它默认

public void testLoad() {

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

              }

       }