一、概況

（一）瞬時狀態（暫時態）

在對象中假設對象剛被創建但沒有被持久化的話就是瞬時態

特點：

(1) 不和 Session 實例關聯

(2)在數據庫中沒有和瞬時對象關聯的記錄

（二）持久狀態

持久化對象就是已經被保存進數據庫的實體對象，而且這個實體對象如今還處於Hibernate的Session緩存管理之中。這時對該實體對象的不論什麽改動。都會在清理緩存時同步到數據庫中。

特點：

（1）持久的實例在數據庫中有相應的記錄，並擁有一個持久化標識(identifier).

（2）和session相關聯的對象

（三）遊離狀態（托管狀態、離線狀態）

當一個持久化對象，脫離開Hibernate的緩存管理後。它就處於遊離狀態，遊離對象和自由對象的最大差別在於，遊離對象在數據庫中可能還存在一條與它相應的記錄，僅僅是如今這個遊離對象脫離了Hibernate的緩存管理，而自由對象不會在數據庫中出現與它相應的數據記錄。

特點：

(1) 本質上和瞬時對象同樣

(2)僅僅是比瞬時對象多了一個數據庫記錄標識值id。

二、轉化圖

通過下面的轉換圖就能夠明確三態之間是怎樣轉換的。假設將這幅圖印在自己的腦子裏，三態就沒什麽神聖的啦！

三、實戰

以上是對三態理論知識上的解說，那麽接下來就從實際代碼中體驗一下它們的奧妙吧。

1.TestTransient　　

　    session = HibernateUtil.openSession();
            session.beginTransaction();
            User user = new User();
            user.setUsername("aaa");
            user.setPassword("aaa");
            user.setBorn(new Date());
            /*
             * 以上user就是一個Transient(瞬時狀態),此時user並沒有被session進行托管。即在session的
             * 緩存中還不存在user這個對象。當運行完save方法後，此時user被session托管，而且數據庫中存在了該對象
             * user就變成了一個Persistent(持久化對象)
             */
            session.save(user);
            session.getTransaction().commit();

此時我們知道hibernate會發出一條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（瞬時狀態），表示沒有被session管理並且數據庫中沒有
            //運行save之後，被session所管理，並且，數據庫中已經存在，此時就是Persistent狀態
            session.save(user);
            //此時u是持久化狀態。已經被session所管理，當在提交時。會把session中的對象和眼下的對象進行比較
            //假設兩個對象中的值不一致就會繼續發出對應的sql語句
            user.setPassword("bbb");
            //此時會發出2條sql，一條用戶做插入，一條用來做更新
            session.getTransaction().commit();

在調用了save方法後。此時user已經是持久化對象了，被保存在了session緩存其中。這時user又又一次改動了屬性值，那麽在提交事務時，此時hibernate對象就會拿當前這個user對象和保存在session緩存中的user對象進行比較，假設兩個對象同樣，則不會發送update語句，否則，假設兩個對象不同，則會發出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-12-22"));
            //沒有意義
            session.update(u);
            session.getTransaction().commit();

這個時候會發出多少sql語句呢？還是相同的道理，在調用save方法後，u此時已經是持久化對象了，記住一點：假設一個對象以及是持久化狀態了。那麽此時對該對象進行各種改動。或者調用多次update、save方法時。hibernate都不會發送sql語句。僅僅有當事物提交的時候。此時hibernate才會拿當前這個對象與之前保存在session中的持久化對象進行比較，假設不相同就發送一條update的sql語句。否則就不會發送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-2-3"));
           u.setUsername("zhangsan2");
           u.setPassword("zhangsan2");
            session.save(u);
            /*
             * 下面三條語句沒有不論什麽意義
             */
            session.save(u);
            session.update(u);
            session.update(u);
           u.setUsername("zhangsan3");
            session.getTransaction().commit();

相信這個測試用例。大家應該都知道結果了。沒錯。此時hibernate也會發出兩條sql語句。原理一樣的

Hibernate: insertinto t_user (born, password, username) values (?, ?, ?
)
Hibernate: updatet_user set born=?
, password=?, username=? where id=?

5.TestPersistent04

　session = HibernateUtil.openSession();
            session.beginTransaction();
            //此時u是Persistent
            User u =(User)session.load(User.class, 4);
            //因為u這個對象和session中的對象不一致，所以會發出sql完畢更新
            u.setUsername("bbb");
            session.getTransaction().commit();

我們來看看此時會發出多少sql語句呢？相同記住一點：當session調用load、get方法時，此時假設數據庫中有該對象，則該對象也變成了一個持久化對象。被session所托管。

因此。這個時候假設對對象進行操作。在提交事務時相同會去與session中的持久化對象進行比較，因此這裏會發送兩條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();
            //此時u是Persistent
            User u =(User)session.load(User.class, 4);
            u.setUsername("123");
            //清空session
            session.clear();
            session.getTransaction().commit();

再看這個樣例，當我們load出user對象時，此時user是持久化的對象。在session緩存中存在該對象，此時我們在對user進行改動後。然後調用session.clear()方法，這個時候就會將session的緩存對象清空，那麽session中就沒有了user這個對象，這個時候在提交事務的時候。發現已經session中已經沒有該對象了，所以就不會進行不論什麽操作，因此這裏僅僅會發送一條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();
            //此時u是一個離線對象，沒有被session托管
            User u = new User();
            u.setId(4);
           u.setPassword("hahahaha");
            //當運行save的時候總是會加入一條數據，此時id就會依據Hibernate所定義的規則來生成
            session.save(u);
            session.getTransaction().commit();

