• Hibernate之三态篇


    一、概况

           (一)瞬时状态(暂时态)

            在对象中假设对象刚被创建但没有被持久化的话就是瞬时态

    特点:

       (1) 不和 Session 实例关联

       (2)在数据库中没有和瞬时对象关联的记录

           (二)持久状态

       持久化对象就是已经被保存进数据库的实体对象,而且这个实体对象如今还处于Hibernate的Session缓存管理之中。这对该实体对象的不论什么改动。都会在清理缓存时同步到数据库中。

    特点:

       (1)持久的实例在数据库中有相应的记录,并拥有一个持久化标识(identifier).

       (2)和session相关联的对象

           (三)游离状态(托管状态、离线状态)

           当一个持久化对象,脱离开Hibernate的缓存管理后。它就处于游离状态,游离对象和自由对象的最大差别在于,游离对象在数据库中可能还存在一条与它相应的记录,仅仅是如今这个游离对象脱离了Hibernate的缓存管理,而自由对象不会在数据库中出现与它相应的数据记录。

    特点:

       (1) 本质上和瞬时对象同样

       (2)仅仅是比瞬时对象多了一个数据库记录标识值id

    二、转化图

             通过下面的转换图就能够明确三态之间是怎样转换的。假设将这幅图印在自己的脑子里,三态就没什么神圣的啦!

       

    三、实战

           以上是对三态理论知识上的解说,那么接下来就从实际代码中体验一下它们的奥妙吧。

    1.TestTransient  

         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: insertinto t_user (born, password, username) values (?, ?, ?)

    2.TestPersistent01

         

     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: insertinto t_user (born, password, username) values (?, ?

    , ?

    ) Hibernate: updatet_user set born=?, password=?, username=? where id=?

    3.TestPersistent02

         

     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();

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

     

    Hibernate: insertinto t_user (born, password, username) values (?

    , ?

    , ?

    ) Hibernate: updatet_user set born=?, password=?, username=? where id=?

    4.TestPersistent03

          

    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
                session =HibernateUtil.openSession();
                session.beginTransaction();
                User u = new User();
               u.setBorn(sdf.parse("1976-2-3"));
               u.setUsername("zhangsan2");
               u.setPassword("zhangsan2");
                session.save(u);
                /*
                 * 下面三条语句没有不论什么意义
                 */
                session.save(u);
                session.update(u);
                session.update(u);
               u.setUsername("zhangsan3");
                session.getTransaction().commit();

           相信这个測试用例。大家应该都知道结果了。没错。此时hibernate也会发出两条sql语句。原理一样的

     

    Hibernate: insertinto t_user (born, password, username) values (?, ?, ?

    ) Hibernate: updatet_user set born=?

    , password=?, username=? where id=?

    5.TestPersistent04

         

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

           我们来看看此时会发出多少sql语句呢?相同记住一点:当session调用load、get方法时,此时假设数据库中有该对象,则该对象也变成了一个持久化对象。被session所托管。

    因此。这个时候假设对对象进行操作。在提交事务时相同会去与session中的持久化对象进行比較,因此这里会发送两条sql语句

     

    Hibernate: selectuser0_.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: updatet_user set born=?, password=?, username=? where id=?

    6.TestPersistent05

         

     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: selectuser0_.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=?

    7.TestDetached01

          

    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: insertinto t_user (born, password, username) values (?, ?, ?)

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

     

    8.TestDetached02

         

     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("world");
                u.setUsername("world");
                //会发出一条sql
                session.update(u);
                session.getTransaction().commit();

           此时我们看到。当调用了update方法以后,此时u已经变成了一个持久化的对象,那么假设此时对u对象进行改动操作后,在事务提交的时候,则会拿该对象和session中刚保存的持久化对象进行比較,假设不同就发一条sql语句

     

    Hibernate: updatet_user set born=?, password=?, username=? where id=?

    9.TestDetached03

          

    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

    10.TestDetached04

         

     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: deletefrom t_user where id=?

    11.TestDetached05

         

     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操作。

     

    <span style="font-size:24px;">Hibernate: updatet_user set born=?, password=?, username=? where id=?</span>

    假设此时我将u.setId(4)这句话凝视掉,那么此时u就是一个瞬时的对象。那么此时就会运行save操作,就会发送一条insert语句

     

    Hibernate: insertinto t_user (born, password, username) values (?, ?, ?

    )



    12.TestDetached06

         

     session = HibernateUtil.openSession();
                session.beginTransaction();
                //u1已经是持久化状态
                User u1 =(User)session.load(User.class, 3);
               System.out.println(u1.getUsername());
                //u2是离线状态
                User u2 = new User();
                u2.setId(3);
               u2.setPassword("123456789");
                //此时u2将会变成持久化状态,在session的缓存中就存在了两份相同的对象,在session中不能存在两份拷贝。否则会抛出异常
                session.saveOrUpdate(u2);

            我们再来看一下这个样例,此时我们的u1已经是持久化的对象了。保存在session缓存中,u2通过调用saveOrUpdate方法后也变成了一个持久化的对象,此时也会保存在session缓存中,这个时候session缓存中就存在了一个持久化对象有两个引用拷贝了,这个时候hibernate就会报错

     

    <span style="font-size:24px;">org.hibernate.NonUniqueObjectException:a different object with the same identifier value was already associated withthe session: [com.xiaoluo.bean.User#3]</span>

    一个session中不能存在对一个持久化对象的双重copy的,要解决这种方法,我们这里又要介绍session的还有一个方法 merge方法,这种方法的作用就是解决一个持久化对象两分拷贝的问题,这种方法会将两个对象合并在一起成为一个对象。

          

    session = HibernateUtil.openSession();
                session.beginTransaction();
                //u1已经是持久化状态
                User u1 =(User)session.load(User.class, 3);
               System.out.println(u1.getUsername());
                //u2是离线状态
                User u2 = new User();
                u2.setId(3);
               u2.setPassword("123456789");
                //此时u2将会变成持久化状态,在session的缓存中就存在了两份相同的对象,在session中不能存在两份拷贝,否则会抛出异常
    //            session.saveOrUpdate(u2);
                //merge方法会推断session中是否已经存在同一个对象,假设存在就将两个对象合并
                session.merge(u2);
                //最佳实践:merge一般不用
                session.getTransaction().commit();

           我们看到通过调用了merge方法以后,此时会将session中的两个持久化对象合并为一个对象,可是merge方法不建议被使用

    <span style="font-size:24px;">Hibernate: selectuser0_.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=?
    zhangsan
    Hibernate: updatet_user set born=?, password=?, username=? where id=?

    </span>

    四、总结

             Hibernate三态瞬时态、持久态、游离态可谓是学习Hibernate的入门基础,仅仅有对它们之间的转换理出头绪,才干在实战中发挥其最大优势。这才是刚刚開始,期待下一出好戏吧。

  • 相关阅读:
    BZOJ 1027: [JSOI2007]合金 (计算几何+Floyd求最小环)
    BZOJ 4522: [Cqoi2016]密钥破解 (Pollard-Rho板题)
    BZOJ 4802: 欧拉函数 (Pollard-Rho)
    BZOJ 3944: Sum (杜教筛)
    BZOJ 3309: DZY Loves Math (莫比乌斯反演)
    BZOJ 2599: [IOI2011]Race(点分治板题)
    BZOJ 3680: 吊打XXX // Luogu [JSOI2004]平衡点 / 吊打XXX (模拟退火)
    Luogu P3690【模板】Link Cut Tree (LCT板题)
    [HNOI2007]最小矩形覆盖
    [SCOI2007]最大土地面积
  • 原文地址:https://www.cnblogs.com/gavanwanggw/p/6817389.html
Copyright © 2020-2023  润新知