9.Lazy策略（hibernate筆記）

一、簡介

延遲加載就是我們真正使用某個對象的時候，這個對象才會被創建出來。而在hibernate中的意思就是只有我們真正需要使用某個對象的時候，才會去查詢。采用第三方的一個庫cglab，生成代理類。和jdk的動態代理的區別是cglab能對類進行代理（繼承原先的類生成一個子類，子類作為代理類），而jdk的動態代理只能對實現了接口的類進行代理。

hibernate的lazy策略可以使用在：
- <class>標簽上，可以取值：true、false，默認是true，打開。
- <property>標簽上，可以取值true、false，默認是true打開，使用較少。需要類增強工具（不講）。
- <set><list>標簽上，可以取值true、false、extra
- <one_to_one><many_to_one>標簽中，單端關聯上，可以取值：false、proxy、noproxy
代理的概念：只有真正使用該對象時才會創建，對于hibernate來說就是只有真正使用的時候才會發出sql。注意：lazy和Session的生命周期一致。

二、用在class標簽上（工程`hibernate_lazy4class`）

實體類（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>

先在數據庫中存入一些數據：
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);
        }
    }
}

測試：
ClassLazyTest.java

package cn.itcast.hibernate;
import org.hibernate.Session;
import org.junit.Test;
/*
 *在測試的時候有個條件是：設置<class>標簽上的lazy=true，也就是默認配置 
 * */
public class ClassLazyTest {
    
    @Test
    public void testLoad1(){
        Session session = null;
        try {
            session = HibernateUtils.getSession();
            session.beginTransaction();
            //不會發sql，因為沒有真正用到
            Group gorup = (Group) session.load(Group.class, 1);
            
            //這里是不會發sql的，因為主鍵在上面已經給出了
            System.out.println("group.id = " + gorup.getId());
            //這里是要發sql的，因為需要用到
            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);
            
        }
        //不能正確執行，拋出異常，因為session已經關閉，hibernate支持lazy策略只有在session打開狀態下有效
        System.out.println("group.name = " + group.getName());
    }
}

三、用在集合標簽上（工程`hibernate_lazy4collection`）

這里我們使用一對多雙向關聯的例子。
實體類：
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>

首先我們需要在數據庫中存入幾條數據。
測試：

1.保持lazy默認
CollectionLazyTest1.java

package cn.itcast.hibernate;
import java.util.Iterator;
import java.util.Set;
import org.hibernate.Session;
import org.junit.Test;
/*保持lazy默認*/
public class CollectionLazyTest1 {
    
    @Test
    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 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);
        }
    }
    @Test
    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 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);
        }
    }   
}

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

2.設置<class>標簽上的lazy=false
CellectionlazyTest2.java

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

說明：看以看到，當我們將class標簽上的lazy設置為false的時候，對于普通屬性就不支持延遲加載了，但是對于集合來說，還是支持延遲加載的，這說明，class上的lazy對于集合是沒有影響的。

3.設置集合上的lazy=false,其它默認
CellectionlazyTest3.java

package cn.itcast.hibernate;
import java.util.Iterator;
import java.util.Set;
import junit.framework.TestCase;
import org.hibernate.Session;
/**
 * 設置集合上的lazy=false,其它默認
 *
 */
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 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);
        }
    }   
    
    public void testLoad2() {
        Session session = null;
        try {
            session = HibernateUtils.getSession();
            session.beginTransaction();
            
            //不會發出sql
            Classes classes = (Classes)session.load(Classes.class, 1);
            
            //會發出sql,會發出兩條sql分別加載Classes和Count
            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);
        }
    }       
}

說明：由于將集合的lazy設置為false，則集合不支持延遲加載，那么在使用到Classes的時候就會將查詢集合的sql語句也發出去。而在之后的操作中不再發送sql語句。但是在查詢集合中元素個數的時候不是發送的count語句，而是直接將集合整體查出來，再統計。

