9.Lazy策略（hibernate筆記）

一、簡(jiǎn)介

  • 延遲加載就是我們真正使用某個(gè)對(duì)象的時(shí)候，這個(gè)對(duì)象才會(huì)被創(chuàng)建出來(lái)。而在hibernate中的意思就是只有我們真正需要使用某個(gè)對(duì)象的時(shí)候，才會(huì)去查詢(xún)。采用第三方的一個(gè)庫(kù)cglab，生成代理類(lèi)。和jdk的動(dòng)態(tài)代理的區(qū)別是cglab能對(duì)類(lèi)進(jìn)行代理（繼承原先的類(lèi)生成一個(gè)子類(lèi)，子類(lèi)作為代理類(lèi)），而jdk的動(dòng)態(tài)代理只能對(duì)實(shí)現(xiàn)了接口的類(lèi)進(jìn)行代理。

  • hibernate的lazy策略可以使用在：

    • <class>標(biāo)簽上，可以取值：true、false，默認(rèn)是true，打開(kāi)。
    • <property>標(biāo)簽上，可以取值true、false，默認(rèn)是true打開(kāi)，使用較少。需要類(lèi)增強(qiáng)工具（不講）。
    • <set><list>標(biāo)簽上，可以取值true、false、extra
    • <one_to_one><many_to_one>標(biāo)簽中，單端關(guān)聯(lián)上，可以取值：false、proxy、noproxy

  • 代理的概念：只有真正使用該對(duì)象時(shí)才會(huì)創(chuàng)建，對(duì)于hibernate來(lái)說(shuō)就是只有真正使用的時(shí)候才會(huì)發(fā)出sql。注意：lazy和Session的生命周期一致。

二、用在class標(biāo)簽上（工程hibernate_lazy4class）

實(shí)體類(lèi)（Group.java）

package cn.itcast.hibernate;
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

<?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="cn.itcast.hibernate.Group" table="_group">
        <id name="id">
            <generator class="native"/>
        </id>
        <property name="name"/>
    </class>
</hibernate-mapping>

先在數(shù)據(jù)庫(kù)中存入一些數(shù)據(jù)：
InitData.java

package cn.itcast.hibernate;
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);
        }
    }
}

測(cè)試：
ClassLazyTest.java

package cn.itcast.hibernate;
import org.hibernate.Session;
import org.junit.Test;
/*
 *在測(cè)試的時(shí)候有個(gè)條件是：設(shè)置<class>標(biāo)簽上的lazy=true，也就是默認(rèn)配置 
 * */
public class ClassLazyTest {
    
    @Test
    public void testLoad1(){
        Session session = null;
        try {
            session = HibernateUtils.getSession();
            session.beginTransaction();
            //不會(huì)發(fā)sql，因?yàn)闆](méi)有真正用到
            Group gorup = (Group) session.load(Group.class, 1);
            
            //這里是不會(huì)發(fā)sql的，因?yàn)橹麈I在上面已經(jīng)給出了
            System.out.println("group.id = " + gorup.getId());
            //這里是要發(fā)sql的，因?yàn)樾枰玫?            System.out.println("group.name = " + gorup.getName());
            session.getTransaction().commit();
        } catch (Exception e) {
            e.printStackTrace();
            session.getTransaction().rollback();
        }finally{
            HibernateUtils.closeSession(session);
        }
    }
    
    @Test
    public void testLoad2(){
        Session session = null;
        Group group = null;
        try {
            session = HibernateUtils.getSession();
            session.beginTransaction();
            group = (Group) session.load(Group.class, 1);
            System.out.println("group.id = " + group.getId());
            
            System.out.println("group.name = " + group.getName());
            session.getTransaction().commit();
        } catch (Exception e) {
            e.printStackTrace();
            session.getTransaction().rollback();
        }finally{
            HibernateUtils.closeSession(session);
            
        }
        //不能正確執(zhí)行，拋出異常，因?yàn)閟ession已經(jīng)關(guān)閉，hibernate支持lazy策略只有在session打開(kāi)狀態(tài)下有效
        System.out.println("group.name = " + group.getName());
    }
}

