9.Lazy策略（hibernate筆記）

一、簡介

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

hibernate的lazy策略可以使用在：
- <class>標(biāo)簽上坯癣，可以取值：true瓶盛、false，默認(rèn)是true示罗，打開惩猫。
- <property>標(biāo)簽上，可以取值true蚜点、false轧房，默認(rèn)是true打開，使用較少禽额。需要類增強(qiáng)工具（不講）锯厢。
- <set><list>標(biāo)簽上，可以取值true脯倒、false实辑、extra
- <one_to_one><many_to_one>標(biāo)簽中，單端關(guān)聯(lián)上藻丢，可以取值：false剪撬、proxy、noproxy
代理的概念：只有真正使用該對象時才會創(chuàng)建悠反，對于hibernate來說就是只有真正使用的時候才會發(fā)出sql残黑。注意：lazy和Session的生命周期一致。

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

實(shí)體類（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ù)庫中存入一些數(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);
        }
    }
}

測試：
ClassLazyTest.java

package cn.itcast.hibernate;
import org.hibernate.Session;
import org.junit.Test;
/*
 *在測試的時候有個條件是：設(shè)置<class>標(biāo)簽上的lazy=true梨水，也就是默認(rèn)配置 
 * */
public class ClassLazyTest {
    
    @Test
    public void testLoad1(){
        Session session = null;
        try {
            session = HibernateUtils.getSession();
            session.beginTransaction();
            //不會發(fā)sql，因?yàn)闆]有真正用到
            Group gorup = (Group) session.load(Group.class, 1);
            
            //這里是不會發(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打開狀態(tài)下有效
        System.out.println("group.name = " + group.getName());
    }
}

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

這里我們使用一對多雙向關(guān)聯(lián)的例子缨硝。
實(shí)體類：
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ù)庫中存入幾條數(shù)據(jù)摩钙。
測試：

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();
            //不會發(fā)出sql
            Classes classes = (Classes) session.load(Classes.class, 1);
            
            //會發(fā)出sql
            System.out.println("classes.name = " + classes.getName());
            
            //不會發(fā)出sql
            Set students = classes.getStudents();
            
            //會發(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();
            
            //不會發(fā)出sql
            Classes classes = (Classes)session.load(Classes.class, 1);
            
            //會發(fā)出sql
            System.out.println("classes.name=" + classes.getName());
            
            //不會發(fā)出sql
            Set students = classes.getStudents();
            
            //會發(fā)出sql,發(fā)出查詢?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);
        }
    }   
}

說明：這里我們可以看到在默認(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();
            
            //會發(fā)出sql
            Classes classes = (Classes)session.load(Classes.class, 1);
            
            //不會發(fā)出sql
            System.out.println("classes.name=" + classes.getName());
            
            //不會發(fā)出sql
            Set students = classes.getStudents();
            
            //會發(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);
        }
    }   
}

說明：看以看到胖笛，當(dāng)我們將class標(biāo)簽上的lazy設(shè)置為false的時候，對于普通屬性就不支持延遲加載了宜岛，但是對于集合來說匀钧，還是支持延遲加載的，這說明谬返，class上的lazy對于集合是沒有影響的之斯。

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

說明：由于將集合的lazy設(shè)置為false，則集合不支持延遲加載遣铝，那么在使用到Classes的時候就會將查詢集合的sql語句也發(fā)出去佑刷。而在之后的操作中不再發(fā)送sql語句。但是在查詢集合中元素個數(shù)的時候不是發(fā)送的count語句酿炸，而是直接將集合整體查出來瘫絮，再統(tǒng)計。

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();
            
            //不會發(fā)出sql
            Classes classes = (Classes)session.load(Classes.class, 1);
            
            //會發(fā)出sql
            System.out.println("classes.name=" + classes.getName());
            
            //不會發(fā)出sql
            Set students = classes.getStudents();
            
            //會發(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();
            
            //不會發(fā)出sql
            Classes classes = (Classes)session.load(Classes.class, 1);
            
            //會發(fā)出sql
            System.out.println("classes.name=" + classes.getName());
            
            //不會發(fā)出sql
            Set students = classes.getStudents();
            //會發(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);
        }
    }       
}