4.設置集合上的lazy=extra,其它默認
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;
/**
 * 設置集合上的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 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);
        }
    }   
    
    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 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);
        }
    }       
}

說明：對于直接查詢出集合對象，和lazy為true的情況是一樣的，是在使用的時候才會發出，但是對于查詢集合中元素的個數則和上個例子不一樣了，這里是發送的count語句，效率會比較高，所以在實際開發中一般使用此屬性。

四、用在單端關聯上（工程`hibernate_lazy4single_end`）

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

相關實體類：
Group.java

private int id; 
private String name;

User.java

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

相關配置：
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>

先想數據庫中存入一些數據：
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);
        }
    }
}

測試：

1.<many-to-one>的lazy保持默認，即proxy。
SingleEndTest1.java

package cn.itcast.hibernate;
import org.hibernate.Session;
import org.junit.Test;
/**
 * 所有lazy屬性默認
 */
public class SingleEndTest1{
    @Test
    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);
        }
    }   
}

說明：可以看到這里的情況和集合的lazy策略一樣，都是在使用的時候才發出sql語句。

2.將<many-to-one>中的lazy設置為false,其它默認
SingleEndTest2.java

package cn.itcast.hibernate;
import org.hibernate.Session;
import org.junit.Test;
import junit.framework.TestCase;
/**
 * 將<many-to-one>中的lazy設置為false,其它默認
 */
public class SingleEndTest2{
    @Test
    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);
        }
    }       
}

說明：此時不支持延遲加載了，即在使用User的時候就會將Group查詢出來。

3.<class>標簽上的lazy=false,其它默認
SingleEndTest3.java

package cn.itcast.hibernate;
import org.hibernate.Session;
import org.junit.Test;
/**
 * <class>標簽上的lazy=false,其它默認
 */
public class SingleEndTest3  {
    
    @Test
    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);
        }
    }       
}

說明：將普通屬性的lazy設置為false對單端關聯沒有影響，單端關聯的lazy策略此時還是proxy。對于noproxy用的不多，這里不再說明。

最后編輯于：2017.12.03 05:54:41

?著作權歸作者所有,轉載或內容合作請聯系作者
平臺聲明：文章內容（如有圖片或視頻亦包括在內）由作者上傳并發布，文章內容僅代表作者本人觀點，簡書系信息發布平臺，僅提供信息存儲服務。