三、用在集合標(biāo)簽上（工程hibernate_lazy4collection）

這里我們使用一對(duì)多雙向關(guān)聯(lián)的例子。
實(shí)體類(lèi)：
Student.java

private int id ;
private String name ;
private Classes classes;

Classes.java

private int id ;
private String name ;
private Set students;

配置：
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="cn.itcast.hibernate.Student" table="_student">
        <id name="id">
            <generator class="native"/>
        </id>
        <property name="name"/>
        <many-to-one name="classes" column="classesid"/>
    </class>
</hibernate-mapping>

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 package="cn.itcast.hibernate">
    <class name="Classes" table="_classes">
        <id name="id">
            <generator class="native"/>
        </id>
        <property name="name"/>
        <set name="students" inverse="true" cascade="all" >
            <key column="classesid"/>
            <one-to-many class="Student"/>
        </set>
    </class>
</hibernate-mapping>

首先我們需要在數(shù)據(jù)庫(kù)中存入幾條數(shù)據(jù)。
測(cè)試：

  • 1.保持lazy默認(rèn)
    CollectionLazyTest1.java 
package cn.itcast.hibernate;
import java.util.Iterator;
import java.util.Set;
import org.hibernate.Session;
import org.junit.Test;
/*保持lazy默認(rèn)*/
public class CollectionLazyTest1 {
    
    @Test
    public void testLoad1(){
        Session session = null;
        try {
            session = HibernateUtils.getSession();
            session.beginTransaction();
            //不會(huì)發(fā)出sql
            Classes classes = (Classes) session.load(Classes.class, 1);
            
            //會(huì)發(fā)出sql
            System.out.println("classes.name = " + classes.getName());
            
            //不會(huì)發(fā)出sql
            Set students = classes.getStudents();
            
            //會(huì)發(fā)出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);
        }
    }
    @Test
    public void testLoad2() {
        Session session = null;
        try {
            session = HibernateUtils.getSession();
            session.beginTransaction();
            
            //不會(huì)發(fā)出sql
            Classes classes = (Classes)session.load(Classes.class, 1);
            
            //會(huì)發(fā)出sql
            System.out.println("classes.name=" + classes.getName());
            
            //不會(huì)發(fā)出sql
            Set students = classes.getStudents();
            
            //會(huì)發(fā)出sql,發(fā)出查詢(xún)?nèi)繑?shù)據(jù)的sql
            System.out.println("student.count=" + students.size());
            session.getTransaction().commit();
        }catch(Exception e) {
            e.printStackTrace();
            session.getTransaction().rollback();
        }finally {
            HibernateUtils.closeSession(session);
        }
    }   
}

說(shuō)明：這里我們可以看到在默認(rèn)情況下，不管是集合還是普通屬性都是支持延遲加載的。

  • 2.設(shè)置<class>標(biāo)簽上的lazy=false
    CellectionlazyTest2.java 
package cn.itcast.hibernate;
import java.util.Iterator;
import java.util.Set;
import junit.framework.TestCase;
import org.hibernate.Session;
/**
 * 設(shè)置<class>標(biāo)簽上的lazy=false
 * @author Administrator
 *
 */
public class CellectionlazyTest2 extends TestCase {

    public void testLoad1() {
        Session session = null;
        try {
            session = HibernateUtils.getSession();
            session.beginTransaction();
            
            //會(huì)發(fā)出sql
            Classes classes = (Classes)session.load(Classes.class, 1);
            
            //不會(huì)發(fā)出sql
            System.out.println("classes.name=" + classes.getName());
            
            //不會(huì)發(fā)出sql
            Set students = classes.getStudents();
            
            //會(huì)發(fā)出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);
        }
    }   
}

