hibernate之对象的三种状态

       在学习Hibernate的过程中，对象持久化时的三种状态以它们直接的转换是我们必须深入学习的，对它的深入理

解，才能更好的理解hibernate的运行机理。可以帮助我们更好的理解hibernate，JVM和sql的关系。

下面我们通过两张图了解一下这三种状态：

一：三个对象的学习：

   

   下面这张图我主要整理了三种对象的定义和特点，作为简单的了解。

 

 

注：Hibernate三种状态中游离对象和临时对象异同：

   1.两者都不会被Session关联，对象属性和数据库可能不一致；

   2.游离对象由持久化对象关闭Session而转化而来，在内存中还有对象所以此时就变成游离状态了；

二：三种状态转换的状态图：

注：三种状态转化的方法都是通过session来调用。

       1.瞬态到持久态的方法有save（）、saveOrUpdate（）、get（）、load（）；

       2.持久态到瞬态的方法有delete（）；

       3.游离态到持久态的方法有update（）、saveOrUpdate（）、lock（）；

       4.持久态到游离态的方法有：session.close（）、session.evict（）、session.clear（）。

 

三：结合save(),update(),saveOrUpdate() 方法说明对象的状态

     

    1.Save() 方法将瞬时对象保存到数据库，对象的临时状态将变为持久化状态。当对象在持久化状态时，它一直

位于 Session 的缓存中，对它的任何操作在事务提交时都将同步到数据库，因此，对一个已经持久的对象调用 

save() 或 update() 方法是没有意义的。

    2.update() 方法两种用途重新关联脱管对象为持久化状态对象，显示调用 update() 以更新对象。调用 

update() 只为了关联一个脱管对象到持久状态，当对象已经是持久状态时，调用 update() 就没有多大意义了。

如：如果希望只有脱管对象改变了， Hibernate 才生成 update 语句，可以把映射文件中 <class> 标签的 select-

before-update 设为true, 这种会先发送一条 select 语句取得数据库中的值，判断值是否相同，如果相同就不执

行 update 语句。不过这种做法有一定的缺点，每次 update 语句之前总是要发送一条多余的 select 语句，影响性

能。对于偶尔更改的类，设置才是有效的，对于经常要更改的类这样做是影响效率的。

    3.saveOrUpdate() 方法兼具 save() 和 update() 方法的功能，对于传入的对象， saveOrUpdate() 首先判断

其是脱管对象还是临时对象，然后调用合适的方法。

代码示例：

