session 中对象实例在不同事务中的状态
不同事務中執行hibernate query,則查詢出來的對象會在不同session中，或一個在托管態，一個在session中管理，所以是不同實例。
?
?
如果在同一事務中的話，則多次query出來的對象實際上是同一個實例，當你改變第一次query出來的對象時，之后你再query出來的實例就會反映第一次的變化。
同一事務下：
1.
swapTrade = swapTradeService.getTradeByLqtId(incomingTrade.getLqttradeid());
swapTrade = positionConverter.toSwapTrade(incomingTrade, swapTrade);
2.
SwapTrade persistedTrade = swapTradeService.getTradeByLqtId(swapTrade.getLqttradeid());
?
persistedTrade 會反映swapTrade的變化。
?
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
http://www.iteye.com/topic/1113462
用過Hibernate的人都知道Hibernate最原始的使用Session方式（異常忽略）：
?
| 獲取SessionFactory 打開Session 打開事務（可選） 執行操作 關閉事務（可選） 關閉Session |
?
?
??? 當然還有另外一個方法getCurrentSession() 這個方法就是通過SessionContext來減少Session創建的。比如常用的ThreadLocalSessionContext：
?
Java代碼 ??
???? ?? currentSession()內部先從ThreadLocal中獲取Session。若不為null直接返回，若為null則openSession(...)一個Session并把這個Session對象綁定在ThreadLocal上。它就是通過在ThreadLocal中注冊綁定Session來確保線程中最多只有一個Session對象。
?
?
上面的地球人都知道
==============================================================================
?
Spring提供許多Template對各種底層ORM等進行集成，如JdbcTemplate、HibernateTemplate、JpaTemplate等同時也提供了相應的Dao模板類，如JdbcDaoSupport、HibernateDaoSupport、JpaDaoSupport等
既然說Spring對Hibernate的集成，就得看HibernateTemplate和HibernateDaoSupport這兩個類。
???? 使用HibernateDaoSupport進行數據操作時常用兩種方式訪問Session：getSession()和HibernateCallback。
| 注意：使用HibernateDaoSupport時候、如果再通過SessionFactory進行getCurrentSession()獲取Session的話就有可能出現問題了。因為Spring的Bean工廠把Hibernate的SessionFactory動了點小手腳 ~。就是前面說到的ThreadLocalSessionContext被Spring替換為 SpringSessionContext ！ ? SessionFactoryUtils#doGetSession()是通過TransactionSynchronizationManager來獲取Session資源的，doGetSession()會通過 TransactionSynchronizationManager訪問線程資源、但是整個操作中沒有打開事務的話、此方法會拋出異常： ? ??? 這個異常就是出現在SessionFactoryUtils#doGetSession()方法的最后： Java代碼 ?? |
?
????? ? getSession和getCurrentSession實現過程差不多，但是精簡了SessionContext那一段。并且可以設置allowCreate，如果設置為false，此方法應該和getCurrentSession同樣效果。
?
?
=========================================================================
?
?
了解了這些之后、我進行了一個HibernateTemplate和getSession之間的測試，主要就是測試
單線程下多次重復請求創建Session與事務之間的關系、HibernateTemplate和getSession()兩者之間在功能實現和效率上有什么樣的不同。（多線程下卡的要死、不測試了）
?
| Dao層： | testTS()方法——臨時創建用于測試的方法 ??????????? 通過HibernateTemplate和直接getSession等方法獲取Session并保存。?????????? ??????????? 打印已經保存的Session的狀態。 ??????????? 打印已經保存的Session之間是否相同。 ??????????? 打印SessionFactory的狀態記錄。 |
| Service層： | testTS()方法——臨時創建用于測試的方法 ??? ??? 內部代碼為執行三次請求： ???????? getDao().testTS(); ???????? getDao().testTS(); ???????? getDao().testTS(); |
?
?
第一次測試
| ??? Service層的testTS(e)方法不打開事務。??? ??? 使用HibernateTemplate。?? | 結論： Service層沒有打開事務，但是每次操作CURD操作時，HibernateTemplate都會自動創建 Transactional。同一線程獲取到的前后兩個Session之間互不相同。 |
| ? --------------Closed Transactional && Single-Thread-------------- ? ????? 測試數據擴大100倍并記時： |
?
第二次測試
| ??? Service層的testTS(e)方法打開事務。??? | 結論： 在事務邊界內獲取的Session由Spring管理、不必手動關閉 雖然打開了事務，但是同一線程下同一事務邊界內前后獲取的兩個Session仍然不同！ 這是為什么？？？ 后面會繼續剖析HibernateTemplate源碼，給出解釋 |
| ? --------------Open Transactional && Single-Thread-------------- ??? ??????? 測試數據擴大100倍并記時： |
?
第三次測試
| ??? Service層的testTS(e)方法不打開事務。??? | 可以看到getSession()由于缺少Spring的支持，在無事務環境下。 它為每個CURD請求創建了一個Session。并且更讓人震驚的是，它好像為每個Session都創建了新 Connection 。這些Session使用之后，它也并不關閉。 |
| ? --------------Closed Transactional && Single-Thread-------------- ??? ???? 測試數據擴大100倍并記時，令人極其震驚且極其坑爹的一幕出現了！我親眼看到程序以一種 肉眼可見的速度 慢騰騰的執行一次又一次的循環，它竟然執行了一分鐘！！！： |
?
第四次測試
| ??? Service層的testTS(e)方法打開事務。??? ??? 使用getSession() 。 | 這個最容易讓人理解、由于同一線程且在同一事務邊界內，前后兩個Session相同。并且也不會重復創建 Connection。 |
| ? --------------Open Transactional && Single-Thread-------------- ???????? 測試數據擴大100倍并記時： |
?
?
總結：
????? getSession()在事務邊界內會通過TransactionSynchronizationManager獲取Session資源，同一線程內它不會重復創建Connection ， 那些獲取到的Session()不需要手動關閉。但是在無聲明式事務環境下，它就會表現出極其坑爹的狀況，它反復獲取Connection，也不關閉Session。非常消耗資源
?
????? HibernateTemplate有一個安全且高效的Session環境，它的CRUD都是位于HibernateCallback內部，如果它的CRUD并沒有位于事務之中，它會自己創建一個事務（Spring集成Hibernate時，所有的資源都是由TransactionSynchronizationManager管理的 ）。同一個線程中它只需要一個Connection。Session也會在事務邊界處自動關閉，程序員不需要關注此事（這個事務邊界可能是@Transactional顯式聲明的也可能是HibernateTemplate#doExecute隱式聲明的）。
?
???? 在同一個事務邊界內，兩個HibernateTemplate操作內部的Session互也不相同這個問題可以在HibernateTemplate源碼中找到答案：
Java代碼 ??
?
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
http://www.kuqin.com/docs/hibernate/transactions.html
第?10?章?事務和并行（Transactions And Concurrency）
Hibernate本身并不是數據庫，它只是一個輕量級的對象－關系數據庫映射（object-relational）工具。它的事務交由底層的數據庫連接管理，如果數據庫連接有JTA的支持，那么在Session中進行的操作將是整個原子性JTA事務的一部分。Hibernate可以看作是添加了面向對象語義的JDBC瘦適配器（thin adapter）。
10.1.?配置，會話和工廠（Configurations, Sessions and Factories）
SessionFactory的創建需要耗費大量資源，它是線程安全（threadsafe）的對象，在應用中它被所有線程共享。而Session的創建耗費資源很少，它不是線程安全的對象，對于一個簡單商業過程（business process），它應該只被使用一次，然后被丟棄。舉例來說，當Hibernate在基于servlet的應用中，servlet能夠以下面的方式得到SessionFactory。
SessionFactory sf = (SessionFactory)getServletContext().getAttribute("my.session.factory");每次調用SessionFactory的service方法能夠生成一個新的Session對象，然后調用Session的flush()，調用commit()提交它的連接，調用close()關閉它，最終丟棄它。(SessionFactory可能被保存在JNDI或者一個靜態的單例（Singleton）輔助變量中。）
在無狀態的session bean中，可以同樣使用類似的方法。bean在setSessionContext()中得到SessionFactory的實例，每個商業方法會生成一個Session對象，調用它的flush()和close()，當然，應用不應該commit()connection. (把它留給JTA.在容器管理的事務中，數據庫連接會自動完成事務。)
我們用上述方法使用Hibernate 的Transaction API，對Transaction執行一次commit()會把所有狀態同步，把底層的數據庫連接提交(對JTA 事務會特殊處理。)
這里需要理解flush()的含義。 flush()將持久化存儲與內存中的變化進行同步，但不是將內存的變化與持久化存儲進行同步。注意對所有的Hibernate JDBD 連接/事務來說，其隔離級別將施加于所有的Hibernate執行的操作之上！
接下來的幾小節將討論利用版本化的方法來確保事務原子性，這些“高級”方法需要小心使用。
10.2.?線程和連接（Threads and connections）
在創建Hibernate會話（Session）時，你應該留意以下的實踐（practices）：
-
對于一個數據庫連接，不要創建一個以上的Session或Transaction。
-
在對于一個數據庫連接、一個事務使用多個Session時，你尤其需要格外地小心。Session對象會記錄下調入數據更新的情況，所以另一個Session對象可能會遇到過時的數據。
-
Session不是線程安全的。決不要在兩個并發的線程中訪問同一個Session。一個Session一般只對應一批需要一次性完成的單元操作！
10.3.?考慮對象辨別
程序可能在兩批單元操作中并發訪問同一個對象的持久化狀態。不管怎樣，持久化類的一個實例不可能在兩個Session中共享。所以有兩種不同的辨別方式：
數據庫辨別foo.getId().equals( bar.getId() )
foo==bar
對于依附于某個特定Session的對象，兩種辨別方式是等價的。然而，當程序可能在兩個不同的session中并發訪問“同一個”（持久化辨別）商業對象時，兩個實例（對于JVM辨別來說）卻可能是“不同”的。
這種方式把關于并發的頭疼問題留給了Hibernate和數據庫。程序不需要對任何商業對象進行同步，只要程序堅持每個Session一個線程，或者對象辨別的策略（在一個Session重，程序可以安全的使用==來比較對象）。
10.4.?樂觀并發控制（Optimistic concurrency control）
許多商業過程需要一系列與用戶進行交互的過程，數據庫訪問穿插在這些過程中。對于web和企業應用來說，跨一個用戶交互過程的數據事務是不可接受的。
維護各商業事務間的隔離（isolocation）就成為應用層的部分責任，我們把這種過程稱為長時間運行的應用事務（application transaction）。單一的應用事務可能跨越多個數據庫事務。如果這些數據庫事務中只有一個（最后一個）保存了被修改的數據，其他事務只是簡單地讀數據，則這個應用事務就是原子性的。
唯一滿足高并發性以及高可擴展性的方法是使用帶有版本化的樂觀并發控制。Hibernate為使用樂觀并發控制的代碼提供了三種可能的方法。
10.4.1.?使用長生命周期帶有自動版本化的會話
在整個商業過程中使用一個單獨的Session實例以及它的持久化實例，這個Session使用帶有版本化的樂觀鎖定機制，來確保多個數據庫事務對于應用來說只是一個邏輯上的事務。在等待用戶交互時，Session斷開與數據庫的連接。這個方法從數據庫訪問方面來看是最有效的，應用不需要關心對自己的版本檢查或是重新與不需要序列化（transient）的實例進行關聯。
在整個應用事務中，使用單一的Session 實例和它的持久化實例。
Session 使用帶有版本化的樂觀鎖定來保證多個數據庫事務對程序來說就如同是單一的邏輯應用事務。在等待用戶交互的時候，Session 脫離所有的底層JDBC連接。對于數據庫訪問來說，這種方法是最高效的。程序自己不需要關心版本檢查或者把已經脫離session的實例重新關聯到session。
// foo is an instance loaded earlier by the Session session.reconnect(); foo.setProperty("bar"); session.flush(); session.connection().commit(); session.disconnect();foo對象仍然知道是哪個Session把自己裝載的。 只要Session 擁有一個JDBC連接，我們可以把對象的更改提交。
如果我們的 Session 太大，以至于在用戶思考的時間內無法保存住，這種模式就會出現問題。比如，HttpSession應該保持盡量小。因為Session也持有（必須的）第一級緩存，包含所有被裝載的對象，我們只能在很少的request/response周期中使用這一策略。這種少用是被鼓勵的，因為Session 很快就會出現過時的數據。
10.4.2.?使用帶有自動版本化的多個會話
每個與持久化存儲的交互出現在一個新的Session中，在每次與數據庫的交互中，使用相同的持久化實例。應用操作那些從其它Session調入的已經脫離session的實例的狀態，通過使用Session.update()或者Session.saveOrUpdate()來重新建立與它們的關聯。
// foo is an instance loaded by a previous Session foo.setProperty("bar"); session = factory.openSession(); session.saveOrUpdate(foo); session.flush(); session.connection().commit(); session.close();你也可以調用lock()而非update()，如果你確信對象沒有被修改過，可以使用LockMode.READ（進行一次版本檢查，而跳過所有的緩存）。
10.4.3.?應用程序自己進行版本檢查
每當一個新的Session中與數據庫出現交互的時候，這個session會在操作持久化實例前重新把它們從數據庫中裝載進來。我們現在所說的方式就是你的應用程序自己使用版本檢查來確保應用事務的隔離性。（當然，Hibernate仍會為你更新版本號）。從數據庫訪問方面來看，這種方法是最沒有效率的，與entity EJB方式類似。
// foo is an instance loaded by a previous Session session = factory.openSession(); int oldVersion = foo.getVersion(); session.load( foo, foo.getKey() ); if ( oldVersion!=foo.getVersion ) throw new StaleObjectStateException(); foo.setProperty("bar"); session.flush(); session.connection().commit(); session.close();當然，如果在低數據并行（low-data-concurrency）的環境中，并不需要版本檢查，你仍可以使用這個方法，只需要忽略版本檢查。
10.5.?會話斷開連接（Session disconnection）
The first approach described above is to maintain a single Session for a whole business process thats spans user think time. (For example, a servlet might keep a Session in the user's HttpSession.) For performance reasons you should
上面提到的第一種方法是對于對一個用戶的一次登錄產生的整個商業過程維護一個Session。（舉例來說，servlet有可能會在用戶的HttpSession中保留一個Session）。為性能考慮，你必須
提交Transaction（或者JDBC連接），然后
(在等待用戶操作前，)斷開Session與JDBC連接。
Session.disconnect()方法會斷開會話與JDBC的連接，把連接返還給連接池（除非是你自己提供這個連接的）。
Session.reconnect()方法會得到一個新的連接（你也可以自己提供一個），重新開始會話。在重新連接后，你可以通過對任何可能被其它事務更新的對象調用Session.lock()方法，來強迫對你沒有更新的數據進行版本檢查。你不需要對正在更新的數據調用lock()。
這是一個例子：
SessionFactory sessions; List fooList; Bar bar; .... Session s = sessions.openSession();Transaction tx = null; try {tx = s.beginTransaction();fooList = s.find("select foo from eg.Foo foo where foo.Date = current date"// uses db2 date function);bar = (Bar) s.create(Bar.class);tx.commit(); } catch (Exception e) {if (tx!=null) tx.rollback();s.close();throw e; } s.disconnect();接下來：
s.reconnect();try {tx = s.beginTransaction();bar.setFooTable( new HashMap() );Iterator iter = fooList.iterator();while ( iter.hasNext() ) {Foo foo = (Foo) iter.next();s.lock(foo, LockMode.READ); //check that foo isn't stalebar.getFooTable().put( foo.getName(), foo );}tx.commit(); } catch (Exception e) {if (tx!=null) tx.rollback();throw e; } finally {s.close(); }從上面的例子可以看到Transaction和Session之間是多對一的關系。一個Session表示了應用程序與數據庫之間的一個對話，Transaction把這個對話分隔成一個個在數據庫級別具有原子性的單元。
10.6.?悲觀鎖定（Pessimistic Locking）
用戶不需要在鎖定策略上花費過多時間，通常我們可以對JDBC連接選定一種隔離級別（isolationn level），然后讓數據庫完成所有的工作。高級用戶可能希望得到悲觀鎖定或者在新的事務開始時重新得到鎖。
Hibernate一直都會使用數據庫的鎖定機制,而不會在內存中鎖定對象。
LockMode類定義了Hibernate需要的不同的鎖級別。鎖由以下的機制得到：
-
LockMode.WRITE在Hibernate更新或插入一行數據時自動得到。
-
LockMode.UPGRADE在用戶通過SELECT ... FOR UPDATE這樣的特定請求得到，需要數據庫支持這種語法。
-
LockMode.UPGRADE_NOWAIT在用戶通過SELECT ... FOR UPDATE NOWAIT這樣的特定請求在Oracle數據庫環境下得到。
-
LockMode.READ在Hibernate在不斷讀（Repeatable Read）和序列化（Serializable）的隔離級別下讀取數據時得到。也可以通過用戶的明確請求重新獲得。
-
LockMode.NONE表示沒有鎖。所有對象在Transaction結束時會切換到這種鎖模式，通過調用update()或者saveOrUpdate()與會話進行關聯的對象,開始時也會在這種鎖模式。
“明確的用戶請求”會以下的幾種方式出現：
-
調用Session.load()，指定一種LockMode。
-
調用Session.lock()。
-
調用Query.setLockMode()。
如果在調用Session.load()時指定了UPGRADE或者UPGRADE_NOWAIT，并且請求的對象還沒有被會話調入，那么這個對象會以SELECT ... FOR UPDATE的方式調入。如果調用load()在一個已經調入的對象，并且這個對象調入時的鎖級別沒有請求時來得嚴格，Hibernate會對這個對象調用lock()。
Session.lock()會執行版本號檢查的特定的鎖模式是：READ，UPGRADE或者UPGRADE_NOWAIT。（在UPGRADE或者UPGRADE_NOWAIT，SELECT ... FOR UPGRADE使用的情況下。）
如果數據庫不支持所請求的鎖模式，Hibernate將會選擇一種合適的受支持的鎖模式替換（而不是拋出一個異常）。這確保了應用具有可移植性。
?
＝＝＝＝＝＝＝＝＝＝＝＝http://www.redsaga.com/hibernate-ref/3.x/zh-cn/html/objectstate.html
第?10?章?與對象共事
Hibernate是完整的對象/關系映射解決方案，它提供了對象狀態管理(state management)的功能，使開發者不再需要理會底層數據庫系統的細節。 也就是說，相對于常見的JDBC/SQL持久層方案中需要管理SQL語句，Hibernate采用了更自然的面向對象的視角來持久化Java應用中的數據。
換句話說，使用Hibernate的開發者應該總是關注對象的狀態(state)，不必考慮SQL語句的執行。 這部分細節已經由Hibernate掌管妥當，只有開發者在進行系統性能調優的時候才需要進行了解。
10.1.?Hibernate對象狀態(object states)
Hibernate定義并支持下列對象狀態(state):
-
瞬時(Transient) - 由new操作符創建，且尚未與Hibernate Session 關聯的對象被認定為瞬時(Transient)的。瞬時(Transient)對象不會被持久化到數據庫中，也不會被賦予持久化標識(identifier)。 如果程序中沒有保持對瞬時(Transient)對象的引用，它會被垃圾回收器(garbage collector)銷毀。 使用Hibernate Session可以將其變為持久(Persistent)狀態。(Hibernate會自動執行必要的SQL語句)
-
持久(Persistent) - 持久(Persistent)的實例在數據庫中有對應的記錄，并擁有一個持久化標識(identifier)。 持久(Persistent)的實例可能是剛被保存的，或剛被加載的，無論哪一種，按定義對象都僅在相關聯的Session生命周期內的保持這種狀態。 Hibernate會檢測到處于持久(Persistent)狀態的對象的任何改動，在當前操作單元(unit of work)執行完畢時將對象數據(state)與數據庫同步(synchronize)。 開發者不需要手動執行UPDATE。將對象從持久(Persistent)狀態變成瞬時(Transient)狀態同樣也不需要手動執行DELETE語句。
-
脫管(Detached) - 與持久(Persistent)對象關聯的Session被關閉后，對象就變為脫管(Detached)的。 對脫管(Detached)對象的引用依然有效，對象可繼續被修改。脫管(Detached)對象如果重新關聯到某個新的Session上， 會再次轉變為持久(Persistent)的(Detached其間的改動將被持久化到數據庫)。 這個功能使得一種編程模型，即中間會給用戶思考時間(user think-time)的長時間運行的操作單元(unit of work)的編程模型成為可能。 我們稱之為應用程序事務，即從用戶觀點看是一個操作單元(unit of work)。
接下來我們來細致的討論下狀態(states)及狀態間的轉換(state transitions)（以及觸發狀態轉換的Hibernate方法）。
10.2.?使對象持久化
Hibernate認為持久化類(persistent class)新實例化的對象是瞬時(Transient)的。 我們可將瞬時(Transient)對象與session關聯而變為持久(Persistent)的。
DomesticCat fritz = new DomesticCat(); fritz.setColor(Color.GINGER); fritz.setSex('M'); fritz.setName("Fritz"); Long generatedId = (Long) sess.save(fritz);如果Cat的持久化標識(identifier)是generated類型的， 那么該標識(identifier)會自動在save()被調用時產生并分配給cat。 如果Cat的持久化標識(identifier)是assigned類型的，或是一個復合主鍵(composite key)， 那么該標識(identifier)應當在調用save()之前手動賦予給cat。 你也可以按照EJB3 early draft中定義的語義，使用persist()替代save()。
此外，你可以用一個重載版本的save()方法。
DomesticCat pk = new DomesticCat(); pk.setColor(Color.TABBY); pk.setSex('F'); pk.setName("PK"); pk.setKittens( new HashSet() ); pk.addKitten(fritz); sess.save( pk, new Long(1234) );如果你持久化的對象有關聯的對象(associated objects)（例如上例中的kittens集合） 那么對這些對象（譯注：pk和kittens）進行持久化的順序是任意的（也就是說可以先對kittens進行持久化也可以先對pk進行持久化）， 除非你在外鍵列上有NOT NULL約束。 Hibernate不會違反外鍵約束，但是如果你用錯誤的順序持久化對象（譯注：在pk持久之前持久kitten），那么可能會違反NOT NULL約束。
通常你不會為這些細節煩心，因為你很可能會使用Hibernate的 傳播性持久化(transitive persistence)功能自動保存相關聯那些對象。 這樣連違反NOT NULL約束情況都不會出現了 - Hibernate會管好所有的事情。 傳播性持久化(transitive persistence)將在本章稍后討論。
10.3.?裝載對象
如果你知道某個實例的持久化標識(identifier)，你就可以使用Session的load()方法 來獲取它。 load()的另一個參數是指定類的.class對象。 本方法會創建指定類的持久化實例，并從數據庫加載其數據(state)。
Cat fritz = (Cat) sess.load(Cat.class, generatedId); // you need to wrap primitive identifiers long pkId = 1234; DomesticCat pk = (DomesticCat) sess.load( Cat.class, new Long(pkId) );此外, 你可以把數據(state)加載到指定的對象實例上（覆蓋掉該實例原來的數據）。
Cat cat = new DomesticCat(); // load pk's state into cat sess.load( cat, new Long(pkId) ); Set kittens = cat.getKittens();請注意如果沒有匹配的數據庫記錄，load()方法可能拋出無法恢復的異常(unrecoverable exception)。 如果類的映射使用了代理(proxy)，load()方法會返回一個未初始化的代理，直到你調用該代理的某方法時才會去訪問數據庫。 若你希望在某對象中創建一個指向另一個對象的關聯，又不想在從數據庫中裝載該對象時同時裝載相關聯的那個對象，那么這種操作方式就用得上的了。 如果為相應類映射關系設置了batch-size， 那么使用這種操作方式允許多個對象被一批裝載（因為返回的是代理，無需從數據庫中抓取所有對象的數據）。
如果你不確定是否有匹配的行存在，應該使用get()方法，它會立刻訪問數據庫，如果沒有對應的行，會返回null。
Cat cat = (Cat) sess.get(Cat.class, id); if (cat==null) {cat = new Cat();sess.save(cat, id); } return cat;你甚至可以選用某個LockMode，用SQL的SELECT ... FOR UPDATE裝載對象。 請查閱API文檔以獲取更多信息。
Cat cat = (Cat) sess.get(Cat.class, id, LockMode.UPGRADE);注意，任何關聯的對象或者包含的集合都不會被以FOR UPDATE方式返回， 除非你指定了lock或者all作為關聯(association)的級聯風格(cascade style)。
任何時候都可以使用refresh()方法強迫裝載對象和它的集合。如果你使用數據庫觸發器功能來處理對象的某些屬性，這個方法就很有用了。
sess.save(cat); sess.flush(); //force the SQL INSERT sess.refresh(cat); //re-read the state (after the trigger executes)此處通常會出現一個重要問題: Hibernate會從數據庫中裝載多少東西？會執行多少條相應的SQLSELECT語句？ 這取決于抓取策略(fetching strategy)，會在第?19.1?節 “ 抓取策略(Fetching strategies) ”中解釋。
10.4.?查詢
如果不知道所要尋找的對象的持久化標識，那么你需要使用查詢。Hibernate支持強大且易于使用的面向對象查詢語言(HQL)。 如果希望通過編程的方式創建查詢，Hibernate提供了完善的按條件(Query By Criteria, QBC)以及按樣例(Query By Example, QBE)進行查詢的功能。 你也可以用原生SQL(native SQL)描述查詢，Hibernate提供了將結果集(result set)轉化為對象的部分支持。
10.4.1.?執行查詢
HQL和原生SQL(native SQL)查詢要通過為org.hibernate.Query的實例來表達。 這個接口提供了參數綁定、結果集處理以及運行實際查詢的方法。 你總是可以通過當前Session獲取一個Query對象：
List cats = session.createQuery("from Cat as cat where cat.birthdate < ?").setDate(0, date).list();List mothers = session.createQuery("select mother from Cat as cat join cat.mother as mother where cat.name = ?").setString(0, name).list();List kittens = session.createQuery("from Cat as cat where cat.mother = ?").setEntity(0, pk).list();Cat mother = (Cat) session.createQuery("select cat.mother from Cat as cat where cat = ?").setEntity(0, izi).uniqueResult();一個查詢通常在調用list()時被執行，執行結果會完全裝載進內存中的一個集合(collection)。 查詢返回的對象處于持久(persistent)狀態。如果你知道的查詢只會返回一個對象，可使用list()的快捷方式uniqueResult()。
10.4.1.1.?迭代式獲取結果(Iterating results)
某些情況下，你可以使用iterate()方法得到更好的性能。 這通常是你預期返回的結果在session，或二級緩存(second-level cache)中已經存在時的情況。 如若不然，iterate()會比list()慢，而且可能簡單查詢也需要進行多次數據庫訪問： iterate()會首先使用1條語句得到所有對象的持久化標識(identifiers)，再根據持久化標識執行n條附加的select語句實例化實際的對象。
// fetch ids Iterator iter = sess.createQuery("from eg.Qux q order by q.likeliness").iterate(); while ( iter.hasNext() ) {Qux qux = (Qux) iter.next(); // fetch the object// something we couldnt express in the queryif ( qux.calculateComplicatedAlgorithm() ) {// delete the current instanceiter.remove();// dont need to process the restbreak;} }10.4.1.2.?返回元組(tuples)的查詢
（譯注：元組(tuples)指一條結果行包含多個對象） Hibernate查詢有時返回元組(tuples)，每個元組(tuples)以數組的形式返回:
Iterator kittensAndMothers = sess.createQuery("select kitten, mother from Cat kitten join kitten.mother mother").list().iterator();while ( kittensAndMothers.hasNext() ) {Object[] tuple = (Object[]) kittensAndMothers.next();Cat kitten = tuple[0];Cat mother = tuple[1];.... }10.4.1.3.?標量(Scalar)結果
查詢可在select從句中指定類的屬性，甚至可以調用SQL統計(aggregate)函數。 屬性或統計結果被認定為"標量(Scalar)"的結果（而不是持久(persistent state)的實體）。
Iterator results = sess.createQuery("select cat.color, min(cat.birthdate), count(cat) from Cat cat " +"group by cat.color").list().iterator();while ( results.hasNext() ) {Object[] row = results.next();Color type = (Color) row[0];Date oldest = (Date) row[1];Integer count = (Integer) row[2];..... }10.4.1.4.?綁定參數
接口Query提供了對命名參數(named parameters)、JDBC風格的問號(?)參數進行綁定的方法。 不同于JDBC，Hibernate對參數從0開始計數。 命名參數(named parameters)在查詢字符串中是形如:name的標識符。 命名參數(named parameters)的優點是:
-
命名參數(named parameters)與其在查詢串中出現的順序無關
-
它們可在同一查詢串中多次出現
-
它們本身是自我說明的
10.4.1.5.?分頁
如果你需要指定結果集的范圍（希望返回的最大行數/或開始的行數），應該使用Query接口提供的方法:
Query q = sess.createQuery("from DomesticCat cat"); q.setFirstResult(20); q.setMaxResults(10); List cats = q.list();Hibernate 知道如何將這個有限定條件的查詢轉換成你的數據庫的原生SQL(native SQL)。
10.4.1.6.?可滾動遍歷(Scrollable iteration)
如果你的JDBC驅動支持可滾動的ResuleSet，Query接口可以使用ScrollableResults，允許你在查詢結果中靈活游走。
Query q = sess.createQuery("select cat.name, cat from DomesticCat cat " +"order by cat.name"); ScrollableResults cats = q.scroll(); if ( cats.first() ) {// find the first name on each page of an alphabetical list of cats by namefirstNamesOfPages = new ArrayList();do {String name = cats.getString(0);firstNamesOfPages.add(name);}while ( cats.scroll(PAGE_SIZE) );// Now get the first page of catspageOfCats = new ArrayList();cats.beforeFirst();int i=0;while( ( PAGE_SIZE > i++ ) && cats.next() ) pageOfCats.add( cats.get(1) );} cats.close()請注意，使用此功能需要保持數據庫連接（以及游標(cursor)）處于一直打開狀態。 如果你需要斷開連接使用分頁功能，請使用setMaxResult()/setFirstResult()
10.4.1.7.?外置命名查詢(Externalizing named queries)
你可以在映射文件中定義命名查詢(named queries)。 （如果你的查詢串中包含可能被解釋為XML標記(markup)的字符，別忘了用CDATA包裹起來。）
<query name="eg.DomesticCat.by.name.and.minimum.weight"><![CDATA[from eg.DomesticCat as catwhere cat.name = ?and cat.weight > ? ] ]></query>參數綁定及執行以編程方式(programatically)完成：
Query q = sess.getNamedQuery("eg.DomesticCat.by.name.and.minimum.weight"); q.setString(0, name); q.setInt(1, minWeight); List cats = q.list();請注意實際的程序代碼與所用的查詢語言無關，你也可在元數據中定義原生SQL(native SQL)查詢， 或將原有的其他的查詢語句放在配置文件中，這樣就可以讓Hibernate統一管理，達到遷移的目的。
10.4.2.?過濾集合
集合過濾器(filter)是一種用于一個持久化集合或者數組的特殊的查詢。查詢字符串中可以使用"this"來引用集合中的當前元素。
Collection blackKittens = session.createFilter(pk.getKittens(), "where this.color = ?").setParameter( Color.BLACK, Hibernate.custom(ColorUserType.class) ).list() );返回的集合可以被認為是一個包(bag, 無順序可重復的集合(collection))，它是所給集合的副本。 原來的集合不會被改動（這與“過濾器(filter)”的隱含的含義不符，不過與我們期待的行為一致）。
請注意過濾器(filter)并不需要from子句（當然需要的話它們也可以加上）。過濾器(filter)不限定于只能返回集合元素本身。
Collection blackKittenMates = session.createFilter(pk.getKittens(), "select this.mate where this.color = eg.Color.BLACK.intValue").list();即使無條件的過濾器(filter)也是有意義的。例如，用于加載一個大集合的子集：
Collection tenKittens = session.createFilter(mother.getKittens(), "").setFirstResult(0).setMaxResults(10).list();10.4.3.?條件查詢(Criteria queries)
HQL極為強大，但是有些人希望能夠動態的使用一種面向對象API創建查詢，而非在他們的Java代碼中嵌入字符串。對于那部分人來說，Hibernate提供了直觀的Criteria查詢API。
Criteria crit = session.createCriteria(Cat.class); crit.add( Expression.eq( "color", eg.Color.BLACK ) ); crit.setMaxResults(10); List cats = crit.list();Criteria以及相關的樣例(Example)API將會再第?15?章 條件查詢(Criteria Queries) 中詳細討論。
10.4.4.?使用原生SQL的查詢
你可以使用createSQLQuery()方法，用SQL來描述查詢，并由Hibernate處理將結果集轉換成對象的工作。 請注意，你可以在任何時候調用session.connection()來獲得并使用JDBC Connection對象。 如果你選擇使用Hibernate的API, 你必須把SQL別名用大括號包圍起來:
List cats = session.createSQLQuery("SELECT {cat.*} FROM CAT {cat} WHERE ROWNUM<10","cat",Cat.class ).list(); List cats = session.createSQLQuery("SELECT {cat}.ID AS {cat.id}, {cat}.SEX AS {cat.sex}, " +"{cat}.MATE AS {cat.mate}, {cat}.SUBCLASS AS {cat.class}, ... " +"FROM CAT {cat} WHERE ROWNUM<10","cat",Cat.class ).list()和Hibernate查詢一樣，SQL查詢也可以包含命名參數和占位參數。 可以在第?16?章 Native SQL查詢找到更多關于Hibernate中原生SQL(native SQL)的信息。
10.5.?修改持久對象
事務中的持久實例（就是通過session裝載、保存、創建或者查詢出的對象） 被應用程序操作所造成的任何修改都會在Session被刷出（flushed）的時候被持久化（本章后面會詳細討論）。 這里不需要調用某個特定的方法（比如update()，設計它的目的是不同的）將你的修改持久化。 所以最直接的更新一個對象的方法就是在Session處于打開狀態時load()它，然后直接修改即可：
DomesticCat cat = (DomesticCat) sess.load( Cat.class, new Long(69) ); cat.setName("PK"); sess.flush(); // changes to cat are automatically detected and persisted有時這種程序模型效率低下，因為它在同一Session里需要一條SQL SELECT語句（用于加載對象） 以及一條SQL UPDATE語句(持久化更新的狀態)。 為此Hibernate提供了另一種途徑，使用脫管(detached)實例。
請注意Hibernate本身不提供直接執行UPDATE或DELETE語句的API。 Hibernate提供的是狀態管理(state management)服務，你不必考慮要使用的語句(statements)。 JDBC是出色的執行SQL語句的API，任何時候調用session.connection()你都可以得到一個JDBC Connection對象。 此外，在聯機事務處理(OLTP)程序中，大量操作(mass operations)與對象/關系映射的觀點是相沖突的。 Hibernate的將來版本可能會提供專門的進行大量操作(mass operation)的功能。 參考第?13?章 批量處理（Batch processing），尋找一些可用的批量(batch)操作技巧。
10.6.?修改脫管(Detached)對象
很多程序需要在某個事務中獲取對象，然后將對象發送到界面層去操作，最后在一個新的事務保存所做的修改。 在高并發訪問的環境中使用這種方式，通常使用附帶版本信息的數據來保證這些“長“工作單元之間的隔離。
Hibernate通過提供使用Session.update()或Session.merge()方法 重新關聯脫管實例的辦法來支持這種模型。
// in the first session Cat cat = (Cat) firstSession.load(Cat.class, catId); Cat potentialMate = new Cat(); firstSession.save(potentialMate);// in a higher layer of the application cat.setMate(potentialMate);// later, in a new session secondSession.update(cat); // update cat secondSession.update(mate); // update mate如果具有catId持久化標識的Cat之前已經被另一Session(secondSession)裝載了， 應用程序進行重關聯操作(reattach)的時候會拋出一個異常。
如果你確定當前session沒有包含與之具有相同持久化標識的持久實例，使用update()。 如果想隨時合并你的的改動而不考慮session的狀態，使用merge()。 換句話說，在一個新session中通常第一個調用的是update()方法，以便保證重新關聯脫管(detached)對象的操作首先被執行。
希望相關聯的脫管對象（通過引用“可到達”的脫管對象）的數據也要更新到數據庫時（并且也僅僅在這種情況）， 應用程序需要對該相關聯的脫管對象單獨調用update() 當然這些可以自動完成，即通過使用傳播性持久化(transitive persistence)，請看第?10.11?節 “傳播性持久化(transitive persistence)”。
lock()方法也允許程序重新關聯某個對象到一個新session上。不過，該脫管(detached)的對象必須是沒有修改過的！
//just reassociate: sess.lock(fritz, LockMode.NONE); //do a version check, then reassociate: sess.lock(izi, LockMode.READ); //do a version check, using SELECT ... FOR UPDATE, then reassociate: sess.lock(pk, LockMode.UPGRADE);請注意，lock()可以搭配多種LockMode， 更多信息請閱讀API文檔以及關于事務處理(transaction handling)的章節。重新關聯不是lock()的唯一用途。
其他用于長時間工作單元的模型會在第?11.3?節 “樂觀并發控制(Optimistic concurrency control)”中討論。
10.7.?自動狀態檢測
Hibernate的用戶曾要求一個既可自動分配新持久化標識(identifier)保存瞬時(transient)對象，又可更新/重新關聯脫管(detached)實例的通用方法。 saveOrUpdate()方法實現了這個功能。
// in the first session Cat cat = (Cat) firstSession.load(Cat.class, catID);// in a higher tier of the application Cat mate = new Cat(); cat.setMate(mate);// later, in a new session secondSession.saveOrUpdate(cat); // update existing state (cat has a non-null id) secondSession.saveOrUpdate(mate); // save the new instance (mate has a null id)saveOrUpdate()用途和語義可能會使新用戶感到迷惑。 首先，只要你沒有嘗試在某個session中使用來自另一session的實例，你應該就不需要使用update()， saveOrUpdate()，或merge()。有些程序從來不用這些方法。
通常下面的場景會使用update()或saveOrUpdate()：
-
程序在第一個session中加載對象
-
該對象被傳遞到表現層
-
對象發生了一些改動
-
該對象被返回到業務邏輯層
-
程序調用第二個session的update()方法持久這些改動
saveOrUpdate()做下面的事:
-
如果對象已經在本session中持久化了，不做任何事
-
如果另一個與本session關聯的對象擁有相同的持久化標識(identifier)，拋出一個異常
-
如果對象沒有持久化標識(identifier)屬性，對其調用save()
-
如果對象的持久標識(identifier)表明其是一個新實例化的對象，對其調用save()
-
如果對象是附帶版本信息的（通過<version>或<timestamp>） 并且版本屬性的值表明其是一個新實例化的對象，save()它。
-
否則update() 這個對象
merge()可非常不同:
-
如果session中存在相同持久化標識(identifier)的實例，用用戶給出的對象的狀態覆蓋舊有的持久實例
-
如果session沒有相應的持久實例，則嘗試從數據庫中加載，或創建新的持久化實例
-
最后返回該持久實例
-
用戶給出的這個對象沒有被關聯到session上，它依舊是脫管的
10.8.?刪除持久對象
使用Session.delete()會把對象的狀態從數據庫中移除。 當然，你的應用程序可能仍然持有一個指向已刪除對象的引用。所以，最好這樣理解：delete()的用途是把一個持久實例變成瞬時(transient)實例。
sess.delete(cat);你可以用你喜歡的任何順序刪除對象，不用擔心外鍵約束沖突。當然，如果你搞錯了順序，還是有可能引發在外鍵字段定義的NOT NULL約束沖突。 例如你刪除了父對象，但是忘記刪除孩子們。
10.9.?在兩個不同數據庫間復制對象
偶爾會用到不重新生成持久化標識(identifier)，將持久實例以及其關聯的實例持久到不同的數據庫中的操作。
//retrieve a cat from one database Session session1 = factory1.openSession(); Transaction tx1 = session1.beginTransaction(); Cat cat = session1.get(Cat.class, catId); tx1.commit(); session1.close();//reconcile with a second database Session session2 = factory2.openSession(); Transaction tx2 = session2.beginTransaction(); session2.replicate(cat, ReplicationMode.LATEST_VERSION); tx2.commit(); session2.close();ReplicationMode決定數據庫中已存在相同行時，replicate()如何處理。
-
ReplicationMode.IGNORE - 忽略它
-
ReplicationMode.OVERWRITE - 覆蓋相同的行
-
ReplicationMode.EXCEPTION - 拋出異常
-
ReplicationMode.LATEST_VERSION - 如果當前的版本較新，則覆蓋，否則忽略
這個功能的用途包括使錄入的數據在不同數據庫中一致，產品升級時升級系統配置信息，回滾non-ACID事務中的修改等等。 （譯注，non-ACID，非ACID;ACID，Atomic，Consistent，Isolated and Durable的縮寫）
10.10.?Session刷出(flush)
每間隔一段時間，Session會執行一些必需的SQL語句來把內存中的對象的狀態同步到JDBC連接中。這個過程被稱為刷出(flush)，默認會在下面的時間點執行：
-
在某些查詢執行之前
-
在調用org.hibernate.Transaction.commit()的時候
-
在調用Session.flush()的時候
涉及的SQL語句會按照下面的順序發出執行：
所有對實體進行插入的語句，其順序按照對象執行Session.save()的時間順序
所有對實體進行更新的語句
所有進行集合刪除的語句
所有對集合元素進行刪除，更新或者插入的語句
所有進行集合插入的語句
所有對實體進行刪除的語句，其順序按照對象執行Session.delete()的時間順序
（有一個例外是，如果對象使用native方式來生成ID（持久化標識）的話，它們一執行save就會被插入。）
除非你明確地發出了flush()指令，關于Session何時會執行這些JDBC調用是完全無法保證的，只能保證它們執行的前后順序。 當然，Hibernate保證，Query.list(..)絕對不會返回已經失效的數據，也不會返回錯誤數據。
也可以改變默認的設置，來讓刷出(flush)操作發生的不那么頻繁。 FlushMode類定義了三種不同的方式。 僅在提交時刷出(僅當Hibernate的Transaction API被使用時有效)， 按照剛才說的方式刷出， 以及除非明確使用flush()否則從不刷出。 最后一種模式對于那些需要長時間保持Session為打開或者斷線狀態的長時間運行的工作單元很有用。 (參見 第?11.3.2?節 “長生命周期session和自動版本化”).
sess = sf.openSession(); Transaction tx = sess.beginTransaction(); sess.setFlushMode(FlushMode.COMMIT); // allow queries to return stale stateCat izi = (Cat) sess.load(Cat.class, id); izi.setName(iznizi);// might return stale data sess.find("from Cat as cat left outer join cat.kittens kitten");// change to izi is not flushed! ... tx.commit(); // flush occurs刷出(flush)期間，可能會拋出異常。（例如一個DML操作違反了約束） 異常處理涉及到對Hibernate事務性行為的理解，因此我們將在第?11?章 事務和并發中討論。
10.11.?傳播性持久化(transitive persistence)
對每一個對象都要執行保存，刪除或重關聯操作讓人感覺有點麻煩，尤其是在處理許多彼此關聯的對象的時候。 一個常見的例子是父子關系。考慮下面的例子:
如果一個父子關系中的子對象是值類型(value typed)（例如，地址或字符串的集合）的，他們的生命周期會依賴于父對象，可以享受方便的級聯操作(Cascading)，不需要額外的動作。 父對象被保存時，這些值類型(value typed)子對象也將被保存；父對象被刪除時，子對象也將被刪除。 這對將一個子對象從集合中移除是同樣有效：Hibernate會檢測到，并且因為值類型(value typed)的對象不可能被其他對象引用，所以Hibernate會在數據庫中刪除這個子對象。
現在考慮同樣的場景，不過父子對象都是實體(entities)類型，而非值類型(value typed)（例如，類別與個體，或母貓和小貓）。 實體有自己的生命期，允許共享對其的引用（因此從集合中移除一個實體，不意味著它可以被刪除）， 并且實體到其他關聯實體之間默認沒有級聯操作的設置。 Hibernate默認不實現所謂的可到達即持久化（persistence by reachability）的策略。
每個Hibernate session的基本操作 - 包括 persist(), merge(), saveOrUpdate(), delete(), lock(), refresh(), evict(), replicate() - 都有對應的級聯風格(cascade style)。 這些級聯風格(cascade style)風格分別命名為 create, merge, save-update, delete, lock, refresh, evict, replicate。 如果你希望一個操作被順著關聯關系級聯傳播，你必須在映射文件中指出這一點。例如：
<one-to-one name="person" cascade="create"/>級聯風格(cascade style)是可組合的:
<one-to-one name="person" cascade="create,delete,lock"/>你可以使用cascade="all"來指定全部操作都順著關聯關系級聯(cascaded)。 默認值是cascade="none"，即任何操作都不會被級聯(cascaded)。
注意有一個特殊的級聯風格(cascade style) delete-orphan，只應用于one-to-many關聯，表明delete()操作 應該被應用于所有從關聯中刪除的對象。
建議:
-
通常在<many-to-one>或<many-to-many>關系中應用級聯(cascade)沒什么意義。 級聯(cascade)通常在 <one-to-one>和<one-to-many>關系中比較有用。
-
如果子對象的壽命限定在父親對象的壽命之內，可通過指定cascade="all,delete-orphan"將其變為自動生命周期管理的對象(lifecycle object)。
-
其他情況，你可根本不需要級聯(cascade)。但是如果你認為你會經常在某個事務中同時用到父對象與子對象，并且你希望少打點兒字，可以考慮使用cascade="create,merge,save-update"。
可以使用cascade="all"將一個關聯關系（無論是對值對象的關聯，或者對一個集合的關聯）標記為父/子關系的關聯。 這樣對父對象進行save/update/delete操作就會導致子對象也進行save/update/delete操作。
此外，一個持久的父對象對子對象的淺引用(mere reference)會導致子對象被同步save/update。 不過，這個隱喻(metaphor)的說法并不完整。除非關聯是<one-to-many>關聯并且被標記為cascade="delete-orphan"， 否則父對象失去對某個子對象的引用不會導致該子對象被自動刪除。 父子關系的級聯(cascading)操作準確語義如下：
-
如果父對象被persist()，那么所有子對象也會被persist()
-
如果父對象被merge()，那么所有子對象也會被merge()
-
如果父對象被save()，update()或 saveOrUpdate()，那么所有子對象則會被saveOrUpdate()
-
如果某個持久的父對象引用了瞬時(transient)或者脫管(detached)的子對象，那么子對象將會被saveOrUpdate()
-
如果父對象被刪除，那么所有子對象也會被delete()
-
除非被標記為cascade="delete-orphan"（刪除“孤兒”模式，此時不被任何一個父對象引用的子對象會被刪除）， 否則子對象失掉父對象對其的引用時，什么事也不會發生。 如果有特殊需要，應用程序可通過顯式調用delete()刪除子對象。
10.12.?使用元數據
Hibernate中有一個非常豐富的元級別(meta-level)的模型，含有所有的實體和值類型數據的元數據。 有時這個模型對應用程序本身也會非常有用。 比如說，應用程序可能在實現一種“智能”的深度拷貝算法時， 通過使用Hibernate的元數據來了解哪些對象應該被拷貝（比如，可變的值類型數據）， 那些不應該（不可變的值類型數據，也許還有某些被關聯的實體）。
Hibernate提供了ClassMetadata接口，CollectionMetadata接口和Type層次體系來訪問元數據。 可以通過SessionFactory獲取元數據接口的實例。
Cat fritz = ......; ClassMetadata catMeta = sessionfactory.getClassMetadata(Cat.class);Object[] propertyValues = catMeta.getPropertyValues(fritz); String[] propertyNames = catMeta.getPropertyNames(); Type[] propertyTypes = catMeta.getPropertyTypes();// get a Map of all properties which are not collections or associations Map namedValues = new HashMap(); for ( int i=0; i<propertyNames.length; i++ ) {if ( !propertyTypes[i].isEntityType() && !propertyTypes[i].isCollectionType() ) {namedValues.put( propertyNames[i], propertyValues[i] );} }?
總結
以上是生活随笔為你收集整理的session 中对象实例在不同事务中的状态的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： hibernate实体的几种状态
- 下一篇： hibernate入门总结