說明：對于直接查詢出集合對象填硕，和lazy為true的情況是一樣的麦萤，是在使用的時候才會發(fā)出鹿鳖，但是對于查詢集合中元素的個數(shù)則和上個例子不一樣了，這里是發(fā)送的count語句壮莹，效率會比較高翅帜，所以在實(shí)際開發(fā)中一般使用此屬性。

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

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

相關(guān)實(shí)體類：
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ù)庫中存入一些數(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);
        }
    }
}

測試：

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();
            
            //不會發(fā)出sql
            User user = (User)session.load(User.class, 1);
            
            //會發(fā)出sql
            System.out.println("user.name=" + user.getName());
            
            //不會發(fā)出sql
            Group group = user.getGroup();
            
            //會發(fā)出sql
            System.out.println("group.name=" + group.getName());
            
            session.getTransaction().commit();
        }catch(Exception e) {
            e.printStackTrace();
            session.getTransaction().rollback();
        }finally {
            HibernateUtils.closeSession(session);
        }
    }   
}

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

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();
            
            //不會發(fā)出sql
            User user = (User)session.load(User.class, 1);
            
            //會發(fā)出sql，發(fā)出兩條sql分別加載User和Group
            System.out.println("user.name=" + user.getName());
            
            //不會發(fā)出sql
            Group group = user.getGroup();
            
            //不會發(fā)出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>標(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();
            
            //會發(fā)出sql
            User user = (User)session.load(User.class, 1);
            
            //不會發(fā)出sql
            System.out.println("user.name=" + user.getName());
            
            //不會發(fā)出sql
            Group group = user.getGroup();
            
            //會發(fā)出sql
            System.out.println("group.name=" + group.getName());
            
            session.getTransaction().commit();
        }catch(Exception e) {
            e.printStackTrace();
            session.getTransaction().rollback();
        }finally {
            HibernateUtils.closeSession(session);
        }
    }       
}

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

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

?著作權(quán)歸作者所有,轉(zhuǎn)載或內(nèi)容合作請聯(lián)系作者

