Hibernate持久化对象的三种状态

持久化对象的状态:
1.瞬时对象(Transient Objects):使用new 操作符初始化的对象不是立刻就持久的。它们的状态是瞬时的,也就是说它们没有任何跟数据表相关联的行为,只要应用不再引用这些对象(不再被任何其它对象所引用),它们的状态将会丢失,并由垃圾回收机制回收。
2.持久化对象(Persist Objects):持久实例是任何具有数据库标识的实例。它有持久化管理器Session统一管理,持久实例是在事务中进行操作的。它们的状态在事务结束时同数据库进行同步。当事务提交时,通过执行SQL的insert、update和delete语句把内存中的状态同步到数据库中。
3.离线对象(Detached Objects):Session关闭之后,持久化对象就变为离线对象。离线表示这个对象不能再与数据库保持同步,它们不再受Hibernate管理。

下面通过一个小例子来具体说明持久化对象的生命周期:

为了方便,先创建一个管理Session的工具类HibernateUtils.java,代码如下:

Java代码   
  1. package com.ysj.utils;  
  2.   
  3. import org.hibernate.Session;  
  4. import org.hibernate.SessionFactory;  
  5. import org.hibernate.cfg.Configuration;  
  6.   
  7.   
  8. public class HibernateUtils {  
  9.       
  10.     /** 
  11.      * 创建静态块,用于初始化SessionFactory 
  12.      */  
  13.     private static SessionFactory factory ;  
  14.     static{  
  15.         try{  
  16.             // 默认获取src根目录下的 hibernate.cfg.xml配置文件  
  17.             Configuration cfg = new Configuration().configure();  
  18.             // 通过配置文件获取 sessionFactory  
  19.             factory = cfg.buildSessionFactory() ;   
  20.         }catch(Exception e){  
  21.             e.printStackTrace() ;  
  22.         }  
  23.     }  
  24.       
  25.     /** 
  26.      * 获得SessionFactory 
  27.      */  
  28.     public static SessionFactory getSessionFactory(){  
  29.         return factory ;  
  30.     }  
  31.       
  32.     /** 
  33.      * 获得Session 
  34.      */  
  35.     public static Session getSession(){  
  36.         if(factory != null){  
  37.             return factory.openSession() ;  
  38.         }else{  
  39.             return null ;  
  40.         }  
  41.     }  
  42.       
  43.     /** 
  44.      * 关闭Session 
  45.      */  
  46.     public static void closeSession(Session session){  
  47.         if(session != null){  
  48.             if(session.isOpen()){  
  49.                 session.close() ;  
  50.                 session = null ;  
  51.             }  
  52.         }  
  53.     }  
  54. }  

测试类SessionTest.java,代码如下:

Java代码  
  1. package com.ysj;  
  2.   
  3. import java.util.Date;  
  4.   
  5. import junit.framework.TestCase;  
  6.   
  7. import org.hibernate.Session;  
  8. import org.hibernate.Transaction;  
  9.   
  10. import com.ysj.utils.HibernateUtils;  
  11.   
  12. public class SessionTest extends TestCase {  
  13.       
  14.     /** 
  15.      * 持久化对象生命周期的过程演示 
  16.      */  
  17.     public void testSave(){  
  18.         Session session = null ;  
  19.         Transaction tran = null ;  
  20.         User user = null ;  
  21.         try{  
  22.             session = HibernateUtils.getSession() ;  
  23.             tran = session.beginTransaction() ;  
  24.             /** 
  25.              * Transient(瞬态) : 
  26.              * 1、在数据库中没有与之匹配的数据; 
  27.              * 2、没有纳入session的管理; 
  28.              * 3、如果在瞬态session 调用了 save()等方法就变为了持久态; 
  29.              */    
  30.             user = new User() ;  
  31.             user.setName("小一") ;  
  32.             user.setPassword("xiaoyi") ;  
  33.             user.setCreateTime(new Date()) ;  
  34.             user.setExpireTime(new Date()) ;  
  35.             /** 
  36.              * Persistent(持久态) : 
  37.              * 1、persistent状态的对象在数据库中有与之匹配的数据; 
  38.              * 2、纳入了session的管理; 
  39.              * 3、在清理缓存(脏数据检查)的时候,会和数据库同步; 
  40.              * 4、在session关闭后,在持久态里面的内容,变为托管态,数据如果修改不会影响数据库对应值; 
  41.              */  
  42.             session.save(user);  
  43.               
  44.             user.setName("小二");  
  45.             /* 
  46.              * 注意 : 
  47.              * 在执行完tran.commit()方法后,会在控制台输出两条SQL语句,分别是 
  48.              * Hibernate: insert into t_user (name, password, createTime, expireTime, id) values (?, ?, ?, ?, ?) 
  49.              * Hibernate: update t_user set name=?, password=?, createTime=?, expireTime=? where id=? 
  50.              *  
  51.              * session.save(user); // 执行到save()方法时插入数据库一条记录。 
  52.              * user.setName("小二"); // 当对持久态对象进行修改时,会执行update操作。相当于在该条词句下面显示执行session.update(user);操作。  
  53.              */  
  54.             tran.commit() ;  
  55.               
  56.         }catch(Exception e){  
  57.             if(tran != null){  
  58.                 tran.rollback() ;  
  59.             }  
  60.             e.printStackTrace() ;  
  61.         }finally{  
  62.             HibernateUtils.closeSession(session);  
  63.         }  
  64.         /** 
  65.          * Detached(托管态) : 
  66.          * 1、在数据库中有与之匹配的数据; 
  67.          * 2、没有纳入session的管理; 
  68.          * 3、托管态对象中有主键值,瞬态的id没有主键值 
  69.          */  
  70.         user.setName("小三") ;  
  71.         try{  
  72.             session = HibernateUtils.getSession() ;  
  73.             session.beginTransaction() ;  
  74.             /* 
  75.              * 将detached对象重新纳入session管理,此时将变为persistent状态的对象。 
  76.              * persistent状态的对象,在清理缓存时会和数据库同步。 
  77.              */  
  78.             session.update(user);  
  79.             session.getTransaction().commit() ;  
  80.         }catch(Exception e){  
  81.             session.getTransaction().rollback();  
  82.             e.printStackTrace();  
  83.         }finally{  
  84.             HibernateUtils.closeSession(session);  
  85.         }  
  86.     }  
  87. }  

猜你喜欢

转载自ganxinge20090616.iteye.com/blog/1897760