Hibernate持久化对象的生命周期

持久化对象的状态：

瞬时对象（Transient Objects）：使用new操作符初始化的对象不是立刻就持久化的。他们的状态是瞬时的，也就是说他们没有任何跟数据库表相关联的行为，只要应用不再引用这些对象（不再被任何其他对象所引用），他们的状态将会丢失，并由垃圾回收机制回收。

临时对象的特征。临时对象具有以下特征：
(1) 不处于Session的缓存中，也可以说，不被任何一个Session实例关联。
(2) 在数据库中没有对应的记录。

在以下情况下，Java对象进入临时状态：
(1) 当通过new语句刚创建了一个Java对象，它处于临时状态，此时不和数据库中的任何记录对应。
(2) Session的delete()方法能使一个持久化对象或游离对象转变为临时对象。对于游离对象，delete()方法从数据库中删除与它对应的记录；对于持久化对象，delete()方法从数据库中删除与它对应的记录，并且把它从Session的缓存中删除。

持久化对象（Persist Objects）：持久实例是任何具有数据库标识的实例。它有持久化管理器Session统一管理，持久实例是在事务中进行操作的———他们的状态在事务结束时同数据库进行同步。当事务提交时，通过执行SQL的INSET,UPDATE和DELETE语句把内存中的状态同步到数据库中。

持久化对象的特征。持久化对象具有以下特征：
(1) 位于一个Session实例的缓存中，也可以说，持久化对象总是被一个Session实例关联。
(2) 持久化对象和数据库中的相关记录对应。
(3) Session在清理缓存时，会根据持久化对象的属性变化，来同步更新数据库。

Session的许多方法都能够触发Java对象进入持久化状态：
(1) Session的save()方法把临时对象转变为持久化对象。
(2) Session的load()或get()方法返回的对象总是处于持久化状态。
(3) Session的find()方法返回的List集合中存放的都是持久化对象。
(4) Session的update()、saveOrUpdate()和lock()方法使游离对象转变为持久化对象。
(5)当一个持久化对象关联一个临时对象，在允许级联保存的情况下，Session在清理缓存时会把这个临时对象也转变为持久化对象。

Hibernate 保证在同一个Session实例的缓存中，数据库表中的每条记录只对应惟一的持久化对象。例如对于以下代码，共创建了两个Session实例：session1和session2。session1和session2拥有各自的缓存。在session1的缓存中，只会有惟一的OID为1的 Customer持久化对象，在session2的缓存中，也只会有惟一的OID为2的Customer持久化对象。因此在内存中共有两个 Customer持久化对象，一个属于session1的缓存，一个属于session2的缓存。引用变量a和b都引用session1缓存中的 Customer持久化对象，而引用变量c引用session2缓存中的Customer持久化对象：

Session session1=sessionFactory.openSession();
Session session2=sessionFactory.openSession();
Transaction tx1 = session1.beginTransaction();
Transaction tx2 = session2.beginTransaction();

Customer a=(Customer)session1.load(Customer.class,new Long(1));
Customer b=(Customer)session1.load(Customer.class,new Long(1));
Customer c=(Customer)session2.load(Customer.class,new Long(1));

System.out.println(a= =b); //true
System.out.println(a= =c); //false

tx1.commit();
tx2.commit();
session1.close();
session2.close();

Java对象的持久化状态是相对于某个具体的Session实例的，以下代码试图使一个Java对象同时被两个Session实例关联：

Session session1=sessionFactory.openSession();
Session session2=sessionFactory.openSession();
Transaction tx1 = session1.beginTransaction();
Transaction tx2 = session2.beginTransaction();

Customer c=(Customer)session1.load(Customer.class,new Long(1)); //Customer对象被session1关联
session2.update(c); //Customer对象被session2关联
c.setName("Jack"); //修改Customer对象的属性

tx1.commit(); //执行update语句
tx2.commit(); //执行update语句
session1.close();
session2.close();

当执行session1的load()方法时，OID为1的Customer对象被加入到session1的缓存中，因此它是session1的持久化对象，此时它还没有被session2关联，因此相对于session2，它处于游离状态。当执行session2的update()方法时，Customer对象被加入到session2的缓存中，因此也成为session2的持久化对象。接下来修改Customer对象的name属性，会导致两个Session实例在清理各自的缓存时，都执行相同的update语句：

