(3)hibernate的三种状态

刺骨的言语ヽ痛彻心扉 2022-05-09 09:24 320阅读 0赞

瞬时状态(transient):刚new出来的对象就属于瞬时状态

持久化状态(persistent):对象存进数据库，被session所管理就是持久化状态

离线状态(detached):数据库有，但是没有被session管理就是离线状态

1.test01:

  1. void test01() {
  2.         Session session=null;
  3.         try {
  4.             session=HibernateUtil.getSession();
  5.             session.beginTransaction();
  6.             User u=new User();
  7.             u.setNickname("李四");
  8.             u.setBorn(new Date());
  9.             u.setPassword("123");
  10.             u.setUsername("ls");
  11.             session.save(u);
  12.             u.setUsername("ls-test");
  13.             session.getTransaction().commit();//
  14.         } catch (Exception e) {
  15.             // TODO 自动生成的 catch 块
  16.             e.printStackTrace();
  17.             session.getTransaction().rollback();
  18.         }finally {
  19.             HibernateUtil.closeSession(session);
  20.         }
  21.     }

注意:（1）.当执行save后,u就是持久化状态了，同时存在session的缓存中，当执行commit时，会把当前对象与缓存对象进行比较，如果不同则自动update

2.test02:

  1. void test02() {
  2.         Session session=null;
  3.         try {
  4.             SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");
  5.             session=HibernateUtil.getSession();
  6.             session.beginTransaction();
  7.             User u=new User();
  8.             u.setNickname("李四");
  9.             u.setBorn(new Date());
  10.             u.setPassword("123");
  11.             u.setUsername("ls");
  12.             session.save(u);
  13.             u.setUsername("ls-test");
  14.             session.save(u);//该语句没有意义
  15.             u.setPassword("1234");
  16.             session.update(u);//该语句没有意义
  17.             u.setBorn(sdf.parse("1977-01-14"));
  18.             session.update(u);//该语句没有意义
  19.             session.getTransaction().commit();
  20.         } catch (Exception e) {
  21.             // TODO 自动生成的 catch 块
  22.             e.printStackTrace();
  23.             session.getTransaction().rollback();
  24.         }finally {
  25.             HibernateUtil.closeSession(session);
  26.         }
  27.     }

注意:（1）.当对象是持久化状态时，进行save或update都无效，都不会发sql语句，只有当commit时，才会把session中缓存的对象与当前对象比较，不同则更新

3.test03:

  1. void test03() {
  2.         Session session=null;
  3.         try {
  4.             session=HibernateUtil.getSession();
  5.             session.beginTransaction();
  6.             User u=(User)session.load(User.class, 7);
  7.             u.setPassword("12345");
  8.             session.getTransaction().commit();
  9.         } catch (Exception e) {
  10.             // TODO 自动生成的 catch 块
  11.             e.printStackTrace();
  12.             session.getTransaction().rollback();
  13.         }finally {
  14.             HibernateUtil.closeSession(session);
  15.         }
  16.     }

注意:（1）.当执行load时，如果数据库有该对象，则该对象变为持久化状态（因为执行load后，对象就被session所管理）

4.test04:

  1. void test04() {
  2.         Session session=null;
  3.         try {
  4.             session=HibernateUtil.getSession();
  5.             session.beginTransaction();
  6.             User u=(User)session.load(User.class, 7);
  7.             u.setPassword("12345");
  8.             session.clear();
  9.             session.getTransaction().commit();
  10.         } catch (Exception e) {
  11.             // TODO 自动生成的 catch 块
  12.             e.printStackTrace();
  13.             session.getTransaction().rollback();
  14.         }finally {
  15.             HibernateUtil.closeSession(session);
  16.         }
  17.     }

注意:（1）.当使用clear后，session中缓存的对象就没了，此时commit就不会自动更新对象了，所以该代码只发一条select的sql语句

5.test05:

  1. void test05() {
  2.         SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");
  3.         Session session=null;
  4.         try {
  5.             session=HibernateUtil.getSession();
  6.             session.beginTransaction();
  8.             User u=new User();
  9.             u.setId(7);//数据库有id为7的对象,但是没有被session管理,所以是该对象属于离线状态
  10.             //怎么把该对象变为持久化状态呢,我们可以用save或者update，但是用save的话，数据库会多一条id不同对象相同的数据，所以用update比较合适
  11.             session.update(u);
  12.             u.setNickname("test-nick"); //补全对象属性
  13.             u.setBorn(sdf.parse("1980-05-05")); //补全对象属性
  14.             u.setPassword("123456"); //补全对象属性
  15.             u.setUsername("TEST"); //补全对象属性
  16.             session.getTransaction().commit();
  17.         } catch (Exception e) {
  18.             // TODO 自动生成的 catch 块
  19.             e.printStackTrace();
  20.             session.getTransaction().rollback();
  21.         }finally {
  22.             HibernateUtil.closeSession(session);
  23.         }
  24.     }

注意:（1）.当数据库用，但是没有被session管理（离线状态）,可以使用update使它成为持久化状态，此时缓存的对象就只有id，如果不把其他属性进行set，则数据不全

