Configuration、SessionFactory、Session

文章目錄

• buildSessionFactory

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.

buildSessionFactoryInstantiate 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 SessionFactoryThe 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 SessionThe 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 TransactionAllows 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.