hibernate的lazy策略使用总结

转自：http://www.blogjava.net/ywj-316/archive/2009/11/03/300928.html

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特性只对普通属性起作用,不会影响到集合上的lazy特性
      <class>标签上的lazy特性只对普通属性起作用,不会影响到单端关联上的lazy特性
在jsp中使用OpenSessionInview模式，一般采用filter实现

lazy策略在<class>上

// 设置<class>标签上的lazy="true",也就是默认配置
public void testload1(){ Session session=null; try{ session=HibernateUtils.getSession(); session.beginTransaction(); //不会发sql Group g=(Group)session.load(Group.class, 1); //不会发sql System.out.println(g.getId()); //会发sql System.out.println(g.getName()); session.getTransaction().commit(); }catch(Exception e){ e.printStackTrace(); session.getTransaction().rollback(); }finally{ HibernateUtils.closeSession(session); } }
public void testload2(){ Session session=null; Group g=null; try{ session=HibernateUtils.getSession(); session.beginTransaction(); //不会发sql g=(Group)session.load(Group.class, 1); //不会发sql session.getTransaction().commit(); }catch(Exception e){ e.printStackTrace(); session.getTransaction().rollback(); }finally{ HibernateUtils.closeSession(session); } //不能正确输出，抛出lazy初始化lazyInitializationException异常，因为session已经关闭 //hibernate支持lazy策略只有在session打开关态下有效 System.out.println(g.getName()); } 

lazy策略在<set><list>上
<class>标签上的lazy特性只对普通属性起作用,不会影响到集合上的lazy特性

// 保持lazy是默认配置
public void testLoad1(){ Session session=null; try{ session=HibernateUtils.getSession(); session.beginTransaction(); //不会发出sql Classes classes=(Classes)session.load(Classes.class, 3); //会发出sql System.out.println(classes.getName()); //不会发出sql Set students=classes.getStudents(); //会发出sql,发出查询全部数据的sql System.out.println(students.size()); session.getTransaction().commit(); }catch(Exception e){ session.getTransaction().rollback(); e.printStackTrace(); }finally{ HibernateUtils.closeSession(session); } }
     // 设置<class>标签上的lazy="false"
public void testLoad1(){ Session session=null; try{ session=HibernateUtils.getSession(); session.beginTransaction(); //会发出sql Classes classes=(Classes)session.load(Classes.class, 3); //不会发出sql System.out.println(classes.getName()); //不会发出sql,不会影响集合 Set students=classes.getStudents(); //会发出sql,发出查询全部数据的sql System.out.println(students.size()); session.getTransaction().commit(); }catch(Exception e){ session.getTransaction().rollback(); e.printStackTrace(); }finally{ HibernateUtils.closeSession(session); } }
    
     // 设置集合上的lazy="false",其他全为默认
public void testLoad1(){ Session session=null; try{ session=HibernateUtils.getSession(); session.beginTransaction(); //不会发出sql Classes classes=(Classes)session.load(Classes.class, 3); //会发出sql，会发出两条sql分别加载classes和Student System.out.println(classes.getName()); //不会发出sql Set students=classes.getStudents(); //不会发出sql System.out.println(students.size()); session.getTransaction().commit(); }catch(Exception e){ session.getTransaction().rollback(); e.printStackTrace(); }finally{ HibernateUtils.closeSession(session); } }
    
         // 设置集合上的lazy="extra",其他全为默认(比智能，基本与lazy="true"相同)
public void testLoad1(){ Session session=null; try{ session=HibernateUtils.getSession(); session.beginTransaction(); //不会发出sql Classes classes=(Classes)session.load(Classes.class, 3); //会发出sql System.out.println(classes.getName()); //不会发出sql Set students=classes.getStudents(); //会发出sql,发出一条比较智能的sql System.out.println(students.size()); session.getTransaction().commit(); }catch(Exception e){ session.getTransaction().rollback(); e.printStackTrace(); }finally{ HibernateUtils.closeSession(session); } } 

lazy策略在<one-to-one><many-to-one>单端关联上
可以取值：false/proxy/noproxy,默认为proxy，noproxy为不用代理，使用自解码，要使用增强工具

// 所有lazy全为默认
public void testload1(){ Session session=null; try{ session=HibernateUtils.getSession(); session.beginTransaction(); //不会发出sql User user=(User)session.load(User.class, 3); //会发出sql System.out.println(user.getName()); //不会发出sql Group group=user.getGroup(); //会发出sql System.out.println(group.getName()); session.getTransaction().commit(); }catch(Exception e){ e.printStackTrace(); session.getTransaction().rollback(); }finally{ HibernateUtils.closeSession(session); } }
    
     // 设置<many-to-one>的lazy="false",其他全为默认,效果同集合
public void testload1(){ Session session=null; try{ session=HibernateUtils.getSession(); session.beginTransaction(); //不会发出sql User user=(User)session.load(User.class, 3); //会发出sql，会发出两条sql分别加载Group和User System.out.println(user.getName()); //不会发出sql Group group=user.getGroup(); //不会发出sql System.out.println(group.getName()); session.getTransaction().commit(); }catch(Exception e){ e.printStackTrace(); session.getTransaction().rollback(); }finally{ HibernateUtils.closeSession(session); } }
    
     // 设置<class>标签上的lazy="false",其他全默认，效果同集合
     < class > 标签上的lazy特性只对普通属性起作用,不会影响到 < many - to - one > 的lazy特性
public void testload1(){ Session session=null; try{ session=HibernateUtils.getSession(); session.beginTransaction(); //会发出sql User user=(User)session.load(User.class, 3); //不会发出sql System.out.println(user.getName()); //不会发出sql,不会影响到<many-to-one> Group group=user.getGroup(); //会发出sql System.out.println(group.getName()); session.getTransaction().commit(); }catch(Exception e){ e.printStackTrace(); session.getTransaction().rollback(); }finally{ HibernateUtils.closeSession(session); } }