lazy(懒加载)属性解析

关联映射文件中<class>标签中的lazy(懒加载)属性 

Lazy(懒加载)：只有在正真使用该对象时，才会创建这个对象

Hibernate中的lazy(懒加载)：只有我们在正真使用时，它才会发出SQL语句，给我们去查询，如果不使用对象则不会发SQL语句进行查询。

Hibernate中lazy(懒加载)的实现：

采用了第三方组件的库，这个库叫cglib.jar(比较流行)，这个库对我们的类生成代理类(JDK的动态代理，只能对JDK中实现了接口的类进行代理)，代理可以控制源对象并且可以对源对象的功能进行增强，而cglib.jar可以对类进行代理(cglib对我们的类进行继承，生成一个子类，这个子类作为代理类返回给你)。 

只有你正真代理类的方法，则会查看你有没有加载目标对象，如果没有则会加载目标对象。 

Lazy(懒加载)在hibernate何处使用：

1、<class>标签上，可以取值：true/false,(默认值为：true) 

2、<property>标签上，可以取值：true/false，需要类增强工具 

3、<set>、<list>集合上，可以取值：true/false/extra,(默认值为：true) 

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

Session.load()方法支持lazy，而session.get()不支持lazy; 

Hibernate的lazy生效期：

生效期和session一样的，session关闭，lazy失效 

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

<class>标签上，可以取值：true/false,(默认值为：true)：

实例一：设置<class标签上的lazy=true(默认) 

@Test
    public void LazyTest() {
        session = HibernateUtil.getSession();
        tx = session.beginTransaction();

        // 执行此语并不会发SQL语句,只是返回一个代理类
        Group group = (Group) session.load(Group.class, 1);

        // 不会发SQL语句，使用上面输入的1值
        System.out.println("group.id=" + group.getId());

        // 此处使用对象，会发出SQL语句
        System.out.println("group.name=" + group.getName());

        // 提交事务
        tx.commit();
    }

输出：

group.id=1
Hibernate: select group0_.id as id1_1_0_, group0_.name as name2_1_0_ from t_group group0_ where group0_.id=?

设置<class标签上的lazy=true(默认) 

@Test
    public void LazyTest1(){
        Session session = null;
        Transaction tx = null;
        Group group = null;
            
        try {
            session = HibernateUtil.getSession();
            tx = session.beginTransaction();
    
            group =(Group)session.load(Group.class, 1);
            
            System.out.println("group.name=" + group.getName());
            
            //提交事务
            tx.commit();
        } catch (Exception e) {
            e.printStackTrace();
            tx.rollback();
        } finally {
            HibernateUtil.closeSession(session);
        }
        
        //不能正确输出，抛出了LazyInitalizationException异常,因为session已经关闭
        //hibernate支持lazy策略只有在session打开状态下有效。
        System.out.println("group.name=" + group.getName());
    }

关联映射文件中集合标签中的lazy(懒加载)属性

<set>、<list>集合上，可以取值：true/false/extra,(默认值为：true) 

实例一：(集合上的lazy=true(默认)) 

@Test
    public void LazyTest2() {

        session = HibernateUtil.getSession();
        tx = 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 = iter.next();
            System.out.println(student.getName());
        }

        // 提交事务
        tx.commit();
    }

实例二：集合上的lazy=true(默认)

session = HibernateUtils.getSession();
            tx = 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());
            
            //提交事务
            tx.commit();

实例三：集合上的lazy=false,其它保持默认

//不会发出SQL语句,因为只设置了集合上的lazy为false,其它保持默认
            Classes classes = (Classes)session.load(Classes.class, 1);
            //发出两条SQL语句，分别加载classes和student
            //并且把集合中的数据也加载上来(虽然并没有使用集合中的对象)，因为设置了集合的lazy=false
            System.out.println("classes.name=" + classes.getName());
            
            //不会发SQL语句，因为已经在前面加载了数据
            Set<Student> students = classes.getStudents();
            
            //会发出SQL语句，因为已经在前面加载了数据
            for (Iterator<Student> iter = students.iterator();iter.hasNext();){
                Student student = iter.next();
                System.out.println(student.getName());
            }

实例四：集合上的lazy=false,其它保持默认

//不会发出SQL语句
        Classes classes = (Classes)session.load(Classes.class, 1);
        //发出两条SQL语句，分别加载classes和student
        //并且把集合中的数据也加载上来(虽然并没有使用集合中的对象)，因为设置了集合的lazy=false
        System.out.println("classes.name=" + classes.getName());
        
        //不会发SQL语句，因为已经在前面加载了数据
        Set<Student> students = classes.getStudents();
        
        //不会发SQL语句，因为已经在前面加载了数据
        System.out.println("student.count=" + students.size());

实例五：设置集合上lazy=extra，其它默认

session = HibernateUtils.getSession();
            tx = 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 = iter.next();
                System.out.println(student.getName());
            }

实例六：设置集合上lazy=extra，其它默认

session = HibernateUtils.getSession();
        tx = 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语句(select count(id) form t_student where classesid=?)
        System.out.println("student.count=" + students.size());
        
        //提交事务
        tx.commit();

<one-to-one>、<many-to-one>单端关联上的lazy(懒加载)属性

Ø <one-to-one>、<many-to-one>单端关联上，可以取值：false/proxy/noproxy(false/代理/不代理)

实例一：所有lazy属性默认(支持懒加载)

session = HibernateUtils.getSession();
            tx = session.beginTransaction();

            //不发出SQL语句，支持lazy(懒加载)
            User user = (User) session.load(User.class, 3);
            //发出SQL语句，只加载普通属性，集合中的数据不会加载
            System.out.println("user.name=" + user.getName());
            
            //不会发出SQL语句，只返回代理类
            Group group = user.getGroup();
            //发出SQL语句，因为现在真正使用对象
            System.out.println("group.name=" + group.getName());
            tx.commit();

实例二：将<many-to-one>中的lazy设置为false，其它默认

session = HibernateUtils.getSession();
            tx = session.beginTransaction();

            //不会发出SQL
            User user = (User) session.load(User.class, 3);
            //会发出SQL，发出两条SQL，分别是User和组
            //因为<many-to-one>中的lazy=false，则会加载Group
            System.out.println("user.name=" + user.getName());
            
            //不会发出，已经在上面加载了数据
            Group group = user.getGroup();
            //不会发出，已经在上面加载了数据
            System.out.println("group.name=" + group.getName());
            tx.commit();

实例三：将<class>中的lazy设置为false，其它默认

session = HibernateUtils.getSession();
            tx = session.beginTransaction();

            //会发出SQL,因为<class>中的lazy=false
            User user = (User) session.load(User.class, 3);
            //不会发出SQL，已经在上面加载了
            System.out.println("user.name=" + user.getName());
            
            //不会发出，因为<class>标签上的lazy只对普通属性的影响
            //<class>标签上的lazy不会影响到单端关联上的lazy特性
            Group group = user.getGroup();
            //会发出，因为开始使用对象
            System.out.println("group.name=" + group.getName());

            tx.commit();