溫馨提示×
您好，登錄后才能下訂單哦！
點擊 登錄注冊 即表示同意《億速云用戶服務(wù)條款》
您好，登錄后才能下訂單哦！
學(xué)過hibernate的人都可能都知道hibernate有三種狀態(tài)，transient(瞬時狀態(tài))，persistent(持久化狀態(tài))以及detached(離線狀態(tài))，大家伙也許也知道這三者之間的區(qū)別，比如瞬時狀態(tài)就是剛new出來一個對象，還沒有被保存到數(shù)據(jù)庫中，持久化狀態(tài)就是已經(jīng)被保存到數(shù)據(jù)庫中，離線狀態(tài)就是數(shù)據(jù)庫中有，但是session中不存在該對象。但是大家又是否對hibernate的session的那幾個特殊方法一清二楚呢？或者說大家是否能夠一眼就快速看出一個測試用例在反復(fù)的調(diào)用session的諸如save，update方法后會到底發(fā)出多少條SQL語句呢？本篇隨筆將會給你答案，本篇隨筆將會以大量的測試用例來掩飾hibernate的這三種狀態(tài)的轉(zhuǎn)變，相信看完本篇隨筆的你會對hibernate的那三種狀態(tài)有更深入的理解。
好了，廢話不多說了，相信大家都知道hibernate的這三種狀態(tài)的含義，那我們就通過一張圖來開始我們的深入hibernate的三種狀態(tài)之旅吧。
1.TestTransient
session = HibernateUtil.openSession();
session.beginTransaction();
User user = new User();
user.setUsername("aaa");
user.setPassword("aaa");
user.setBorn(new Date());
/*
* 以上user就是一個Transient(瞬時狀態(tài)),此時user并沒有被session進行托管，即在session的
* 緩存中還不存在user這個對象，當(dāng)執(zhí)行完save方法后，此時user被session托管，并且數(shù)據(jù)庫中存在了該對象
* user就變成了一個Persistent(持久化對象)
*/
session.save(user);
session.getTransaction().commit();
此時我們知道hibernate會發(fā)出一條insert的語句，執(zhí)行完save方法后，該user對象就變成了持久化的對象了
2.TestPersistent01
session = HibernateUtil.openSession();
session.beginTransaction();
User user = new User();
user.setUsername("aaa");
user.setPassword("aaa");
user.setBorn(new Date());
//以上u就是Transient（瞬時狀態(tài)），表示沒有被session管理并且數(shù)據(jù)庫中沒有
//執(zhí)行save之后，被session所管理，而且，數(shù)據(jù)庫中已經(jīng)存在，此時就是Persistent狀態(tài)
session.save(user);
//此時u是持久化狀態(tài)，已經(jīng)被session所管理，當(dāng)在提交時，會把session中的對象和目前的對象進行比較
//如果兩個對象中的值不一致就會繼續(xù)發(fā)出相應(yīng)的sql語句
user.setPassword("bbb");
//此時會發(fā)出2條sql，一條用戶做插入，一條用來做更新
session.getTransaction().commit();
在調(diào)用了save方法后，此時user已經(jīng)是持久化對象了，被保存在了session緩存當(dāng)中，這時user又重新修改了屬性值，那么在提交事務(wù)時，此時hibernate對象就會拿當(dāng)前這個user對象和保存在session緩存中的user對象進行比較，如果兩個對象相同，則不會發(fā)送update語句，否則，如果兩個對象不同，則會發(fā)出update語句。
Hibernate: insert into t_user (born, password, username) values (?, ?, ?) Hibernate: update t_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();
這個時候會發(fā)出多少sql語句呢？還是同樣的道理，在調(diào)用save方法后，u此時已經(jīng)是持久化對象了，記住一點：如果一個對象以及是持久化狀態(tài)了，那么此時對該對象進行各種修改，或者調(diào)用多次update、save方法時，hibernate都不會發(fā)送sql語句，只有當(dāng)事物提交的時候，此時hibernate才會拿當(dāng)前這個對象與之前保存在session中的持久化對象進行比較，如果不相同就發(fā)送一條update的sql語句，否則就不會發(fā)送update語句
Hibernate: insert into t_user (born, password, username) values (?, ?, ?) Hibernate: update t_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();
相信這個測試用例，大家應(yīng)該都知道結(jié)果了，沒錯，此時hibernate也會發(fā)出兩條sql語句，原理一樣的
Hibernate: insert into t_user (born, password, username) values (?, ?, ?) Hibernate: update t_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中的對象不一致，所以會發(fā)出sql完成更新
u.setUsername("bbb");
session.getTransaction().commit();
我們來看看此時會發(fā)出多少sql語句呢？同樣記住一點：當(dāng)session調(diào)用load、get方法時，此時如果數(shù)據(jù)庫中有該對象，則該對象也變成了一個持久化對象，被session所托管。因此，這個時候如果對對象進行操作，在提交事務(wù)時同樣會去與session中的持久化對象進行比較，因此這里會發(fā)送兩條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=?
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();
再看這個例子，當(dāng)我們load出user對象時，此時user是持久化的對象，在session緩存中存在該對象，此時我們在對user進行修改后，然后調(diào)用session.clear()方法，這個時候就會將session的緩存對象清空，那么session中就沒有了user這個對象，這個時候在提交事務(wù)的時候，發(fā)現(xiàn)已經(jīng)session中已經(jīng)沒有該對象了，所以就不會進行任何操作，因此這里只會發(fā)送一條select語句
7.TestDetached01
session = HibernateUtil.openSession();
session.beginTransaction();
//此時u是一個離線對象，沒有被session托管
User u = new User();
u.setId(4);
u.setPassword("hahahaha");
//當(dāng)執(zhí)行save的時候總是會添加一條數(shù)據(jù)，此時id就會根據(jù)Hibernate所定義的規(guī)則來生成
session.save(u);
session.getTransaction().commit();
我們看到，當(dāng)調(diào)用了u.setId(4)時，此時u是一個離線的對象，因為數(shù)據(jù)庫中存在id=4的這個對象，但是該對象又沒有被session所托管，所以這個對象就是離線的對象，要使離線對象變成一個持久化的對象，應(yīng)該調(diào)用什么方法呢？我們知道調(diào)用save方法，可以將一個對象變成一個持久化對象，但是，當(dāng)save一執(zhí)行的時候，此時hibernate會根據(jù)id的生成策略往數(shù)據(jù)庫中再插入一條數(shù)據(jù)，所以如果調(diào)用save方法，此時數(shù)據(jù)庫會發(fā)送一條插入的語句：
Hibernate: insert into t_user (born, password, username) values (?, ?, ?)
所以對于離線對象，如果要使其變成持久化對象的話，我們不能使用save方法，而應(yīng)該使用update方法
8.TestDetached02
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
session = HibernateUtil.openSession();
session.beginTransaction();
User u = new User();
u.setId(5);
//完成update之后也會變成持久化狀態(tài)
session.update(u);
u.setBorn(sdf.parse("1998-12-22"));
u.setPassword("world");
u.setUsername("world");
//會發(fā)出一條sql
session.update(u);
session.getTransaction().commit();
此時我們看到，當(dāng)調(diào)用了update方法以后，此時u已經(jīng)變成了一個持久化的對象，那么如果此時對u對象進行修改操作后，在事務(wù)提交的時候，則會拿該對象和session中剛保存的持久化對象進行比較，如果不同就發(fā)一條sql語句
Hibernate: update t_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之后也會變成持久化狀態(tài)
session.update(u);
u.setBorn(sdf.parse("1998-12-22"));
u.setPassword("lisi");
u.setUsername("lisi");
//會拋出異常
u.setId(333);
session.getTransaction().commit();
我們看這個例子，前面的操作一樣，調(diào)用update方法后，user變成了一個持久化對象，在對user進行一些修改后，此時又通過 u.setId(333)方法設(shè)置了u的ID，那么這個時候，hibernate會報錯，因為我們的u當(dāng)前已經(jīng)是一個持久化對象，如果試圖修改一個持久化對象的ID的值的話，就會拋出異常，這點要特別注意
10.TestDetached04
session = HibernateUtil.openSession();
session.beginTransaction();
User u = new User();
u.setId(5);
//現(xiàn)在u就是transient對象
session.delete(u);
//此時u已經(jīng)是瞬時對象，不會被session和數(shù)據(jù)庫所管理
u.setPassword("wangwu");
session.getTransaction().commit();
接著我們來看這個例子，這里在調(diào)用了session.delete()方法以后，此時后u就會變成一個瞬時對象，因為此時數(shù)據(jù)庫中已經(jīng)不存在該對象了，既然u已經(jīng)是一個瞬時對象了，那么對u再進行各種修改操作的話，hibernate也不會發(fā)送任何的修改語句，因此這里只會 有一條 delete的語句發(fā)生：
Hibernate: delete from t_user where id=?
11.TestDetached05
session = HibernateUtil.openSession();
session.beginTransaction();
User u = new User();
u.setId(4);
u.setPassword("zhaoliu");
//如果u是離線狀態(tài)就執(zhí)行update操作，如果是瞬時狀態(tài)就執(zhí)行Save操作
//但是注意：該方法并不常用
session.saveOrUpdate(u);
session.getTransaction().commit();
這里我們來看看 saveOrUpdate這個方法，這個方法其實是一個"偷懶"的方法，如果對象是一個離線對象，那么在執(zhí)行這個方法后，其實是調(diào)用了update方法，如果對象是一個瞬時對象，則會調(diào)用save方法，記住：如果對象設(shè)置了ID值，例如u.setId(4)，那么該對象會被假設(shè)當(dāng)作一個離線對象，此時就會執(zhí)行update操作。
Hibernate: update t_user set born=?, password=?, username=? where id=?
如果此時我將u.setId(4)這句話注釋掉，那么此時u就是一個瞬時的對象，那么此時就會執(zhí)行save操作，就會發(fā)送一條insert語句
Hibernate: insert into t_user (born, password, username) values (?, ?, ?)
12.TestDetached06
session = HibernateUtil.openSession();
session.beginTransaction();
//u1已經(jīng)是持久化狀態(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");
//此時u2將會變成持久化狀態(tài)，在session的緩存中就存在了兩份同樣的對象,在session中不能存在兩份拷貝，否則會拋出異常
session.saveOrUpdate(u2);
我們再來看一下這個例子，此時我們的u1已經(jīng)是持久化的對象了，保存在session緩存中，u2通過調(diào)用saveOrUpdate方法后也變成了一個持久化的對象，此時也會保存在session緩存中，這個時候session緩存中就存在了一個持久化對象有兩個引用拷貝了，這個時候hibernate就會報錯
一個session中不能存在對一個持久化對象的雙重copy的，要解決這個方法，我們這里又要介紹session的另一個方法 merge方法，這個方法的作用就是解決一個持久化對象兩分拷貝的問題，這個方法會將兩個對象合并在一起成為一個對象。
session = HibernateUtil.openSession();
session.beginTransaction();
//u1已經(jīng)是持久化狀態(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");
//此時u2將會變成持久化狀態(tài)，在session的緩存中就存在了兩份同樣的對象,在session中不能存在兩份拷貝，否則會拋出異常
// session.saveOrUpdate(u2);
//merge方法會判斷session中是否已經(jīng)存在同一個對象，如果存在就將兩個對象合并
session.merge(u2);
//最佳實踐：merge一般不用
session.getTransaction().commit();
我們看到通過調(diào)用了merge方法以后，此時會將session中的兩個持久化對象合并為一個對象，但是merge方法不建議被使用
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=? zhangsan Hibernate: update t_user set born=?, password=?, username=? where id=?
終于寫完了本篇隨筆，本篇隨筆可能概念性的內(nèi)容比較少，基本都是通過測試用例來分析hibernate的三種狀態(tài)可能會出現(xiàn)的各種情況。
最后總結(jié)一下：
①.對于剛創(chuàng)建的一個對象，如果session中和數(shù)據(jù)庫中都不存在該對象，那么該對象就是瞬時對象(Transient)
②.瞬時對象調(diào)用save方法，或者離線對象調(diào)用update方法可以使該對象變成持久化對象，如果對象是持久化對象時，那么對該對象的任何修改，都會在提交事務(wù)時才會與之進行比較，如果不同，則發(fā)送一條update語句，否則就不會發(fā)送語句
③.離線對象就是，數(shù)據(jù)庫存在該對象，但是該對象又沒有被session所托管
以上就是本文的全部內(nèi)容，希望對大家的學(xué)習(xí)有所幫助，也希望大家多多支持億速云。
免責(zé)聲明：本站發(fā)布的內(nèi)容（圖片、視頻和文字）以原創(chuàng)、轉(zhuǎn)載和分享為主，文章觀點不代表本網(wǎng)站立場，如果涉及侵權(quán)請聯(lián)系站長郵箱：is@yisu.com進行舉報，并提供相關(guān)證據(jù)，一經(jīng)查實，將立刻刪除涉嫌侵權(quán)內(nèi)容。
億速云公眾號
手機網(wǎng)站二維碼