hibernate中的對象有3中狀態，瞬時對象（transientobjects）、持久化對象（persistentobjects）和離線對象（detachedobjects也叫做脫管對象）。
下圖3.1顯示了瞬時對象、持久化對象和離線對象之間的關系以及它們之間的轉換。
圖3.1
臨時狀態：由java的new命令開辟內存空間的java對象也就是普通的java對象，如果沒有變量引用它它將會被jvm收回。臨時對象在內存中是孤立存在的，它的意義是攜帶信息載體，不和數據庫中的數據由任何的關聯。通過session的save（）方法和saveorupdate（）方法可以把一個臨時對象和數據庫相關聯，并把臨時對象攜帶的信息通過配置文件所做的映射插入數據庫中，這個臨時對象就成為持久化對象。
持久化狀態：持久化對象在數據庫中有相應的記錄，持久化對象可以是剛被保存的，或者剛被加載的，但都是在相關聯的session聲明周期中保存這個狀態。如果是直接數據庫查詢所返回的數據對象，則這些對象和數據庫中的字段相關聯，具有相同的id，它們馬上變成持久化對象。如果一個臨時對象被持久化對象引用，也立馬變為持久化對象。
如果使用delete（）方法，持久化對象變為臨時對象，并且刪除數據庫中相應的記錄，這個對象不再與數據庫有任何的聯系。
持久化對象總是與session和transaction關聯在一起，在一個session中，對持久化對象的操作不會立即寫到數據庫，只有當transaction（事務）結束時，才真正的對數據庫更新，從而完成持久化對象和數據庫的同步。在同步之前的持久化對象成為臟對象。
當一個session（）執行close（）、clear（）、或evict（）之后，持久化對象就變為離線對象，這時對象的id雖然擁有數據庫的識別值，但已經不在hibernate持久層的管理下，他和臨時對象基本上一樣的，只不過比臨時對象多了數據庫標識id。沒有任何變量引用時，jvm將其回收。
脫管狀態：session關閉之后，與此session關聯的持久化對象就變成為脫管對象，可以繼續對這個對象進行修改，如果脫管對象被重新關聯到某個新的session上，會在此轉成持久對象。
脫管對象雖然擁有用戶的標識id，所以通過update（）、saveorupdate（）等方法，再次與持久層關聯。
下面我們就通過使用hibernate，實現對數據庫的增刪改查來體現三種狀態之間的轉換過程。
添加修改演示三種狀態之間的變化
當我們建立session都要實例化sessionfactory，所以我們把重復的代碼進行封裝，并且session是單線程的。我們把對session的管理，打開session，關閉session等封裝到工具類中，代碼如下所示。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
|
package com.bjpowernode.hibernate; import org.hibernate.session; import org.hibernate.sessionfactory; import org.hibernate.cfg.configuration; public class hibernateutils { private static sessionfactory factory; //static只初始化一次. static { try{ //默認讀取的是hibernate.cfg.xml 文件. configuration cfg = new configuration().configure(); //建立sessionfactory. factory = cfg.buildsessionfactory(); }catch(exception e ) { e.printstacktrace(); } } public static session getsession() { //打開session. return factory.opensession(); } //關閉session. public static void closesession(session session) { //判斷是否為空. //判斷是否是打開狀態再進行關閉. if(session!=null) { if(session.isopen()) { session.close(); } } } //返回工廠類. public static sessionfactory getsessionfactory() { return factory; } } |
hibernate.cfg.xml代碼如下所示。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
<!doctype hibernate-configuration public "-//hibernate/hibernate configuration dtd 3.0//en" "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd"> <hibernate-configuration> <session-factory > <property name="hibernate.connection.driver_class">com.mysql.jdbc.driver</property> <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/hibernate_session</property> <property name="hibernate.connection.username">root</property> <property name="hibernate.connection.password">root</property> <property name="hibernate.dialect">org.hibernate.dialect.mysqldialect</property> <property name="hibernate.show_sql">true</property> <mapping resource="com/bjpowernode/hibernate/user.hbm.xml"/> </session-factory> </hibernate-configuration> |
之前我們把對表添加的操作放到普通的java類中，在這個類的main（）方法中執行，如果我們再對表進行其他的操作呢？那是不是還要建立新的java類，多個方法就不容易測試了。我們使用測試工具類junit來做測試，來測試增刪改查。首先建立源目錄，在test包中放測試程序。
我們建立我們的測試程序sessiontest.java，繼承testcase類，這樣我們在sessiontest.java類中測試數據庫中的某個方法，方法名的規范要以test開頭。我們向user表中添加一條記錄如下代碼所示。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
|
package com.bjpowernode.hibernate; import java.util.date; import junit.framework.testcase; import org.hibernate.session; import org.hibernate.transaction; public class sessiontest extends testcase { //測試方法以test開頭. public void testsave1() { session session = null; transaction tx = null; try { //取得session. session = hibernateutils.getsession(); //自己開啟事務. 返回 transient的一個實例. tx = session.begintransaction(); //傳入值.變為transient狀態. user user = new user(); user.setname("張三"); user.setpassword("123"); user.setcreatetime(new date()); user.setexpiretime(new date()); //進行保存.執行save則對session進行管理了. 處于持久狀態. //persistent狀態的對象.當對象的屬性發生改變的時候,hibernate在清理 //緩存的時候(臟數據檢查)的時候,會和數據庫同步. session.save(user); user.setname("李四"); //再次提交. tx.commit(); }catch(exception e) { e.printstacktrace(); if(tx!=null) { // 事務回滾. tx.rollback(); } }finally { //關閉session.當關閉session時處于detached狀態. hibernateutils.closesession(session); } } |
首先是建立對象與表的會話session，開啟事務session.begintransaction()，實例化user對象，當我們user user = new user（）的時候，當我們new一個對象的時候數據庫是沒有的，所以是transient對象（臨時對象），然后給user賦值，設置名稱和密碼以及其他屬性。 為對象的所有屬性賦值完畢，接下來保存到會話session中，拿到session執行save（user）方法。 當我們執行session的save（）方法時，這個對象就被session管理了，session中有個map，會把對象放到map中，此時的對象我們就成為persistent狀態（持久狀態）。
接下來我們又把user中的name屬性設置為“李四”，之后提交事務。我們先再會話中存儲的“張三”，之后改為“李四”。try catch來撲捉異常，當執行完畢，關閉session后，對象處于detached狀態（離線狀態）。
我們創建數據庫，利用exportdb.java方法建立表。之后執行sessiontest的testsave1（）方法，當執行到session方法的時候，表中自動生成user表的id值，并且名子為“張三”，之后再次執行，名字又變為“李四”，之后執行事務的commit（）方法tx .commit ，此時控制臺才發出語句，如下圖3.2。
從控制臺的語句中可以看出，顯示發送的插入sql語句，后是update語句，首先是持久化對象user中的名字為“張三”，所以save的時候生成inset語句。此時user處于持久狀態的對象，我們之后又給變了持久化對象，所以發送了一個修改語句。也就是當持久化對象發生修改時，我們再提交事務，就會把修改的全部體現出來（update語句）。
也就是我們再提交事務的時候，在清理緩存，也就是臟數據檢查（內存中變了，而數據沒變），要檢查哪些數據是有問題的，要保持內存和數據庫的同步。所以我們數據庫中添加的記錄，user的名字為李四（如圖3.3所示）。
圖3.3
如果上述代碼中，我們在修改名字為李四后user.setname("李四")；我們顯示調用session的update（）方法，session.update(),運行，會看到控制臺上打印的sql語句和我們不加如session.update()打印的相同。持久化對象只要更改了，在提交事務的時候就會同步，沒有必要再顯示調用。
detached狀態演示
我們在執行完所有的操作，關閉session后，此時的user對象變為detached狀態，此時進行操作。
代碼如下所示。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
|
public void testsave3() { session session = null; transaction tx = null; user user = null; try { //取得session. session = hibernateutils.getsession(); //自己開啟事務. fanhui transient的一個實例. tx = session.begintransaction(); //傳入值.變為transient狀態. user = new user(); user.setname("張三"); user.setpassword("123"); user.setcreatetime(new date()); user.setexpiretime(new date()); //進行保存.執行save則對session進行管理了. 處于持久狀態. //persistent狀態的對象.當對象的屬性發生改變的時候,hibernate在清理 //緩存的時候(臟數據檢查)的時候,會和數據庫同步. session.save(user); user.setname("李四"); //可以顯示的調用update方法,因為此時為持久狀態,調用update沒有什么意義. //再次提交. tx.commit(); }catch(exception e) { e.printstacktrace(); if(tx!=null) { // 事務回滾. tx.rollback(); } }finally { //關閉session.當關閉session時處于detached狀態. hibernateutils.closesession(session); } //已經不能用以前的session了. user.setname("王五"); try { //得到新的session. session = hibernateutils.getsession(); //開啟事務. session.begintransaction(); //將detached狀態的對象重新納入session管理. //此時將變為persistent狀態的對象. //persistent狀態的對象,在清理緩存時,會根數據庫同步. session.update(user); //提交事務.把內存的改變提交到數據庫上. session.gettransaction().commit(); }catch(exception e) { e.printstacktrace(); session.gettransaction().rollback(); }finally { hibernateutils.closesession(session); } } |
取得detached狀態的user對象，改變這個對象的name值，user.setname("王五")；之后我們再new一個新的
session，通過session開啟事務，之后更新操作，session.update(user)，也就是把離線的對象（或脫管對象）再納入session管理，這樣就會和數據庫同步，因為session.update()就把user對象納入session管理，user對象由離線狀態變為persistent狀態。
提交事務，將和數據庫同步。把內存的改變體現到數據庫上。控制臺sql語句以及運行向表中添加記錄結果如圖3.4,3.5所示。
圖3.4
總結
以上所述是小編給大家介紹的hibernate持久化對象的三個狀態，希望對大家有所幫助，如果大家有任何疑問請給我留言，小編會及時回復大家的。在此也非常感謝大家對服務器之家網站的支持！