update CUSTOMERS set NAME='Jack' …… where ID=1;
在实际应用程序中，应该避免一个Java对象同时被多个Session实例关联，因为这会导致重复执行SQL语句，并且极容易出现一些并发问题。

离线对象（Detached Objects）：Session关闭之后，持久化对象就变为离线对象。离线表示这个对象不能再与数据库保持同步，他们不再受Hibernate管理。


游离对象的特征。游离对象具有以下特征：
(1) 不再位于Session的缓存中，也可以说，游离对象不被Session关联。
(2) 游离对象是由持久化对象转变过来的，因此在数据库中可能还存在与它对应的记录（前提条件是没有其他程序删除了这条记录）。

游离对象与临时对象的相同之处在于，两者都不被Session关联，因此Hibernate不会保证它们的属性变化与数据库保持同步。游离对象与临时对象的区别在于：前者是由持久化对象转变过来的，因此可能在数据库中还存在对应的记录，而后者在数据库中没有对应的记录。

Session的以下方法使持久化对象转变为游离对象：
(1) 当调用Session的close()方法时，Session的缓存被清空，缓存中的所有持久化对象都变为游离对象。如果在应用程序中没有引用变量引用这些游离对象，它们就会结束生命周期。
(2)Session 的evict()方法能够从缓存中删除一个持久化对象，使它变为游离状态。当Session的缓存中保存了大量的持久化对象，会消耗许多内存空间，为了提高性能，可以考虑调用evict()方法，从缓存中删除一些持久化对象。但是多数情况下不推荐使用evict()方法，而应该通过查询语言，或者显式的导航来控制对象图的深度。





Java对象在JVM中的生命周期：

创建一个Java对象时，JVM会为这个对象分配一个内存空间，只要这个对象被引用变量引用，就一直存在于内存中，如果一个对象不被任何引用变量引用，就结束生命周期。Java集合（List、Map、Set）存放的是Java对象的引用，当向集合中添加一个对象时，其实是把这个对象的引用添加到集合中。因此集合中含有的对象生命周期一直存在。

请参考图片

理解Session的缓存：

在Session接口的实现中定义一系列的Java集合，这些集合构成了Session的缓存。

Session缓存的作用：1、减少访问数据库的频率，可以提高数据库访问的性能。2、保证缓存中的对象与数据库中的相关记录保持同步。3、当缓存中的持久化对象（位于缓存中的对象）之间存在循环关联关系时，Sessioin会保证不出现访问对象的死循环。

在Hibernate应用中Java对象的状态：

临时状态（transient）：刚用new语句创建，还没有被持久化，不处于Session的缓存中。处于临时状态的Java对象称为临时对象。

持久化状态（persistent）：已经被持久化，加入到Session的缓存中。处于持久化状态的Java对象称为持久化对象。

游离状态（detached）：已经被持久化，但不再处于Session的缓存中。处于游离状态的Java对象称为游离对象。

Java对象：开始生命周期——》临时状态——》持久化状态——》游离状态——》结束生命周期

请参考图片

Session的保存、更新、删除、查询方法：

1、Session的save()方法

session.save(customer);完成的操作：

(1)把Customer对象加载到缓存中，使它变为持久化对象。

(2)选用映射文件指定的标识符生成器为持久化对象分配唯一的OID。Customer.hbm.xml文件中<id>元素的<generator>子元素指定标识符生成器。

(3)计划执行一个insert语句，把Customer对象当前的属性值组装到insert语句中。

insert into CUSTOMERS(ID, NAME, ......) values(1, "Tom", ......)

save()方法并不立即执行SQL insert语句。只有当Session清理缓存时，才会执行SQL语句。

2、Session的update()方法

session.update(customer);完成的操作：

(1)把Customer对象重新加入到Session缓存中，使它变为持久化对象。

(2)计划执行一个update语句。Session只有在清理缓存时才会执行update语句，并且在执行时才会把Customer对象当前的属性值组装到update语句中。

(3)只要通过update()方法使游离对象被一个Session关联，即使没有修改Customer对象的任何属性，Session在清理缓存时也会执行由update()方法计划的update语句。

update CUSTOMERS set NAME="Tom", ...... where ID=1

如果希望Session仅当修改了Customer对象的属性时，才执行update语句，可把映射文件Customer.hbm.xml中<class>元素的"select-before-update"设为true(该属性默认为false)

<class name="mypack.Customer" table="CUSTOMERS" select-before-update="true">

当Session清理缓存时，先执行一条select语句，然后比较Customer对象的属性是否和从数据库中检索出来的记录一致，只有在不一致时才执行update语句。

