hibernate的三種狀態

轉載:https://www.cnblogs.com/xiaoluo501395377/p/3380270.html

 

瞬時狀態:　　剛new出來一個對象，對象在session和數據庫中都不存在的狀態

持久化狀態:    對象在session和數據庫中都存在的狀態

遊離狀態:        對象在session中不存在,但在數據庫中存在的狀態

 

1.遊離態轉變爲持久態

　　　　　　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: insert into t_user (born, password, username) values (?, ?, ?)

 

2.修改持久態屬性,提交事務後發出對應SQL

　　　　　　　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: insert into t_user (born, password, username) values (?, ?, ?)
Hibernate: update t_user set born=?, password=?, username=? where id=?

 

3.在事務中持久態被修改屢次,且調用save,update方法

　　　　　　　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();

　　在調用save方法後，u此時已是持久化對象了，記住一點：若是一個對象以及是持久化狀態了，那麼此時對該對象進行各類修改，或者調用屢次update、save方法時，hibernate都不會發送sql語句，只有當事物提交的時候，此時hibernate纔會拿當前這個對象與以前保存在session中的持久化對象進行比較，若是不相同就發送一條update的sql語句，不然就不會發送update語句

Hibernate: insert into t_user (born, password, username) values (?, ?, ?)
Hibernate: update t_user set born=?, password=?, username=? where id=?

 

4.當數據庫已有對象被取出,該取出對象爲持久態

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

　　記住一點：當session調用load、get方法時，此時若是數據庫中有該對象，則該對象也變成了一個持久化對象，被session所託管。所以，這個時候若是對對象進行操做，在提交事務時一樣會去與session中的持久化對象進行比較，所以這裏會發送兩條sql語句

Hibernate: select user0_.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: update t_user set born=?, password=?, username=? where id=?

 

5.調用clear方法清空session緩存對象

　　　　　　　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: select user0_.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=?

 

6.遊離態的變爲持久態,應使用update方法

　　　　　　　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: insert into t_user (born, password, username) values (?, ?, ?)

　　因此對於離線對象，若是要使其變成持久化對象的話，咱們不能使用save方法，而應該使用update方法

 

7.不能修改持久態主鍵,修改後會報異常

 

　　　　　　　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

 

8.用delete方法將持久態,遊離態轉變爲臨時態

　　　　　　　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: delete from t_user where id=?

 

9.saveOrUpdate方法將遊離態或臨時態轉變爲持久態

　　　　　　　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操做。

Hibernate: update t_user set born=?, password=?, username=? where id=?

　　若是此時我將u.setId(4)這句話註釋掉，那麼此時u就是一個瞬時的對象，那麼此時就會執行save操做，就會發送一條insert語句

Hibernate: insert into t_user (born, password, username) values (?, ?, ?)