public classSessionTest extends TestCase{
 
   public void testSave1(){
             Session session = null;
             Transaction tx=null;
             User user=null;
             try{
                       session=HibernateUtils.getSession（）；
                       tx = session.begionTransaction（）；
                      
                       // Transient状态
                       user =new User();
                       user.setName=("张三");
                       user.setPassword("123");
                       user.setCreateTime(new Date());
                       user.setExpireTime(new Date());
                      
                       //persistent状态（持久状态）
                       //Persistent状态的对象，当对象的属性发送改变的时候
                       //hibernate在清理缓存（脏数据检查）的时候，会和数据库同步
                       session.save(user);
                      
                       user.setName("李四");
                      
                       //可以显示的调用update方法，但是在持久状态没有什么意思
                       session.update(user);
                       tx.commit();
                    }catch(Exception e){
                            e.printStackTrace();
                            if (tx!=null){
                                       tx.rollback();
                                    }
                    }finally{
                               HibernateUtils.closeSession(session);
                            }
                            //session关闭之后为Detached状态
                            user.setName=("王五");
                            try{
                                    session=HibernateUtils.getSession();
                                    session.beginTranSaction();
                                    //将detached状态的对象重新纳入Session管理
                                    //此时将变为persistent状态的对象
                                    //persistent状态的对象，在清理缓存是会和数据库同步
                                    session.update(user);
                                    session.getTransaction().commit();//清除缓存
                                    }catch(Exceptione){
                                            e.printSatackTrace();
                                            session.getTransaction().rollback();
                                    }finally{
                                            HibernateUtils.closeSession(session);
                                    }
          }
          
          public void testGet1(){
             Session session = null;
                            try{
                                    session=HibernateUtils.getSession();
                                    session.beginTranSaction();
                                    //get加载上来的对象为持久对象
                                    //执行get会马上发出查询语句
                                    //get方法加载数据，如果不存在反回null
                        User user=(User)session.get(User.calss,"序列化的ID");
                                    System.out.println(user.getName());
                                    
                                    //persistent状态（持久状态）
                       //Persistent状态的对象，当对象的属性发送改变的时候
                       //hibernate在清理缓存（脏数据检查）的时候，会和数据库同步
                                    user.setName("赵柳");
                                    session.getTransaction().commit();//清除缓存
                                    }catch(Exceptione){
                                            e.printSatackTrace();
                                            session.getTransaction().rollback();
                                    }finally{
                                            HibernateUtils.closeSession(session);
                                    }
          }
          
                  public void testLoad1(){
             Session session = null;
                            try{
                                    session=HibernateUtils.getSession();
                                    session.beginTranSaction();
                                    //不会马上发出查询语句，因为load支持延迟加载
                                    //只有真正使用这个对象的时候，在创建，对于hibernate来说，才真正发出查询语句。
                                    //主要是为了提高性能。
                                    //hibernate是如何实现延迟加载的？采用代理对象实现，代理对象主要采用的是CGLIB库生成的
                                    //而不是JDK的动态代理，因为JDK的动态代理只能对实现了接口的类生成代理，CGLIB可以对类生成代理，他采用的是继承方式
                       //load查询，如果对象不存在，hibernate会抛出ObjectNotFoundException异常的。
                        User user=(User)session.Load(User.calss,"序列化的ID");
                                    System.out.println(user.getName());
                                    
                                    //persistent状态（持久状态）
                       //Persistent状态的对象，当对象的属性发送改变的时候
                       //hibernate在清理缓存（脏数据检查）的时候，会和数据库同步
                                    user.setName("王五");
                                    session.getTransaction().commit();//清除缓存
                                    }catch(Exceptione){
                                            e.printSatackTrace();
                                            session.getTransaction().rollback();
                                    }finally{
                                            HibernateUtils.closeSession(session);
                                    }
          }
          
          public voidtestDelete1(){
             Session session = null;
                            try{
                                    session=HibernateUtils.getSession();
                                    session.beginTranSaction();
                        User user=(User)session.Load(User.calss,"序列化的ID");
                        //删除，建议采用此种方法删除：先加载在删除
                              session.delete(user);
                                    session.getTransaction().commit();//清除缓存
                                    }catch(Exceptione){
                                            e.printSatackTrace();
                                            session.getTransaction().rollback();
                                    }finally{
                                            HibernateUtils.closeSession(session);
                                    }
          }
          public voidtestDelete2(){
             Session session = null;
                            try{
                                    session=HibernateUtils.getSession();
                                    session.beginTranSaction();
                  //手动构造Detached对象
                  User user=new User();
                  user.setID="序列化ID"；
                              session.delete(user);
                                    session.getTransaction().commit();//清除缓存
                                    }catch(Exceptione){
                                            e.printSatackTrace();
                                            session.getTransaction().rollback();
                                    }finally{
                                            HibernateUtils.closeSession(session);
                                    }
          }
          
                  publicvoid testUpdate1(){
             Session session = null;
                            try{
                                    session=HibernateUtils.getSession();
                                    session.beginTranSaction();
                  //手动构造Detached对象
                  User user=new User();
                  user.setID="序列化ID"；
                  user.setName("周六");
                              session.update(user);
                                    session.getTransaction().commit();//清除缓存
                                    }catch(Exceptione){
                                            e.printSatackTrace();
                                            session.getTransaction().rollback();
                                    }finally{
                                            HibernateUtils.closeSession(session);
                                    }
          }
          //建议用这种方式
                  publicvoid testUpdate2(){
             Session session = null;
                            try{
                                    session=HibernateUtils.getSession();
                                    session.beginTranSaction();
                 User user=(User)session.load(User.class,"序列化ID");
                  user.setName("周六");
                 //因为处于persistent状态，所以可以不用update，也可以显示的update
                              session.update(user);
                                    session.getTransaction().commit();//清除缓存
                                    }catch(Exceptione){
                                            e.printSatackTrace();
                                            session.getTransaction().rollback();
                                    }finally{
                                            HibernateUtils.closeSession(session);
                                    }
          }
}

 

总结：

      

    学习了解持久化的三个对象和三种状态直接的转换，是学习Hibenrnate的基础，对我们后面深入学习Hibenrnate提

供帮助。我们会发现所有状态的转变都是以Session为轴，对Session的操作会引起状态的改变，这其中我们要重点区分

save(),update(),saveOrUpdate()三种方法的不同，以及load（）和get（）方法的区别（load支持延迟加载）。