3、Session的saveOrUpdate()方法

如果传入的参数是临时对象，就调用save()方法；如果传入的参数是游离对象，就调用update()方法；如果传入的参数是持久化对象，那就直接返回。

Hibernate判断临时对象的条件：

(1)Java对象的OID取值为null

(2)Java对象具有version属性并且取值为null

(3)在映射文件中为<id>元素设置了unsaved-value属性，并且OID取值与unsaved-value属性只匹配

(4)在映射文件中为version属性设置了unsaved-value属性，并且version属性取值与unsaved-value属性值匹配

(5)自定义了Hibernate的Interceptor实现类，并且Interceptor的isUnsaved()方法返回Boolean.TRUE

4、Session的load()方法和get()方法

根据给定的OID从数据库中加载一个持久化对象。

当数据库中不存在与OID对应的记录时

load()方法，返回ObjectNotFoundException异常

get()方法，返回null。

5、Session的delete()方法

如果传入的参数是持久化对象，Session就计划执行一个delete语句；如果传入的参数是游离对象，先使游离对象被Session关联，使它变为持久化对象，然后计划执行一个delete语句。

Session只有在清理缓存的时候才会执行delete语句。只有当调用Session的close()方法时，才会从Session的缓存中删除该对象。

session.delete(customer);

session.delete("from Customer as c where c.id>8");

级联操纵对象图

在对象-关系关联映射文件中，用于映射持久化类之间关联关系的元素<set>、<many-to-one>、<one-to-one>有cascade属性，用于指定如何操纵与当前对象关联的其他对象。

cascade属性可选值：none、save-update、delete、all、delete-orphan、all-delete-orphan

Hibernate与触发器协同工作

能激发触发器运行的事件：

插入（insert）记录事件、更新（update）记录事件、删除（delete）记录事件

利用拦截器（Interceptor）生成审计日志

用户定义的拦截器必须实现org.hibernate.Interceptor接口。

Interceptor对象有两种存放方式：

SessionFactory.openSession(Interceptor)：为每个Session实例分配一个Interceptor实例，这个实例存放在Session范围内。

Configuration.setInterceptor(Interceptor)：为SessionFactory实例分配一个Interceptor实例，这个实例存放在SessionFactory范围内，被所有Session实例共享。










操纵持久化对象


1.   理解Session的缓存：
在Java里面，缓存通常是指Java对象的属性占用的内存空间，通常是一些集合类型的属性。在session接口的实现类SessionImpl中定义了一系列的Java集合，这些Java集合就构成了Session的缓存。
当 Session的save()方法持久化一个对象时，这个对象被加入到Session的缓存中，以后即使应用程序中的引用变量不再引用这个对象，只要 Session的缓存还没有被清空，这个对象仍然处于生命周期中。当Session的load()方法加载一个对象时，Session会先判断缓存中是否已经存在这个对象了，如果存在，就不需要再到数据库中重新加载了。
Session的缓存有两大作用：
1.1.       减少访问数据库的频率。
1.2.       保证缓存中的对象与数据库中的相关记录保持同步。
Session有两个方法：一个commit()事务提交方法，还有flush()刷新缓存方法，都有着清理缓存的作用。flush()进行缓存的清理，执行一系列的SQL语句，但不会提交事务。而commit()方法会先调用flush()方法，然后在提交事务。
2.   定义持久化类的建议：
在应用程序中，用来实现业务问题实体的（如，在电子商务应用程序中的Customer和Order）类就是持久化类。如果这些持久化类遵循一些简单的规则，Hibernate能够工作得更好，这些规则也被称作简单传统Java对象(POJO:Plain Old Java Object)编程模型。但是这些规则并不是必需的。最好要遵循以下几条主要的规则：
1)     实现一个默认的（即无参数的）构造方法（constructor）：
我们强烈建议，在Hibernate中，为了运行期代理的生成，构造方法至少是包(package)内可见的。
2)     提供一个标识属性（identifier property）：
我们建议你对持久化类声明命名一致的标识属性。我们还建议你使用一个可以为空（也就是说，不是原始类型）的类型。
3)     使用非final的类：
代理（proxies）是Hibernate的一个重要的功能，它依赖的条件是，持久 化类或者是非final的，或者是实现了一个所有方法都声明为public的接口。你也应该避免在非final类中声明public final的方法。
4)     为持久化字段声明访问器(accessors)：
5)     如果你有如下需求，你必须重载 equals() 和 hashCode()方法：
l 想把持久类的实例放入Set中（当表示多值关联时，推荐这么做）
l 想重用脱管实例
Hibernate保证，仅在特定会话范围内，持久化标识（数据库的行）和Java标识是等价的。因此，一旦 我们混合了从不同会话中获取的实例，如果希望Set有明确的语义，就必须实现equals() 和hashCode()。
3.   持久化对象的三种状态：
一个持久化类的实例可能处于三种不同状态中的某一种。
3.1.   瞬时（transient）状态：
该实例是刚用new语句创建的，还没有被持久化，不处于任何Session的缓存中。它没有持久化标识（相当于主键值）。处于瞬时状态的实例被称为瞬时对象。它的特点是：
不和任何一个Session实例关联。在数据库中没有对应的记录。
3.2.   持久化(persistent)状态：
已经被持久化，加入到Session缓存中。处于持久化状态的实例被称为持久化对象。
实例目前与某个Session有关联。 它拥有持久化标识（相当于主键值），并且可能在数据库中有一个对应的行。 Hibernate保证在同一个Sesion实例的缓存中，数据库中的每条记录只对应唯一的持久化对象。 它的特点是：
       持久化对象总是被一个Session实例关联。持久化对象和数据库中的相关记录对应。Session在清理缓存时，会根据持久化对象的属性变化，来同步更新数据库。