6.test06:

  1. void test06() {
  2.         SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");
  3.         Session session=null;
  4.         try {
  5.             session=HibernateUtil.getSession();
  6.             session.beginTransaction();
  8.             User u=new User();
  9.             u.setId(7);//数据库有id为7的对象,但是没有被session管理,所以是该对象属于离线状态
  10.             //怎么把该对象变为持久化状态呢,我们可以用save或者update，都是用save的话，数据库会多一条id不同对象相同的数据，所以用update比较合适
  11.             session.update(u);
  12.             u.setNickname("test-nick"); 
  13.             u.setBorn(sdf.parse("1980-05-05"));
  14.             u.setPassword("123456");
  15.             u.setUsername("TEST");
  16.             u.setId(88);
  17.             session.getTransaction().commit();
  18.         } catch (Exception e) {
  19.             // TODO 自动生成的 catch 块
  20.             e.printStackTrace();
  21.             session.getTransaction().rollback();
  22.         }finally {
  23.             HibernateUtil.closeSession(session);
  24.         }
  25.     }

注意:（1）.当使用update使对象成为持久化状态时，不能再修改id，否则会报错

7.test07:

  1. void test07() {
  2.         Session session=null;
  3.         try {
  4.             session=HibernateUtil.getSession();
  5.             session.beginTransaction();
  7.             User u=new User();
  8.             u.setId(7);
  9.             session.delete(u);//此时u没有被数据库管理,就是瞬时状态，此时进行set无效，所以只有一条删除的sql语句
  10.             u.setNickname("TEST");
  11.             session.getTransaction().commit();
  12.         } catch (Exception e) {
  13.             // TODO 自动生成的 catch 块
  14.             e.printStackTrace();
  15.             session.getTransaction().rollback();
  16.         }finally {
  17.             HibernateUtil.closeSession(session);
  18.         }
  19.     }

8.test08:

  1. @Test
  2.     void test08() {
  3.         SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");
  4.         Session session=null;
  5.         try {
  6.             session=HibernateUtil.getSession();
  7.             session.beginTransaction();
  9.             User u=new User();
  11.             u.setNickname("test-nick"); 
  12.             u.setBorn(sdf.parse("1980-05-05"));
  13.             u.setPassword("123456");
  14.             u.setUsername("TEST");
  15.             session.saveOrUpdate(u);/*如果对象有设置id,则该对象会假设为离线状态，就会使用update进行持久化，
  16.             如果对象没有设置id,则该对象会假设为瞬时状态，就会使用save进行持久化
  17.             */
  18.             session.getTransaction().commit();
  19.         } catch (Exception e) {
  20.             // TODO 自动生成的 catch 块
  21.             e.printStackTrace();
  22.             session.getTransaction().rollback();
  23.         }finally {
  24.             HibernateUtil.closeSession(session);
  25.         }
  26.     }

9.test09:

  1. void test09() {
  2.         SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");
  3.         Session session=null;
  4.         try {
  5.             session=HibernateUtil.getSession();
  6.             session.beginTransaction();
  8.         User u1=session.load(User.class, 3);
  9.         System.out.println(u1.toString());//u1已经是持久化状态了
  10.         User u2=new User();
  11.         u2.setBorn(sdf.parse("1888-04-04"));
  12.         u2.setId(3);//u2是离线状态
  14.         session.saveOrUpdate(u2);//u2是持久化状态了
  15.             session.getTransaction().commit();
  16.         } catch (Exception e) {
  17.             // TODO 自动生成的 catch 块
  18.             e.printStackTrace();
  19.             session.getTransaction().rollback();
  20.         }finally {
  21.             HibernateUtil.closeSession(session);
  22.         }
  23.     }

注意:（1）.u1的id为3，u2的id也是3，session中不能存在对一个持久化对象的双重copy，否则会报错

10.test10:

  1. @Test
  2.     void test07() {
  3.         Session session=null;
  4.         try {
  5.             session=HibernateUtil.getSession();
  6.             session.beginTransaction();
  8.         User u1=session.load(User.class, 3);
  10.         User u2=new User();
  11.         u2.setBorn(sdf.parse("1888-04-04"));
  12.         u2.setId(3);
  14.         session.merge(u2);//merge之前会判断session中是否有同一对象,如果存在将两个对象合并
  15.             session.getTransaction().commit();
  16.         } catch (Exception e) {
  17.             // TODO 自动生成的 catch 块
  18.             e.printStackTrace();
  19.             session.getTransaction().rollback();
  20.         }finally {
  21.             HibernateUtil.closeSession(session);
  22.         }
  23.     }

发表评论

表情：
评论列表 （有 0 条评论，320人围观）

还没有评论，来说两句吧...

相关阅读

    相关 Hibernate的实例的三种状态

            结合课上老师讲的以及查资料看书，把相关知识进行了整理。今天开始用笔记把一些知识点和敲的代码段记下来了，果然还是记一下效果好。推荐有道或是为知等笔记软件，很好用。

    亦凉亦凉/ 0 赞/ 208 阅读