zoukankan      html  css  js  c++  java
  • hibernate的三种状态

    转载:https://www.cnblogs.com/xiaoluo501395377/p/3380270.html

    瞬时状态:  刚new出来一个对象,对象在session和数据库中都不存在的状态

    持久化状态:    对象在session和数据库中都存在的状态

    游离状态:        对象在session中不存在,但在数据库中存在的状态

    1.游离态转变为持久态

          session = HibernateUtil.openSession();
             session.beginTransaction();
             User user = new User();
             user.setUsername("aaa");
             user.setPassword("aaa");
             user.setBorn(new Date());
             /*
              *  以上user就是一个Transient(瞬时状态),此时user并没有被session进行托管,即在session的
              *  缓存中还不存在user这个对象,当执行完save方法后,此时user被session托管,并且数据库中存在了该对象
              *  user就变成了一个Persistent(持久化对象)
              */
             session.save(user);
             session.getTransaction().commit();

      此时我们知道hibernate会发出一条insert的语句,执行完save方法后,该user对象就变成了持久化的对象了

    Hibernate: insert into t_user (born, password, username) values (?, ?, ?)

    2.修改持久态属性,提交事务后发出对应SQL

           session = HibernateUtil.openSession();
                session.beginTransaction();
                User user = new User();
                user.setUsername("aaa");
                user.setPassword("aaa");
                user.setBorn(new Date());
                //以上u就是Transient(瞬时状态),表示没有被session管理并且数据库中没有
                //执行save之后,被session所管理,而且,数据库中已经存在,此时就是Persistent状态
                session.save(user);
                //此时u是持久化状态,已经被session所管理,当在提交时,会把session中的对象和目前的对象进行比较
                //如果两个对象中的值不一致就会继续发出相应的sql语句
                user.setPassword("bbb");
                //此时会发出2条sql,一条用户做插入,一条用来做更新
                session.getTransaction().commit();

      在调用了save方法后,此时user已经是持久化对象了,被保存在了session缓存当中,这时user又重新修改了属性值,那么在提交事务时,此时hibernate对象就会拿当前这个user对象和保存在session缓存中的user对象进行比较,如果两个对象相同,则不会发送update语句,否则,如果两个对象不同,则会发出update语句。

    Hibernate: insert into t_user (born, password, username) values (?, ?, ?)
    Hibernate: update t_user set born=?, password=?, username=? where id=?

    3.在事务中持久态被修改多次,且调用save,update方法

           SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
                session = HibernateUtil.openSession();
                session.beginTransaction();
                User u = new User();
                u.setBorn(new Date());
                u.setUsername("zhangsan");
                u.setPassword("zhangsan");
                session.save(u);
                u.setPassword("222");
                //该条语句没有意义
                session.save(u);
                u.setPassword("zhangsan111");
                //没有意义
                session.update(u);
                u.setBorn(sdf.parse("1988-12-22"));
                //没有意义
                session.update(u);
                session.getTransaction().commit();

      在调用save方法后,u此时已经是持久化对象了,记住一点:如果一个对象以及是持久化状态了,那么此时对该对象进行各种修改,或者调用多次update、save方法时,hibernate都不会发送sql语句,只有当事物提交的时候,此时hibernate才会拿当前这个对象与之前保存在session中的持久化对象进行比较,如果不相同就发送一条update的sql语句,否则就不会发送update语句

    Hibernate: insert into t_user (born, password, username) values (?, ?, ?)
    Hibernate: update t_user set born=?, password=?, username=? where id=?

    4.当数据库已有对象被取出,该取出对象为持久态

           session = HibernateUtil.openSession();
                session.beginTransaction();
                //此时u是Persistent
                User u = (User)session.load(User.class, 4);
                //由于u这个对象和session中的对象不一致,所以会发出sql完成更新
                u.setUsername("bbb");
                session.getTransaction().commit();

      记住一点:当session调用load、get方法时,此时如果数据库中有该对象,则该对象也变成了一个持久化对象,被session所托管。因此,这个时候如果对对象进行操作,在提交事务时同样会去与session中的持久化对象进行比较,因此这里会发送两条sql语句

    Hibernate: select user0_.id as id0_0_, user0_.born as born0_0_, user0_.password as password0_0_, user0_.username as username0_0_ from t_user user0_ where user0_.id=?
    Hibernate: update t_user set born=?, password=?, username=? where id=?

    5.调用clear方法清空session缓存对象

           session = HibernateUtil.openSession();
                session.beginTransaction();
                //此时u是Persistent
                User u = (User)session.load(User.class, 4);
                u.setUsername("123");
                //清空session
                session.clear();
                session.getTransaction().commit();

      当我们load出user对象时,此时user是持久化的对象,在session缓存中存在该对象,此时我们在对user进行修改后,然后调用session.clear()方法,这个时候就会将session的缓存对象清空,那么session中就没有了user这个对象,这个时候在提交事务的时候,发现已经session中已经没有该对象了,所以就不会进行任何操作,因此这里只会发送一条select语句

    Hibernate: select user0_.id as id0_0_, user0_.born as born0_0_, user0_.password as password0_0_, user0_.username as username0_0_ from t_user user0_ where user0_.id=?

    6.游离态的变为持久态,应使用update方法

           session = HibernateUtil.openSession();
                session.beginTransaction();
                //此时u是一个离线对象,没有被session托管
                User u = new User();
                u.setId(4);
                u.setPassword("hahahaha");
                //当执行save的时候总是会添加一条数据,此时id就会根据Hibernate所定义的规则来生成
                session.save(u);
                session.getTransaction().commit();

      当调用了u.setId(4)时,此时u是一个离线的对象,因为数据库中存在id=4的这个对象,但是该对象又没有被session所托管,所以这个对象就是离线的对象,要使离线对象变成一个持久化的对象,应该调用什么方法呢?我们知道调用save方法,可以将一个对象变成一个持久化对象,但是,当save一执行的时候,此时hibernate会根据id的生成策略往数据库中再插入一条数据,所以如果调用save方法,此时数据库会发送一条插入的语句:

    Hibernate: insert into t_user (born, password, username) values (?, ?, ?)

      所以对于离线对象,如果要使其变成持久化对象的话,我们不能使用save方法,而应该使用update方法

    7.不能修改持久态主键,修改后会报异常

           SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
                session = HibernateUtil.openSession();
                session.beginTransaction();
                User u = new User();
                u.setId(5);
                //完成update之后也会变成持久化状态
                session.update(u);
                u.setBorn(sdf.parse("1998-12-22"));
                u.setPassword("lisi");
                u.setUsername("lisi");
                //会抛出异常
                u.setId(333);
                session.getTransaction().commit();

      调用update方法后,user变成了一个持久化对象,在对user进行一些修改后,此时又通过 u.setId(333)方法设置了u的ID,那么这个时候,hibernate会报错,因为我们的u当前已经是一个持久化对象,如果试图修改一个持久化对象的ID的值的话,就会抛出异常.

    org.hibernate.HibernateException: identifier of an instance of com.xiaoluo.bean.User was altered from 5 to 333

    8.用delete方法将持久态,游离态转变为临时态

           session = HibernateUtil.openSession();
                session.beginTransaction();
                User u = new User();
                u.setId(5);
                //现在u就是transient对象
                session.delete(u);
                //此时u已经是瞬时对象,不会被session和数据库所管理
                u.setPassword("wangwu");
                session.getTransaction().commit();

      这里在调用了session.delete()方法以后,此时后u就会变成一个瞬时对象,因为此时数据库中已经不存在该对象了,既然u已经是一个瞬时对象了,那么对u再进行各种修改操作的话,hibernate也不会发送任何的修改语句,因此这里只会 有一条 delete的语句发生:

    Hibernate: delete from t_user where id=?

    9.saveOrUpdate方法将游离态或临时态转变为持久态

           session = HibernateUtil.openSession();
                session.beginTransaction();
                User u = new User();
                u.setId(4);
                u.setPassword("zhaoliu");
                //如果u是离线状态就执行update操作,如果是瞬时状态就执行Save操作
                //但是注意:编程中不建议使用这种模棱两可的方法
                session.saveOrUpdate(u);
                session.getTransaction().commit();

      saveOrUpdate这个方法其实是一个"偷懒"的方法,如果对象是一个离线对象,那么在执行这个方法后,其实是调用了update方法,如果对象是一个瞬时对象,则会调用save方法,记住:如果对象设置了ID值,例如u.setId(4),那么该对象会被假设当作一个离线对象,此时就会执行update操作

    Hibernate: update t_user set born=?, password=?, username=? where id=?

      如果此时我将u.setId(4)这句话注释掉,那么此时u就是一个瞬时的对象,那么此时就会执行save操作,就会发送一条insert语句

    Hibernate: insert into t_user (born, password, username) values (?, ?, ?)
  • 相关阅读:
    X509Certificate2 Class
    Difference Between Octet and Byte
    雅虎被裁员工写博客表达悲凉心境:晕眩数分钟
    Ruby on rails开发从头来(windows)(三十四) Active Support
    你不得不看的超牛面试(新版)
    Mongrel创建者炮轰Rails社区,并宣称和Rails社区决裂
    Ruby on rails开发从头来(windows)(三十一) Rails的目录结构
    Ruby on rails开发从头来(windows)(三十二) Rails的配置文件
    Ruby on rails开发从头来(windows)(三十) NetBeans IDE
    新闻+旧闻:Ruby 1.9,Ruby on Rails 2.0 ,NetBeans 6.0正式版
  • 原文地址:https://www.cnblogs.com/xiaoshouxing/p/9292251.html
Copyright © 2011-2022 走看看