hibernate中实体对象的三种状态（生命周期中的三种状态）

(1)  Transient：在内存中的自由存在，与数据库中的记录无关。

Java代码

1. public void methodA {    
2.     TUser user = new TUser();    
3.     user.setName("Emma");            ---user与数据库中的记录没有关联。    
4. }   

public void methodA { 
    TUser user = new TUser(); 
    user.setName("Emma");            ---user与数据库中的记录没有关联。 
} 

 
(2)  Persistent:处于由Hibernate框架所管理的状态。实体对象的引用被纳入Hibernate实体容器中加以管理。

Java代码

1. TUser user = new TUser();    
2. TUser anotherUser = new TUser();    
3.   
4. user.setName("Emma");    
5. anotherUser.setName("Kevin");    
6. //此时user和anotherUser都处于Transient状态    
7.   
8. Transaction tx = session.beginTransaction();    
9. session.save(user);    
10. //此时的user对象已经由Hibernate纳入实体管理容器，处于Persistent状态    
11. //而anotherUser仍然处于Transient状态。    
12. tx.commit();    
13. //事务提交之后，库表中已经插入一条用户"Emma"的记录    
14. //对于anotherUser则无任何操作    
15.   
16. Transaction tx2 = session.beginTransaction();    
17. user.setName("Emma_1"); //Persistent    
18. anotherUser.setName("Kevin_1"); //Transient    
19.   
20. tx2.commit();   

TUser user = new TUser(); 
TUser anotherUser = new TUser(); 

user.setName("Emma"); 
anotherUser.setName("Kevin"); 
//此时user和anotherUser都处于Transient状态 

Transaction tx = session.beginTransaction(); 
session.save(user); 
//此时的user对象已经由Hibernate纳入实体管理容器，处于Persistent状态 
//而anotherUser仍然处于Transient状态。 
tx.commit(); 
//事务提交之后，库表中已经插入一条用户"Emma"的记录 
//对于anotherUser则无任何操作 

Transaction tx2 = session.beginTransaction(); 
user.setName("Emma_1"); //Persistent 
anotherUser.setName("Kevin_1"); //Transient 

tx2.commit(); 

 

虽然这个事务中我们没有显式调用Session.save()方法保存user对象，但是由于处于
Persistent状态的对象将自动被固化到数据库中，因此user对象的变化也将被同步到
数据库中，也就是说数据库中"Emma"的用户记录已经被更新为"Emma_1"

此时anotherUser仍然是个普通Java对象，处于Transient状态，它不受Hibernate

框架管理，因此其属性的更改也不会对数据库产生任何影响.

Transient  ------Session.save()------>  Persistent
Object       ------Session.load()------>   Persistent
（Object    ---Session(有效期内)----->   Persistent）

Java代码

1. //由Hibernate返回的Persistent对象    
2. TUser user = (TUser)session.load(TUser.class,new Integer(1));    
3. //Session.load方法中，在返回对象之前，Hibernate就已经将其对象纳入    
4. //其实体容器中   

//由Hibernate返回的Persistent对象 
TUser user = (TUser)session.load(TUser.class,new Integer(1)); 
//Session.load方法中，在返回对象之前，Hibernate就已经将其对象纳入 
//其实体容器中 

 

Persistent对象 <------  一一对应 ------> 数据库中的一条记录

(3)  Detached：
Oberct(Persistent) -----对应的Session实例关闭-----> Object(Detached)

Java代码

1. TUser user = new TUser();    
2. user.setName("Emma");//user in Transistent    
3. Transaction tx = session.beginTransaction();    
4. session.save(user);//user in Persistent    
5. tx.commit();    
6. session.close();//user in Detached   

TUser user = new TUser(); 
user.setName("Emma");//user in Transistent 
Transaction tx = session.beginTransaction(); 
session.save(user);//user in Persistent 
tx.commit(); 
session.close();//user in Detached 

 
Detached 与 Transient的区别：
Detached对象可以再次与某个Session实例相关联而成为Persistent对象（Transient也可以，但其内部不一样）---Transient状态的user与库表中的数据缺乏对应关系，而Deatached状态的user却在库表中存在相应的记录（由主键唯一确定）。

人工制造一个Detached对象：

Java代码

1. TUser user = new TUser();    
2. user.setName("Emma");    
3. //硬编码为其指定主键值(假设库表中存在id=1的记录)    
4. user.setId(new Integer(1));    
5. //此时user成为一个"人造detached对象"    
6.   
7. Transaction tx = session.beginTransaction();    
8. session.update(user);//Session根据其主键值，将其变为Persistent    
9. user.setAge(new Integer(20));    
10. tx.commit();    
11.   
12. session.flush();    
13. session.close();   

TUser user = new TUser(); 
user.setName("Emma"); 
//硬编码为其指定主键值(假设库表中存在id=1的记录) 
user.setId(new Integer(1)); 
//此时user成为一个"人造detached对象" 

Transaction tx = session.beginTransaction(); 
session.update(user);//Session根据其主键值，将其变为Persistent 
user.setAge(new Integer(20)); 
tx.commit(); 

session.flush(); 
session.close(); 

 

Object(Persistent)---Session.delete()--->Object(Transient)

Transient： 从库表中找不到对应的记录。
Detached： 从库表中能找到对应的记录（只是没有与session进行关联）。

一般而言，应该避免直接将PO传递到系统中的其他层面，一种解决办法是，通过构造一个新的VO,通过属性父指示器具备与PO相同的属性值，并以其为传输媒质（实际上，这个VO被用作Data Transfer Object，即DTO），将此VO传递给其他层面以实现必须的数据传送。