我們看到，當調用了u.setId(4)時。此時u是一個離線的對象，由於數據庫中存在id=4的這個對象。可是該對象又沒有被session所托管。所以這個對象就是離線的對象。要使離線對象變成一個持久化的對象。應該調用什麽方法呢？我們知道調用save方法。能夠將一個對象變成一個持久化對象，可是。當save一運行的時候。此時hibernate會依據id的生成策略往數據庫中再插入一條數據，所以假設調用save方法，此時數據庫會發送一條插入的語句：

Hibernate: insertinto t_user (born, password, username) values (?, ?, ?)

所以對於離線對象。假設要使其變成持久化對象的話。我們不能使用save方法，而應該使用update方法

8.TestDetached02

　SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
            session =HibernateUtil.openSession();
            session.beginTransaction();
            User u = new User();
            u.setId(5);
            //完畢update之後也會變成持久化狀態
            session.update(u);
           u.setBorn(sdf.parse("1998-12-22"));
            u.setPassword("world");
            u.setUsername("world");
            //會發出一條sql
            session.update(u);
            session.getTransaction().commit();

此時我們看到。當調用了update方法以後，此時u已經變成了一個持久化的對象，那麽假設此時對u對象進行改動操作後，在事務提交的時候，則會拿該對象和session中剛保存的持久化對象進行比較，假設不同就發一條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之後也會變成持久化狀態
            session.update(u);
           u.setBorn(sdf.parse("1998-12-22"));
            u.setPassword("lisi");
            u.setUsername("lisi");
            //會拋出異常
            u.setId(333);
            session.getTransaction().commit();

我們看這個樣例，前面的操作一樣。調用update方法後。user變成了一個持久化對象。在對user進行一些改動後，此時又通過u.setId(333)方法設置了u的ID，那麽這個時候，hibernate會報錯。由於我們的u當前已經是一個持久化對象。假設試圖改動一個持久化對象的ID的值的話，就會拋出異常，這點要特別註意

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);
            //如今u就是transient對象
            session.delete(u);
            //此時u已經是瞬時對象，不會被session和數據庫所管理
            u.setPassword("wangwu");
            session.getTransaction().commit();

接著我們來看這個樣例，這裏在調用了session.delete()方法以後，此時後u就會變成一個瞬時對象，由於此時數據庫中已經不存在該對象了，既然u已經是一個瞬時對象了。那麽對u再進行各種改動操作的話。hibernate也不會發送不論什麽的改動語句，因此這裏僅僅會有一條 delete的語句發生：

Hibernate: deletefrom t_user where id=?

11.TestDetached05

　session = HibernateUtil.openSession();
            session.beginTransaction();
            User u = new User();
            u.setId(4);
            u.setPassword("zhaoliu");
            //假設u是離線狀態就運行update操作，假設是瞬時狀態就運行Save操作
            //可是註意：該方法並不經常使用
            session.saveOrUpdate(u);
            session.getTransaction().commit();

這裏我們來看看saveOrUpdate這種方法，這種方法事實上是一個"偷懶"的方法，假設對象是一個離線對象，那麽在運行這種方法後，事實上是調用了update方法，假設對象是一個瞬時對象。則會調用save方法，記住：假設對象設置了ID值，比如u.setId(4)。那麽該對象會被假設當作一個離線對象，此時就會運行update操作。

<span style="font-size:24px;">Hibernate: updatet_user set born=?, password=?, username=? where id=?</span>

假設此時我將u.setId(4)這句話凝視掉，那麽此時u就是一個瞬時的對象。那麽此時就會運行save操作，就會發送一條insert語句

Hibernate: insertinto t_user (born, password, username) values (?, ?, ?
)

12.TestDetached06

　session = HibernateUtil.openSession();
            session.beginTransaction();
            //u1已經是持久化狀態
            User u1 =(User)session.load(User.class, 3);
           System.out.println(u1.getUsername());
            //u2是離線狀態
            User u2 = new User();
            u2.setId(3);
           u2.setPassword("123456789");
            //此時u2將會變成持久化狀態，在session的緩存中就存在了兩份相同的對象,在session中不能存在兩份拷貝。否則會拋出異常
            session.saveOrUpdate(u2);

我們再來看一下這個樣例，此時我們的u1已經是持久化的對象了。保存在session緩存中，u2通過調用saveOrUpdate方法後也變成了一個持久化的對象，此時也會保存在session緩存中，這個時候session緩存中就存在了一個持久化對象有兩個引用拷貝了，這個時候hibernate就會報錯

<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>

一個session中不能存在對一個持久化對象的雙重copy的，要解決這種方法，我們這裏又要介紹session的還有一個方法 merge方法，這種方法的作用就是解決一個持久化對象兩分拷貝的問題，這種方法會將兩個對象合並在一起成為一個對象。

session = HibernateUtil.openSession();
            session.beginTransaction();
            //u1已經是持久化狀態
            User u1 =(User)session.load(User.class, 3);
           System.out.println(u1.getUsername());
            //u2是離線狀態
            User u2 = new User();
            u2.setId(3);
           u2.setPassword("123456789");
            //此時u2將會變成持久化狀態，在session的緩存中就存在了兩份相同的對象,在session中不能存在兩份拷貝，否則會拋出異常
//            session.saveOrUpdate(u2);
            //merge方法會推斷session中是否已經存在同一個對象，假設存在就將兩個對象合並
            session.merge(u2);
            //最佳實踐：merge一般不用
            session.getTransaction().commit();

我們看到通過調用了merge方法以後，此時會將session中的兩個持久化對象合並為一個對象，可是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>

四、總結

Hibernate三態瞬時態、持久態、遊離態可謂是學習Hibernate的入門基礎，僅僅有對它們之間的轉換理出頭緒，才幹在實戰中發揮其最大優勢。這才是剛剛開始，期待下一出好戲吧。

Hibernate之三態篇