3.3.   脱管(detached)状态：
已经被持久化过，但不再处于Session的缓存中。处于脱管状态的实例被称为脱管对象。实例曾经与某个持久化上下文发生过关联，不过那个上下文被关闭了，或者这个实例是被序列化(serialize)到另外的进程。 它拥有持久化标识，并且在数据库中可能存在一个对应的行。对于脱管状态的实例，Hibernate不保证任何持久化标识和Java标识的关系。它的特点是：
不再位于session的缓存中，即它不再和session关联。它拥有持久化标识。
4.   Session的保存、删除、更新和查询方法：
4.1.   Session的save()方法：使用一个临时对象转变为持久对象。
方法签名：public Serializable save(Object object) throws HibernateException; 它完成以下操作：
1)     把持久化类的实例加入到缓存中，使它变为持久化对象。
2)     选用映射文件指定的标识符生成器为持久化对象分配唯一的OID。
3)     计划执行一个insert语句，把持久化对象当前的属性值组装到insert 语句(SQL DML)中。值得注意的是，save()方法并不是立即执行SQL insert语句。只有当Session清理缓存时，才会执行SQL insert语句。
另外，需要注意的是：Hibernate通过持久化对象的OID来维持它和数据库相关记录的对应关系。所以当持久化的实例处于持久化状态时，不允许程序随意修改它的OID。其实，无论java对象处于瞬时状态、持久化状态还是脱管状态，程序都不应该修改它的OID。
4.2.   Session的update()方法：使一个脱管对象转变为持久化对象。
方法签名：public void update(Object object) throws HibernateException; 它完成以下操作：
1)     把脱管对象重新加入到Session缓存中，使它变为持久化对象。
2)     计划执行一个update语句。值得注意的是，Session只有在清理缓存的时候才会执行update语句，并且在执行时才会把持久化对象当前的属性值组装到update语句中。
4.3.   Session的saveOrUpdate()方法：
       方法签名：public void saveOrUpdate(Object object) throws HibernateException ; saveOrUpdate()方法同时包含了save()与update()方法的功能，如果传入的参数是瞬时对象，就调用save()方法；如果传入的参数是脱管对象，就调用update()方法；如果传入的参数是持久化对象，方法就直接返回。那么，saveOrUpdate()方法如果判断一个对象处于瞬时状态不是脱管状态呢？如果满足以下情况之一，Hibernate就把它作为临时对象：
1)     Java对象的OID取值为null。
2)     Java对象具有version属性，并且取值了null。
3)     在映射文件中为<id>元素设置了unsaved-value属性，并且OID取值与unsaved-value属性值匹配。
4)     在映射文件中为<version>元素设置了unsaved-value属性，并且version属性取值与unsaved-value属性值匹配。
5)     自定义了Hibernate的Interceptor实现类，并且Interceptor的isUnsaved()方法返回Boolean.TRUE。
4.4.   Session的delete()方法：
方法签名：public void delete(Object object) throws HibernateException; delete()方法用于从数据库中删除与Java对象对应的记录。如果传入的参数是持久化对象，Session就计划执行一个delete语句。如果传入的参数是游离对象，先使游离对象被Session关联，使它变为持久化对象，然后计划执行一个delete语句。值得注意的也是，Session只有在清理缓存的时候才会执行delete语句。
5.   通过主键ID取得数据对象：
5.1.   Session的get()方法：
       方法签名：public Object get(Class clazz, Serializable id) throws HibernateException; 根据给定的OID从数据库中加载一个持久化对象，若数据库中不存在与OID对应的记录，此方法返回null。
       get()方法的执行顺序如下：
