org.hibernate.cfg?Class Configuration

An instance of?Configuration?allows(允許) ?the application to specify properties and mapping documents to be used when creating a?SessionFactory. Usually an application will create a single?Configuration, build a single instance of?SessionFactory?and then instantiate?Sessions in threads servicing client requests. The?Configuration?is meant(意味著) only as an initialization-time object.?SessionFactorys are immutable anddo not retain(不保留) anyassociation(關聯) back to the?Configuration.

A new?Configuration?will use the properties specified in?hibernate.properties?by default.

buildSessionFactory

Instantiate a new?SessionFactory, using the properties and mappings in this configuration. The?SessionFactory?will be immutable, so changes made to the?Configuration?after building the?SessionFactory?will notaffect(影響) it.

org.hibernate?
Interface SessionFactory

The main contract here is the creation of?Session?instances. Usually an application has a single?SessionFactory?instance and threads servicing client requests obtain(獲得,得到)?Sessioninstances from this factory.

The internal state of a?SessionFactory?is immutable. Once(一旦) it is created this internal state isset(設置的). This internal state includes all of themetadata(元數據)about Object/Relational Mapping.

Implementors?must?be threadsafe.

org.hibernate?
Interface Session

The main runtime?interface?between a Java application and Hibernate. This is the central API class abstracting the notion(概念) of a persistence(持久化) service.

The?lifecycle(生命周期) of a?Session?is bounded(有界限) by the beginning and end of a logical(邏輯) transaction. (Long transactions might span(跨越,持續,有) several(多個) database transactions.)

The main function(功能,用途,函數) of the?Session?is to offer(提供) create, read and delete operations for instances of mapped entity classes. Instances may exist in one of three states:

transient(短暫的,瞬時的):?never persistent(持續,持久,固執的), not associated(關聯) with any?Session
persistent:?associated with(與..相關) a unique?Session
detached(分離的):?previously(以前) persistent, not associated with any?Session

Transient instances may be made persistent by calling?save(),?persist()?or?saveOrUpdate(). Persistent instances may be made transient by calling?delete(). Any instance returned by a?get()?or?load()?method is persistent. Detached instances may be made persistent by calling?update(),?saveOrUpdate(),?lock()?or?replicate(). The state of a?transient or detached instance may also be made persistent as a new persistent instance by calling?merge().

save()?and?persist()?result in an SQL?INSERT,?delete()?in an SQL?DELETE?and?update()?or?merge()?in an SQL?UPDATE. Changes to?persistent?instances aredetected(檢測到) at flush time and also result in an SQL?UPDATE.?saveOrUpdate()?and?replicate()?result in either(任何一個) an?INSERT?or an?UPDATE.

It is not intended that implementors be threadsafe. Instead(相反) each thread/transaction shouldobtain(獲得,獲取) its own instance from a?SessionFactory.

A?Session?instance is serializable if its persistent classes are serializable.

A typical(典型的) transaction should use the following idiom:

Session sess = factory.openSession();Transaction tx;try {tx = sess.beginTransaction();//do some work...tx.commit();}catch (Exception e) {if (tx!=null) tx.rollback();throw e;}finally {sess.close();}
If the?Session?throws an exception, the transaction must be rolled back and the sessiondiscarded(廢棄,丟棄). The internal state of the?Session?might not be consistent(不一致) with the database after the exceptionoccurs(發生).

org.hibernate?
Interface Transaction

Allows the application to defineunits of work(操作單元), whilemaintaining(維護) abstraction from theunderlying(底層的) transaction implementation (eg. JTA, JDBC).

A transaction is associated(關聯) with a?Session?and is usually instantiated by a call to?Session.beginTransaction(). A single session might span multiple transactions since the notion of a session (a conversation(對話) between the application and the datastore) is of coarser(粗糙) granularity(粒度) than the notion of a transaction. However, it is intended that there be at most one uncommitted?Transaction?associated with a particular?Session?at any time.

Implementors are not intended to be threadsafe.

轉載于:https://www.cnblogs.com/springside4/archive/2012/04/17/2481164.html

總結

以上是生活随笔為你收集整理的Configuration、SessionFactory、Session的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。