人面猴
序言：七十年代末，一起剝皮案震驚了整個濱河市，隨后出現的幾起案子，更是在濱河造成了極大的恐慌，老刑警劉巖，帶你破解...
沈念sama閱讀 230,182評論 6贊 543
死咒
序言：濱河連續發生了三起死亡事件，死亡現場離奇詭異，居然都是意外死亡，警方通過查閱死者的電腦和手機，發現死者居然都...
沈念sama閱讀 99,489評論 3贊 429
救了他兩次的神仙讓他今天三更去死
文/潘曉璐我一進店門，熙熙樓的掌柜王于貴愁眉苦臉地迎上來，“玉大人，你說我怎么就攤上這事。” “怎么了？”我有些...
開封第一講書人閱讀 178,290評論 0贊 383
道士緝兇錄：失蹤的賣姜人
文/不壞的土叔我叫張陵，是天一觀的道長。經常有香客問我，道長，這世上最難降的妖魔是什么？我笑而不...
開封第一講書人閱讀 63,776評論 1贊 317
?港島之戀（遺憾婚禮）
正文為了忘掉前任，我火速辦了婚禮，結果婚禮上，老公的妹妹穿的比我還像新娘。我一直安慰自己，他們只是感情好，可當我...
茶點故事閱讀 72,510評論 6贊 412
惡毒庶女頂嫁案：這布局不是一般人想出來的
文/花漫我一把揭開白布。她就那樣靜靜地躺著，像睡著了一般。火紅的嫁衣襯著肌膚如雪。梳的紋絲不亂的頭發上，一...
開封第一講書人閱讀 55,866評論 1贊 328
城市分裂傳說
那天，我揣著相機與錄音，去河邊找鬼。笑死，一個胖子當著我的面吹牛，可吹牛的內容都是我干的。我是一名探鬼主播，決...
沈念sama閱讀 43,860評論 3贊 447
雙鴛鴦連環套：你想象不到人心有多黑
文/蒼蘭香墨我猛地睜開眼，長吁一口氣：“原來是場噩夢啊……” “哼！你這毒婦竟也來了？” 一聲冷哼從身側響起，我...
開封第一講書人閱讀 43,036評論 0贊 290
萬榮殺人案實錄
序言：老撾萬榮一對情侶失蹤，失蹤者是張志新（化名）和其女友劉穎，沒想到半個月后，有當地人在樹林里發現了一具尸體，經...
沈念sama閱讀 49,585評論 1贊 336
?護林員之死
正文獨居荒郊野嶺守林人離奇死亡，尸身上長有42處帶血的膿包…… 初始之章·張勛以下內容為張勛視角年9月15日...
茶點故事閱讀 41,331評論 3贊 358
?白月光啟示錄
正文我和宋清朗相戀三年，在試婚紗的時候發現自己被綠了。大學時的朋友給我發了我未婚夫和他白月光在一起吃飯的照片。...
茶點故事閱讀 43,536評論 1贊 374
活死人
序言：一個原本活蹦亂跳的男人離奇死亡，死狀恐怖，靈堂內的尸體忽然破棺而出，到底是詐尸還是另有隱情，我是刑警寧澤，帶...
沈念sama閱讀 39,058評論 5贊 363
?日本核電站爆炸內幕
正文年R本政府宣布，位于F島的核電站，受9級特大地震影響，放射性物質發生泄漏。R本人自食惡果不足惜，卻給世界環境...
茶點故事閱讀 44,754評論 3贊 349
男人毒藥：我在死后第九天來索命
文/蒙蒙一、第九天我趴在偏房一處隱蔽的房頂上張望。院中可真熱鬧，春花似錦、人聲如沸。這莊子的主人今日做“春日...
開封第一講書人閱讀 35,154評論 0贊 28
一樁弒父案，背后竟有這般陰謀
文/蒼蘭香墨我抬頭看了看天上的太陽。三九已至，卻和暖如春，著一層夾襖步出監牢的瞬間，已是汗流浹背。一陣腳步聲響...
開封第一講書人閱讀 36,469評論 1贊 295
情欲美人皮
我被黑心中介騙來泰國打工，沒想到剛下飛機就差點兒被人妖公主榨干…… 1. 我叫王不留，地道東北人。一個月前我還...
沈念sama閱讀 52,273評論 3贊 399
代替公主和親
正文我出身青樓，卻偏偏與公主長得像，于是被迫代替她去往敵國和親。傳聞我的和親對象是個殘疾皇子，可洞房花燭夜當晚...
茶點故事閱讀 48,505評論 2贊 379

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美国产综合欧美视频

9.Lazy策略（hibernate筆記）

9.Lazy策略（hibernate筆記）

一、簡介

二、用在class標簽上（工程`hibernate_lazy4class`）

三、用在集合標簽上（工程`hibernate_lazy4collection`）

四、用在單端關聯上（工程`hibernate_lazy4single_end`）

推薦閱讀更多精彩內容

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美 国产 综合 欧美 视频

9.Lazy策略（hibernate筆記）

一、簡介

二、用在class標簽上（工程hibernate_lazy4class）

三、用在集合標簽上（工程hibernate_lazy4collection）

四、用在單端關聯上（工程hibernate_lazy4single_end）

推薦閱讀更多精彩內容

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美国产综合欧美视频

二、用在class標簽上（工程`hibernate_lazy4class`）

三、用在集合標簽上（工程`hibernate_lazy4collection`）

四、用在單端關聯上（工程`hibernate_lazy4single_end`）