1)     首先通过id在session缓存中查找对象，如果存在此id主键值的对象，直接将其返回。如果不存在，将进行第2步。
2)     在二级缓存中查找，找到后将其返回。
3)     如果在session缓存和二级缓存中都找不到此对象，刚从数据库加载拥有此id的对象。如果数据库也不存在这个拥有此id的对象，则返回null。
5.2.   Session的load()方法：
方法签名：public Object load(Class theClass, Serializable id) throws HibernateException; 根据给定的OID从数据库中加载一个持久化对象，若数据库中不存在与OID对应的记录，此方法将抛出 org.hibernate.ObjectNotFoundException异常。
对于get和load的根本区别，一句话，hibernate对于load方法认为该数据在数据库中一定存在，可以放心的使用代理来延迟加载，如果在使用过程中发现了问题，只能抛异常；而对于get方法，hibernate一定要获取到真实的数据，否则返回null。
6.   Query接口：
Hibernate提供Query接口，它用来执行HQL语句。
6.1.   绑定参数
6.1.1.      使用 “?”按参数位置绑定：
通过Query接口执行HQL语句时，可以先设定查询参数，然后通过setXXX()方法来绑定参数。如下

Query query = session.createQuery("from User as u where u.age > ? and u.name like ?");
query.setInteger(0, 25);
query.setString(1, "%a%");
List list = query.list();
Hibernate 提供了绑定各种类型的参数的方法，如参数为字符串类型，可调用setString()，如果参数为整数类型，可调用setInteger()方法，以此类推。这些setXXX()方法的第1个参数HQL查询语句中参数的位置，第2个参数代表HQL查询语句中参数的值。
6.1.2.      使用 “:” 后跟变量名来按命名参数绑定：
可以使用命名参数来取代使用“?”设置参数的方法，这可以不用依照特定的顺序来设定参数值，如上例可改成：

Query query = session.createQuery("from User as u where u.age > :minAge and u.name like likeName");
query.setInteger("minAge", 25);
query.setString("likeName", "%a%");
List list = query.list();
使用命名参数方式的绑定方式有以下优势：
1)     代码可读性更好。
2)     命名参数不依赖它们在查询字符串中出现的位置。
3)     在同一个查询中可以多次使用。
所以，应该优先考虑使用命名参数方式。
6.2.   使用命名查询(nameQuery)：
可以将HQL语句编写在程序之外，以避免硬编码在程序之中，这样要修改HQL语句时就很方便。在xxx.hbm.xml中使用<qiuery/>标签，并在<![CDATA[ 与 ]]> 之间编写HQL，如下Student.hbm.xml：

......
<hibernate-mapping>
   <classname="org.qiujy.demo.User"table="user">
       <idname="id"column="id"type="java.lang.Integer">
           <generatorclass="native"/>
       </id>
       <propertyname="name"column="name"type="java.lang.String"/>
       <propertyname="age"column="age"type="java.lang.Integer"/>
   </class>
<query name="queryUserByAgeAndName">
    <![CDATA[
    from User as u where u.age >:minAge and u.name like :likeName
]]>
</query>
</hibernate-mapping>
在代码中这样来调用：

Query query = session.getNamedQuery("queryUserByAgeAndName");
query.setInteger("minAge", 25);
query.setString("likeName", "%a%");
List list = query.list();
6.3.   Query接口的list()方法：
Query接口的list()方法用于取得一个List类的实例，此实例中包括的可能是一个对象集合，也可能是一个对象数组集合。最常见的使用是用list()方法来取得一组符合实例对象。如上示例。
6.4.   Query接口的uniqueResult()方法：
当确信使用的HQL语句查询时返回的集合中只有一个对象时，就可以使用这个方法。但如果返回结果中有多个对象，使用这个方法会抛出org.hibernate.NonUniqueResultException 异常，说“query did not return a unique result”。