人面猴
序言：七十年代末丘跌，一起剝皮案震驚了整個濱河市袭景，隨后出現(xiàn)的幾起案子，更是在濱河造成了極大的恐慌闭树，老刑警劉巖耸棒，帶你破解...
沈念sama閱讀 221,695評論 6贊 515
死咒
序言：濱河連續(xù)發(fā)生了三起死亡事件，死亡現(xiàn)場離奇詭異报辱，居然都是意外死亡与殃，警方通過查閱死者的電腦和手機(jī)，發(fā)現(xiàn)死者居然都...
沈念sama閱讀 94,569評論 3贊 399
救了他兩次的神仙讓他今天三更去死
文/潘曉璐我一進(jìn)店門碍现，熙熙樓的掌柜王于貴愁眉苦臉地迎上來幅疼，“玉大人，你說我怎么就攤上這事昼接∷瘢” “怎么了？”我有些...
開封第一講書人閱讀 168,130評論 0贊 360
道士緝兇錄：失蹤的賣姜人
文/不壞的土叔我叫張陵慢睡，是天一觀的道長逐工。經(jīng)常有香客問我铡溪，道長，這世上最難降的妖魔是什么泪喊？我笑而不...
開封第一講書人閱讀 59,648評論 1贊 297
?港島之戀（遺憾婚禮）
正文為了忘掉前任棕硫，我火速辦了婚禮，結(jié)果婚禮上窘俺，老公的妹妹穿的比我還像新娘饲帅。我一直安慰自己复凳，他們只是感情好瘤泪，可當(dāng)我...
茶點(diǎn)故事閱讀 68,655評論 6贊 397
惡毒庶女頂嫁案：這布局不是一般人想出來的
文/花漫我一把揭開白布。她就那樣靜靜地躺著育八，像睡著了一般对途。火紅的嫁衣襯著肌膚如雪。梳的紋絲不亂的頭發(fā)上髓棋，一...
開封第一講書人閱讀 52,268評論 1贊 309
城市分裂傳說
那天实檀，我揣著相機(jī)與錄音，去河邊找鬼按声。笑死膳犹，一個胖子當(dāng)著我的面吹牛，可吹牛的內(nèi)容都是我干的签则。我是一名探鬼主播须床，決...
沈念sama閱讀 40,835評論 3贊 421
雙鴛鴦連環(huán)套：你想象不到人心有多黑
文/蒼蘭香墨我猛地睜開眼，長吁一口氣：“原來是場噩夢啊……” “哼渐裂！你這毒婦竟也來了豺旬？” 一聲冷哼從身側(cè)響起，我...
開封第一講書人閱讀 39,740評論 0贊 276
萬榮殺人案實(shí)錄
序言：老撾萬榮一對情侶失蹤柒凉，失蹤者是張志新（化名）和其女友劉穎族阅，沒想到半個月后，有當(dāng)?shù)厝嗽跇淞掷锇l(fā)現(xiàn)了一具尸體膝捞，經(jīng)...
沈念sama閱讀 46,286評論 1贊 318
?護(hù)林員之死
正文獨(dú)居荒郊野嶺守林人離奇死亡坦刀，尸身上長有42處帶血的膿包…… 初始之章·張勛以下內(nèi)容為張勛視角年9月15日...
茶點(diǎn)故事閱讀 38,375評論 3贊 340
?白月光啟示錄
正文我和宋清朗相戀三年，在試婚紗的時候發(fā)現(xiàn)自己被綠了蔬咬。大學(xué)時的朋友給我發(fā)了我未婚夫和他白月光在一起吃飯的照片求泰。...
茶點(diǎn)故事閱讀 40,505評論 1贊 352
活死人
序言：一個原本活蹦亂跳的男人離奇死亡，死狀恐怖计盒，靈堂內(nèi)的尸體忽然破棺而出渴频，到底是詐尸還是另有隱情，我是刑警寧澤北启，帶...
沈念sama閱讀 36,185評論 5贊 350
?日本核電站爆炸內(nèi)幕
正文年R本政府宣布卜朗，位于F島的核電站拔第，受9級特大地震影響，放射性物質(zhì)發(fā)生泄漏场钉。R本人自食惡果不足惜蚊俺，卻給世界環(huán)境...
茶點(diǎn)故事閱讀 41,873評論 3贊 333
男人毒藥：我在死后第九天來索命
文/蒙蒙一、第九天我趴在偏房一處隱蔽的房頂上張望逛万。院中可真熱鬧泳猬，春花似錦、人聲如沸宇植。這莊子的主人今日做“春日...
開封第一講書人閱讀 32,357評論 0贊 24
一樁弒父案，背后竟有這般陰謀
文/蒼蘭香墨我抬頭看了看天上的太陽指郁。三九已至畦戒，卻和暖如春寿弱，著一層夾襖步出監(jiān)牢的瞬間，已是汗流浹背。一陣腳步聲響...
開封第一講書人閱讀 33,466評論 1贊 272
情欲美人皮
我被黑心中介騙來泰國打工寥院，沒想到剛下飛機(jī)就差點(diǎn)兒被人妖公主榨干…… 1. 我叫王不留肤无，地道東北人刁俭。一個月前我還...
沈念sama閱讀 48,921評論 3贊 376
代替公主和親
正文我出身青樓隅津，卻偏偏與公主長得像，于是被迫代替她去往敵國和親绣溜。傳聞我的和親對象是個殘疾皇子慷彤，可洞房花燭夜當(dāng)晚...
茶點(diǎn)故事閱讀 45,515評論 2贊 359

9.Lazy策略（hibernate筆記）

一、簡介

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

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

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

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

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

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

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