1、概況
（1）瞬時(shí)狀態(tài)（臨時(shí)態(tài)）
在對象中如果對象剛被創(chuàng)建但沒有被持久化的話就是瞬時(shí)態(tài)
特點(diǎn)：
(1) 不和 Session 實(shí)例關(guān)聯(lián)
(2)在http://www.vxbq.cn/db/中沒有和瞬時(shí)對象關(guān)聯(lián)的記錄
（2）持久狀態(tài)
持久化對象就是已被保存進(jìn)http://www.vxbq.cn/db/的實(shí)體對象，并且這個(gè)實(shí)體對象現(xiàn)在還處于Hibernate的Session緩存管理當(dāng)中。這時(shí)對該實(shí)體對象的任何修改，都會(huì)在清算緩存時(shí)同步到http://www.vxbq.cn/db/中。
特點(diǎn)：
（1）持久的實(shí)例在http://www.vxbq.cn/db/中有對應(yīng)的記錄，并具有1個(gè)持久化標(biāo)識(identifier).
（2）和session相干聯(lián)的對象
（3）游離狀態(tài)（托管狀態(tài)、離線狀態(tài)）
當(dāng)1個(gè)持久化對象，脫離開Hibernate的緩存管理后，它就處于游離狀態(tài)，游離對象和自由對象的最大區(qū)分在于，游離對象在http://www.vxbq.cn/db/中可能還存在1條與它對應(yīng)的記錄，只是現(xiàn)在這個(gè)游離對象脫離了Hibernate的緩存管理，而自由對象不會(huì)在http://www.vxbq.cn/db/中出現(xiàn)與它對應(yīng)的數(shù)據(jù)記錄。
特點(diǎn)：
(1) 本質(zhì)上和瞬時(shí)對象相同
(2)只是比瞬時(shí)對象多了1個(gè)http://www.vxbq.cn/db/記錄標(biāo)識值id。
2、轉(zhuǎn)化圖
通過以下的轉(zhuǎn)換圖就能夠明白3態(tài)之間是如何轉(zhuǎn)換的，如果將這幅圖印在自己的頭腦里，3態(tài)就沒甚么神圣的啦！
3、實(shí)戰(zhàn)
以上是對3態(tài)理論知識上的講授，那末接下來就從實(shí)際代碼中體驗(yàn)1下它們的奧妙吧！
1.TestTransient
session = HibernateUtil.openSession();
session.beginTransaction();
User user = new User();
user.setUsername("aaa");
user.setPassword("aaa");
user.setBorn(new Date());
/*
* 以上user就是1個(gè)Transient(瞬時(shí)狀態(tài)),此時(shí)user并沒有被session進(jìn)行托管，即在session的
* 緩存中還不存在user這個(gè)對象，當(dāng)履行完save方法后，此時(shí)user被session托管，并且http://www.vxbq.cn/db/中存在了該對象
* user就變成了1個(gè)Persistent(持久化對象)
*/
session.save(user);
session.getTransaction().commit();
此時(shí)我們知道hibernate會(huì)發(fā)出1條insert的語句，履行完save方法后，該user對象就變成了持久化的對象了
Hibernate: insertinto t_user (born, password, username) values (?, ?, ?)
2.TestPersistent01
session = HibernateUtil.openSession();
session.beginTransaction();
User user = new User();
user.setUsername("aaa");
user.setPassword("aaa");
user.setBorn(new Date());
//以上u就是Transient（瞬時(shí)狀態(tài)），表示沒有被session管理并且http://www.vxbq.cn/db/中沒有
//履行save以后，被session所管理，而且，http://www.vxbq.cn/db/中已存在，此時(shí)就是Persistent狀態(tài)
session.save(user);
//此時(shí)u是持久化狀態(tài)，已被session所管理，當(dāng)在提交時(shí)，會(huì)把session中的對象和目前的對象進(jìn)行比較
//如果兩個(gè)對象中的值不1致就會(huì)繼續(xù)發(fā)出相應(yīng)的sql語句
user.setPassword("bbb");
//此時(shí)會(huì)發(fā)出2條sql，1條用戶做插入，1條用來做更新
session.getTransaction().commit();
在調(diào)用了save方法后，此時(shí)user已是持久化對象了，被保存在了session緩存當(dāng)中，這時(shí)候user又重新修改了屬性值，那末在提交事務(wù)時(shí)，此時(shí)hibernate對象就會(huì)拿當(dāng)前這個(gè)user對象和保存在session緩存中的user對象進(jìn)行比較，如果兩個(gè)對象相同，則不會(huì)發(fā)送update語句，否則，如果兩個(gè)對象不同，則會(huì)發(fā)出update語句。
Hibernate: insertinto t_user (born, password, username) values (?, ?, ?)
Hibernate: updatet_user set born=?, password=?, username=? where id=?
3.TestPersistent02
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
session =HibernateUtil.openSession();
session.beginTransaction();
User u = new User();
u.setBorn(new Date());
u.setUsername("zhangsan");
u.setPassword("zhangsan");
session.save(u);
u.setPassword("222");
//該條語句沒成心義
session.save(u);
u.setPassword("zhangsan111");
//沒成心義
session.update(u);
u.setBorn(sdf.parse("1988⑴2⑵2"));
//沒成心義
session.update(u);
session.getTransaction().commit();
這個(gè)時(shí)候會(huì)發(fā)出多少sql語句呢？還是一樣的道理，在調(diào)用save方法后，u此時(shí)已是持久化對象了，記住1點(diǎn)：如果1個(gè)對象和是持久化狀態(tài)了，那末此時(shí)對該對象進(jìn)行各種修改，或調(diào)用屢次update、save方法時(shí)，hibernate都不會(huì)發(fā)送sql語句，只有當(dāng)事物提交的時(shí)候，此時(shí)hibernate才會(huì)拿當(dāng)前這個(gè)對象與之前保存在session中的持久化對象進(jìn)行比較，如果不相同就發(fā)送1條update的sql語句，否則就不會(huì)發(fā)送update語句
Hibernate: insertinto t_user (born, password, username) values (?, ?, ?)
Hibernate: updatet_user set born=?, password=?, username=? where id=?
4.TestPersistent03
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
session =HibernateUtil.openSession();
session.beginTransaction();
User u = new User();
u.setBorn(sdf.parse("1976⑵⑶"));
u.setUsername("zhangsan2");
u.setPassword("zhangsan2");
session.save(u);
/*
* 以下3條語句沒有任何意義
*/
session.save(u);
session.update(u);
session.update(u);
u.setUsername("zhangsan3");
session.getTransaction().commit();
相信這個(gè)測試用例，大家應(yīng)當(dāng)都知道結(jié)果了，沒錯(cuò)，此時(shí)hibernate也會(huì)發(fā)出兩條sql語句，原理1樣的
Hibernate: insertinto t_user (born, password, username) values (?, ?, ?)
Hibernate: updatet_user set born=?, password=?, username=? where id=?
5.TestPersistent04
session = HibernateUtil.openSession();
session.beginTransaction();
//此時(shí)u是Persistent
User u =(User)session.load(User.class, 4);
//由于u這個(gè)對象和session中的對象不1致，所以會(huì)發(fā)出sql完成更新
u.setUsername("bbb");
session.getTransaction().commit();
我們來看看此時(shí)會(huì)發(fā)出多少sql語句呢？一樣記住1點(diǎn)：當(dāng)session調(diào)用load、get方法時(shí)，此時(shí)如果http://www.vxbq.cn/db/中有該對象，則該對象也變成了1個(gè)持久化對象，被session所托管。因此，這個(gè)時(shí)候如果對對象進(jìn)行操作，在提交事務(wù)時(shí)一樣會(huì)去與session中的持久化對象進(jìn)行比較，因此這里會(huì)發(fā)送兩條sql語句
Hibernate: selectuser0_.id as id0_0_, user0_.born as born0_0_, user0_.password as password0_0_,user0_.username as username0_0_ from t_user user0_ where user0_.id=?
Hibernate: updatet_user set born=?, password=?, username=? where id=?
6.TestPersistent05
session = HibernateUtil.openSession();
session.beginTransaction();
//此時(shí)u是Persistent
User u =(User)session.load(User.class, 4);
u.setUsername("123");
//清空session
session.clear();
session.getTransaction().commit();
再看這個(gè)例子，當(dāng)我們load出user對象時(shí)，此時(shí)user是持久化的對象，在session緩存中存在該對象，此時(shí)我們在對user進(jìn)行修改后，然后調(diào)用session.clear()方法，這個(gè)時(shí)候就會(huì)將session的緩存對象清空，那末session中就沒有了user這個(gè)對象，這個(gè)時(shí)候在提交事務(wù)的時(shí)候，發(fā)現(xiàn)已session中已沒有該對象了，所以就不會(huì)進(jìn)行任何操作，因此這里只會(huì)發(fā)送1條select語句
Hibernate: selectuser0_.id as id0_0_, user0_.born as born0_0_, user0_.password as password0_0_,user0_.username as username0_0_ from t_user user0_ where user0_.id=?
7.TestDetached01
session = HibernateUtil.openSession();
session.beginTransaction();
//此時(shí)u是1個(gè)離線對象，沒有被session托管
User u = new User();
u.setId(4);
u.setPassword("hahahaha");
//當(dāng)履行save的時(shí)候總是會(huì)添加1條數(shù)據(jù)，此時(shí)id就會(huì)根據(jù)Hibernate所定義的規(guī)則來生成
session.save(u);
session.getTransaction().commit();
我們看到，當(dāng)調(diào)用了u.setId(4)時(shí)，此時(shí)u是1個(gè)離線的對象，由于http://www.vxbq.cn/db/中存在id=4的這個(gè)對象，但是該對象又沒有被session所托管，所以這個(gè)對象就是離線的對象，要使離線對象變成1個(gè)持久化的對象，應(yīng)當(dāng)調(diào)用甚么方法呢？我們知道調(diào)用save方法，可以將1個(gè)對象變成1個(gè)持久化對象，但是，當(dāng)save1履行的時(shí)候，此時(shí)hibernate會(huì)根據(jù)id的生成策略往http://www.vxbq.cn/db/中再插入1條數(shù)據(jù)，所以如果調(diào)用save方法，此時(shí)http://www.vxbq.cn/db/會(huì)發(fā)送1條插入的語句：
Hibernate: insertinto t_user (born, password, username) values (?, ?, ?)
所以對離線對象，如果要使其變成持久化對象的話，我們不能使用save方法，而應(yīng)當(dāng)使用update方法
8.TestDetached02
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
session =HibernateUtil.openSession();
session.beginTransaction();
User u = new User();
u.setId(5);
//完成update以后也會(huì)變成持久化狀態(tài)
session.update(u);
u.setBorn(sdf.parse("1998⑴2⑵2"));
u.setPassword("world");
u.setUsername("world");
//會(huì)發(fā)出1條sql
session.update(u);
session.getTransaction().commit();
此時(shí)我們看到，當(dāng)調(diào)用了update方法以后，此時(shí)u已變成了1個(gè)持久化的對象，那末如果此時(shí)對u對象進(jìn)行修改操作后，在事務(wù)提交的時(shí)候，則會(huì)拿該對象和session中剛保存的持久化對象進(jìn)行比較，如果不同就發(fā)1條sql語句
Hibernate: updatet_user set born=?, password=?, username=? where id=?
9.TestDetached03
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
session =HibernateUtil.openSession();
session.beginTransaction();
User u = new User();
u.setId(5);
//完成update以后也會(huì)變成持久化狀態(tài)
session.update(u);
u.setBorn(sdf.parse("1998⑴2⑵2"));
u.setPassword("lisi");
u.setUsername("lisi");
//會(huì)拋出異常
u.setId(333);
session.getTransaction().commit();
我們看這個(gè)例子，前面的操作1樣，調(diào)用update方法后，user變成了1個(gè)持久化對象，在對user進(jìn)行1些修改后，此時(shí)又通過u.setId(333)方法設(shè)置了u的ID，那末這個(gè)時(shí)候，hibernate會(huì)報(bào)錯(cuò)，由于我們的u當(dāng)前已是1個(gè)持久化對象，如果試圖修改1個(gè)持久化對象的ID的值的話，就會(huì)拋出異常，這點(diǎn)要特別注意
org.hibernate.HibernateException:identifier of an instance of com.xiaoluo.bean.User was altered from 5 to 333
10.TestDetached04
session = HibernateUtil.openSession();
session.beginTransaction();
User u = new User();
u.setId(5);
//現(xiàn)在u就是transient對象
session.delete(u);
//此時(shí)u已是瞬時(shí)對象，不會(huì)被session和http://www.vxbq.cn/db/所管理
u.setPassword("wangwu");
session.getTransaction().commit();
接著我們來看這個(gè)例子，這里在調(diào)用了session.delete()方法以后，此時(shí)后u就會(huì)變成1個(gè)瞬時(shí)對象，由于此時(shí)http://www.vxbq.cn/db/中已不存在該對象了，既然u已是1個(gè)瞬時(shí)對象了，那末對u再進(jìn)行各種修改操作的話，hibernate也不會(huì)發(fā)送任何的修改語句，因此這里只會(huì)有1條
delete的語句產(chǎn)生：
Hibernate: deletefrom t_user where id=?
11.TestDetached05
session = HibernateUtil.openSession();
session.beginTransaction();
User u = new User();
u.setId(4);
u.setPassword("zhaoliu");
//如果u是離線狀態(tài)就履行update操作，如果是瞬時(shí)狀態(tài)就履行Save操作
//但是注意：該方法其實(shí)不經(jīng)常使用
session.saveOrUpdate(u);
session.getTransaction().commit();
這里我們來看看saveOrUpdate這個(gè)方法，這個(gè)方法實(shí)際上是1個(gè)"偷懶"的方法，如果對象是1個(gè)離線對象，那末在履行這個(gè)方法后，實(shí)際上是調(diào)用了update方法，如果對象是1個(gè)瞬時(shí)對象，則會(huì)調(diào)用save方法，記住：如果對象設(shè)置了ID值，例如u.setId(4)，那末該對象會(huì)被假定當(dāng)作1個(gè)離線對象，此時(shí)就會(huì)履行update操作。
<span style="font-size:24px;">Hibernate: updatet_user set born=?, password=?, username=? where id=?</span>
如果此時(shí)我將u.setId(4)這句話注釋掉，那末此時(shí)u就是1個(gè)瞬時(shí)的對象，那末此時(shí)就會(huì)履行save操作，就會(huì)發(fā)送1條insert語句
Hibernate: insertinto t_user (born, password, username) values (?, ?, ?)
12.TestDetached06
session = HibernateUtil.openSession();
session.beginTransaction();
//u1已是持久化狀態(tài)
User u1 =(User)session.load(User.class, 3);
System.out.println(u1.getUsername());
//u2是離線狀態(tài)
User u2 = new User();
u2.setId(3);
u2.setPassword("123456789");
//此時(shí)u2將會(huì)變成持久化狀態(tài)，在session的緩存中就存在了兩份一樣的對象,在session中不能存在兩份拷貝，否則會(huì)拋出異常
session.saveOrUpdate(u2);
我們再來看1下這個(gè)例子，此時(shí)我們的u1已是持久化的對象了，保存在session緩存中，u2通過調(diào)用saveOrUpdate方法后也變成了1個(gè)持久化的對象，此時(shí)也會(huì)保存在session緩存中，這個(gè)時(shí)候session緩存中就存在了1個(gè)持久化對象有兩個(gè)援用拷貝了，這個(gè)時(shí)候hibernate就會(huì)報(bào)錯(cuò)
<span style="font-size:24px;">org.hibernate.NonUniqueObjectException:a different object with the same identifier value was already associated withthe session: [com.xiaoluo.bean.User#3]</span>
1個(gè)session中不能存在對1個(gè)持久化對象的兩重copy的，要解決這個(gè)方法，我們這里又要介紹session的另外一個(gè)方法 merge方法，這個(gè)方法的作用就是解決1個(gè)持久化對象兩分拷貝的問題，這個(gè)方法會(huì)將兩個(gè)對象合并在1起成為1個(gè)對象。
session = HibernateUtil.openSession();
session.beginTransaction();
//u1已是持久化狀態(tài)
User u1 =(User)session.load(User.class, 3);
System.out.println(u1.getUsername());
//u2是離線狀態(tài)
User u2 = new User();
u2.setId(3);
u2.setPassword("123456789");
//此時(shí)u2將會(huì)變成持久化狀態(tài)，在session的緩存中就存在了兩份一樣的對象,在session中不能存在兩份拷貝，否則會(huì)拋出異常
// session.saveOrUpdate(u2);
//merge方法會(huì)判斷session中是不是已存在同1個(gè)對象，如果存在就將兩個(gè)對象合并
session.merge(u2);
//最好實(shí)踐：merge1般不用
session.getTransaction().commit();
我們看到通過調(diào)用了merge方法以后，此時(shí)會(huì)將session中的兩個(gè)持久化對象合并為1個(gè)對象，但是merge方法不建議被使用
<span style="font-size:24px;">Hibernate: selectuser0_.id as id0_0_, user0_.born as born0_0_, user0_.password as password0_0_,user0_.username as username0_0_ from t_user user0_ where user0_.id=?
zhangsan
Hibernate: updatet_user set born=?, password=?, username=? where id=? </span>
4、總結(jié)
Hibernate3態(tài)瞬時(shí)態(tài)、持久態(tài)、游離態(tài)可謂是學(xué)習(xí)Hibernate的入門基礎(chǔ)，只有對它們之間的轉(zhuǎn)換理出頭緒，才能在實(shí)戰(zhàn)中發(fā)揮其最大優(yōu)勢。這才是剛剛開始，期待下1出好戲吧！