說(shuō)明：看以看到，當(dāng)我們將class標(biāo)簽上的lazy設(shè)置為false的時(shí)候，對(duì)于普通屬性就不支持延遲加載了，但是對(duì)于集合來(lái)說(shuō)，還是支持延遲加載的，這說(shuō)明，class上的lazy對(duì)于集合是沒(méi)有影響的。

  • 3.設(shè)置集合上的lazy=false,其它默認(rèn)
    CellectionlazyTest3.java 
package cn.itcast.hibernate;
import java.util.Iterator;
import java.util.Set;
import junit.framework.TestCase;
import org.hibernate.Session;
/**
 * 設(shè)置集合上的lazy=false,其它默認(rèn)
 *
 */
public class CellectionlazyTest3 extends TestCase {

    public void testLoad1() {
        Session session = null;
        try {
            session = HibernateUtils.getSession();
            session.beginTransaction();
            
            //不會(huì)發(fā)出sql
            Classes classes = (Classes)session.load(Classes.class, 1);
            
            //會(huì)發(fā)出sql,會(huì)發(fā)出兩條sql分別加載Classes和Student
            System.out.println("classes.name=" + classes.getName());
            
            //不會(huì)發(fā)出sql
            Set students = classes.getStudents();
            
            //不會(huì)發(fā)出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);
        }
    }   
    
    public void testLoad2() {
        Session session = null;
        try {
            session = HibernateUtils.getSession();
            session.beginTransaction();
            
            //不會(huì)發(fā)出sql
            Classes classes = (Classes)session.load(Classes.class, 1);
            
            //會(huì)發(fā)出sql,會(huì)發(fā)出兩條sql分別加載Classes和Count
            System.out.println("classes.name=" + classes.getName());
            
            //不會(huì)發(fā)出sql
            Set students = classes.getStudents();
            
            //不會(huì)發(fā)出sql
            System.out.println("student.count=" + students.size());
            session.getTransaction().commit();
        }catch(Exception e) {
            e.printStackTrace();
            session.getTransaction().rollback();
        }finally {
            HibernateUtils.closeSession(session);
        }
    }       
}

說(shuō)明：由于將集合的lazy設(shè)置為false，則集合不支持延遲加載，那么在使用到Classes的時(shí)候就會(huì)將查詢(xún)集合的sql語(yǔ)句也發(fā)出去。而在之后的操作中不再發(fā)送sql語(yǔ)句。但是在查詢(xún)集合中元素個(gè)數(shù)的時(shí)候不是發(fā)送的count語(yǔ)句，而是直接將集合整體查出來(lái)，再統(tǒng)計(jì)。

  • 4.設(shè)置集合上的lazy=extra,其它默認(rèn)
    CellectionlazyTest4.java 
package cn.itcast.hibernate;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
import junit.framework.TestCase;
import org.hibernate.Session;
/**
 * 設(shè)置集合上的lazy=extra,其它默認(rèn)
 * @author Administrator
 */
public class CellectionlazyTest4 extends TestCase {

    public void testLoad1() {
        Session session = null;
        try {
            session = HibernateUtils.getSession();
            session.beginTransaction();
            
            //不會(huì)發(fā)出sql
            Classes classes = (Classes)session.load(Classes.class, 1);
            
            //會(huì)發(fā)出sql
            System.out.println("classes.name=" + classes.getName());
            
            //不會(huì)發(fā)出sql
            Set students = classes.getStudents();
            
            //會(huì)發(fā)出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);
        }
    }   
    
    public void testLoad2() {
        Session session = null;
        try {
            session = HibernateUtils.getSession();
            session.beginTransaction();
            
            //不會(huì)發(fā)出sql
            Classes classes = (Classes)session.load(Classes.class, 1);
            
            //會(huì)發(fā)出sql
            System.out.println("classes.name=" + classes.getName());
            
            //不會(huì)發(fā)出sql
            Set students = classes.getStudents();
            //會(huì)發(fā)出sql,發(fā)出一條比較智能的sql
            System.out.println("student.count=" + students.size());
            session.getTransaction().commit();
        }catch(Exception e) {
            e.printStackTrace();
            session.getTransaction().rollback();
        }finally {
            HibernateUtils.closeSession(session);
        }
    }       
}

說(shuō)明：對(duì)于直接查詢(xún)出集合對(duì)象，和lazy為true的情況是一樣的，是在使用的時(shí)候才會(huì)發(fā)出，但是對(duì)于查詢(xún)集合中元素的個(gè)數(shù)則和上個(gè)例子不一樣了，這里是發(fā)送的count語(yǔ)句，效率會(huì)比較高，所以在實(shí)際開(kāi)發(fā)中一般使用此屬性。

四、用在單端關(guān)聯(lián)上（工程hibernate_lazy4single_end）

單端關(guān)聯(lián)有<one-to-one>和<many-to-one>，兩者比較類(lèi)似，這里我們使用后者作為例子。在單端關(guān)聯(lián)上的lazy策略可以取值為：false、proxy、noproxy。

相關(guān)實(shí)體類(lèi)：
Group.java

private int id; 
private String name;

User.java

private int id; 
private String name;
private Group group;

相關(guān)配置：
Group.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 package="cn.itcast.hibernate">
    <class name="Group" table="_group">
        <id name="id">
            <generator class="native"/>
        </id>
        <property name="name"/>
    </class>
</hibernate-mapping>

User.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 package="cn.itcast.hibernate">
    <class name="User" table="_user" lazy="false">
        <id name="id">
            <generator class="native"/>
        </id>
        <property name="name"/>
         <many-to-one name="group" column="groupid"/>
    </class>
</hibernate-mapping>

先想數(shù)據(jù)庫(kù)中存入一些數(shù)據(jù)：
InitData.java

package cn.itcast.hibernate;
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);
            
            User user1 = new User();
            user1.setName("張三");
            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);
        }
    }
}

測(cè)試：

  • 1.<many-to-one>的lazy保持默認(rèn)，即proxy。
    SingleEndTest1.java 
package cn.itcast.hibernate;
import org.hibernate.Session;
import org.junit.Test;
/**
 * 所有l(wèi)azy屬性默認(rèn)
 */
public class SingleEndTest1{
    @Test
    public void testLoad1() {
        Session session = null;
        try {
            session = HibernateUtils.getSession();
            session.beginTransaction();
            
            //不會(huì)發(fā)出sql
            User user = (User)session.load(User.class, 1);
            
            //會(huì)發(fā)出sql
            System.out.println("user.name=" + user.getName());
            
            //不會(huì)發(fā)出sql
            Group group = user.getGroup();
            
            //會(huì)發(fā)出sql
            System.out.println("group.name=" + group.getName());
            
            session.getTransaction().commit();
        }catch(Exception e) {
            e.printStackTrace();
            session.getTransaction().rollback();
        }finally {
            HibernateUtils.closeSession(session);
        }
    }   
}

說(shuō)明：可以看到這里的情況和集合的lazy策略一樣，都是在使用的時(shí)候才發(fā)出sql語(yǔ)句。

  • 2.將<many-to-one>中的lazy設(shè)置為false,其它默認(rèn)
    SingleEndTest2.java 
package cn.itcast.hibernate;
import org.hibernate.Session;
import org.junit.Test;
import junit.framework.TestCase;
/**
 * 將<many-to-one>中的lazy設(shè)置為false,其它默認(rèn)
 */
public class SingleEndTest2{
    @Test
    public void testLoad1() {
        Session session = null;
        try {
            session = HibernateUtils.getSession();
            session.beginTransaction();
            
            //不會(huì)發(fā)出sql
            User user = (User)session.load(User.class, 1);
            
            //會(huì)發(fā)出sql，發(fā)出兩條sql分別加載User和Group
            System.out.println("user.name=" + user.getName());
            
            //不會(huì)發(fā)出sql
            Group group = user.getGroup();
            
            //不會(huì)發(fā)出sql
            System.out.println("group.name=" + group.getName());
            
            session.getTransaction().commit();
        }catch(Exception e) {
            e.printStackTrace();
            session.getTransaction().rollback();
        }finally {
            HibernateUtils.closeSession(session);
        }
    }       
}

說(shuō)明：此時(shí)不支持延遲加載了，即在使用User的時(shí)候就會(huì)將Group查詢(xún)出來(lái)。

  • 3.<class>標(biāo)簽上的lazy=false,其它默認(rèn)
    SingleEndTest3.java 
package cn.itcast.hibernate;
import org.hibernate.Session;
import org.junit.Test;
/**
 * <class>標(biāo)簽上的lazy=false,其它默認(rèn)
 */
public class SingleEndTest3  {
    
    @Test
    public void testLoad1() {
        Session session = null;
        try {
            session = HibernateUtils.getSession();
            session.beginTransaction();
            
            //會(huì)發(fā)出sql
            User user = (User)session.load(User.class, 1);
            
            //不會(huì)發(fā)出sql
            System.out.println("user.name=" + user.getName());
            
            //不會(huì)發(fā)出sql
            Group group = user.getGroup();
            
            //會(huì)發(fā)出sql
            System.out.println("group.name=" + group.getName());
            
            session.getTransaction().commit();
        }catch(Exception e) {
            e.printStackTrace();
            session.getTransaction().rollback();
        }finally {
            HibernateUtils.closeSession(session);
        }
    }       
}

說(shuō)明：將普通屬性的lazy設(shè)置為false對(duì)單端關(guān)聯(lián)沒(méi)有影響，單端關(guān)聯(lián)的lazy策略此時(shí)還是proxy。對(duì)于noproxy用的不多，這里不再說(shuō)明。

最后編輯于 ：
?著作權(quán)歸作者所有,轉(zhuǎn)載或內(nèi)容合作請(qǐng)聯(lián)系作者
平臺(tái)聲明：文章內(nèi)容（如有圖片或視頻亦包括在內(nèi)）由作者上傳并發(fā)布，文章內(nèi)容僅代表作者本人觀點(diǎn)，簡(jiǎn)書(shū)系信息發(fā)布平臺(tái)，僅提供信息存儲(chǔ)服務(wù)。

推薦閱讀更多精彩內(nèi)容

  • 1. Java基礎(chǔ)部分 基礎(chǔ)部分的順序：基本語(yǔ)法，類(lèi)相關(guān)的語(yǔ)法，內(nèi)部類(lèi)的語(yǔ)法，繼承相關(guān)的語(yǔ)法，異常的語(yǔ)法，線程的語(yǔ)...
    子非魚(yú)_t_閱讀 31,778評(píng)論 18贊 399
  • 一. Java基礎(chǔ)部分.................................................
    wy_sure閱讀 3,839評(píng)論 0贊 11
  • 本文包括：1、Hibernate的持久化類(lèi)2、Hibernate 持久化對(duì)象的三個(gè)狀態(tài)（難點(diǎn)）3、Hibernat...
    廖少少閱讀 1,495評(píng)論 0贊 13
  • Spring Cloud為開(kāi)發(fā)人員提供了快速構(gòu)建分布式系統(tǒng)中一些常見(jiàn)模式的工具（例如配置管理，服務(wù)發(fā)現(xiàn)，斷路器，智...
    卡卡羅2017閱讀 134,992評(píng)論 19贊 139
  • 學(xué)霸的體質(zhì)并不是與生俱來(lái)的，更多的是后天養(yǎng)成的。從強(qiáng)迫到習(xí)慣到最后深入骨髓。就像我們知道的那句話(huà)，腹有詩(shī)書(shū)氣自華。...
    七月妮安閱讀 86,123評(píng)論 947贊 5,626