최대 절전 상태의 예에 대한 자세한 설명

이 기사에서는 주로 일시적(일시적 상태), 지속성(지속적 상태) 및 분리됨(오프라인 상태)을 포함하는 최대 절전 모드의 세 가지 상태에 대한 심층적인 이해를 소개합니다.

Hibernate에 대해 공부해본 사람이라면 Hibernate가 일시적(transient state), 지속적(persistent state), 분리된(offline state) 세 가지 상태가 있다는 것을 알 수 있을 것이다. 객체가 방금 생성되었으며 데이터베이스에 저장되지 않았습니다. 영구 상태는 객체가 데이터베이스에 저장되었지만 세션에는 존재하지 않음을 의미합니다. 그런데 Hibernate 세션의 특별한 방법에 대해 모두 알고 계시나요? 아니면 세션의 저장 및 업데이트 메소드를 반복적으로 호출한 후 테스트 케이스가 실행하는 SQL 문 수를 한 눈에 빠르게 확인할 수 있습니까? 이 에세이는 여러분에게 답을 줄 것입니다. 이 에세이는 최대 절전 모드의 세 가지 상태에 대한 변경 사항을 다루기 위해 많은 테스트 사례를 사용할 것입니다. 이 에세이를 읽고 나면 최대 절전 모드의 세 가지 상태에 대해 더 깊이 이해하게 될 것입니다. 이해하다.

자, 헛소리는 하지 말자. 이 세 가지 동면 상태의 의미는 모두가 알고 있을 테니, 세 가지 동면 상태에 대한 여행을 사진을 통해 시작해 보자.

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: t_user(본인, 비밀번호, 사용자 이름) 값에 삽입 ​​(?, ?, ?)

2.TestPertant01

　　　 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 메소드를 호출한 후, 이때 사용자는 이미 영속 객체이며 세션 캐시에 저장되어 있습니다. 이때 사용자는 속성 값을 다시 수정합니다. 그런 다음 트랜잭션이 제출되면 최대 절전 모드 객체가 사용됩니다. 현재 사용자 개체를 세션 캐시에 저장된 사용자 개체와 비교합니다. 두 개체가 동일하면 업데이트 문이 전송되지 않고 두 개체가 다르면 업데이트 문이 실행됩니다.

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

3.TestPercious02

　　　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는 이미 영속 객체입니다. 기억하세요: 객체가 영속 상태에 있으면 이 시점에서 객체에 다양한 수정이 가해지거나 여러 번 호출될 수 있습니다. 업데이트 및 저장 방법 중에 최대 절전 모드는 SQL 문을 보내지 않으며, 항목이 제출된 경우에만 최대 절전 모드는 세션에 이전에 저장된 영구 개체와 비교하여 업데이트를 보냅니다. 그렇지 않으면 업데이트 문이 전송되지 않습니다.

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

4.TestPertant03

　　　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: insert into t_user (born, password, username) values (?, ?, ?)
Hibernate: update t_user set born=?, password=?, username=? where id=?

5.TestPertant04

　　　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문이 발행되는지 볼까요? 또한 한 가지를 기억하십시오. 세션이 load 및 get 메소드를 호출할 때 객체가 데이터베이스에 존재하는 경우 해당 객체도 영구 객체가 되어 세션에 의해 호스팅됩니다. 따라서 이때 해당 객체에 대해 작업을 수행하면 트랜잭션 제출 시 세션 내 영속 객체와도 비교하게 되므로 두 개의 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=?

<🎜는 sent here >

6.TestPertant05

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

이 예제를 다시 보면 사용자 개체를 로드할 때 현재 사용자는 영구 개체입니다. 세션 내 이 객체는 캐시에 존재합니다. 이때 사용자를 수정한 후 session.clear() 메서드를 호출하면 해당 세션의 캐시 객체가 지워집니다. 이때 submit 트랜잭션 중 해당 객체가 세션에 더 이상 존재하지 않는 것으로 확인되어 아무런 작업도 수행하지 않으므로 여기에는 select 문만 전송됩니다

코드 복사 코드는 다음과 같습니다:

최대 절전 모드: user0_.id를 id0_0_로, user0_.born을 Born0_0_로, user0_.password를 비밀번호0_0_로, user0_.username을 username0_0_로 선택합니다. t_user user0_ 여기서 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: insert into 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: update t_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: delete from 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操作。

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 (?, ?, ?)

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就会报错

复制代码 代码如下:

org.hibernate.NonUniqueObjectException: a different object with the same identifier value was already associated with the session: [com.xiaoluo.bean.User#3]

一个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方法不建议被使用

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=?
zhangsan
Hibernate: update t_user set born=?, password=?, username=? where id=?

终于写完了本篇随笔，本篇随笔可能概念性的内容比较少，基本都是通过测试用例来分析hibernate的三种状态可能会出现的各种情况。

最后总结一下：

①.对于刚创建的一个对象，如果session中和数据库中都不存在该对象，那么该对象就是瞬时对象(Transient)

②. 임시 개체에 대해 save 메서드를 호출하거나 오프라인 개체에 대해 업데이트 메서드를 호출하면 해당 개체가 영구 개체가 될 수 있습니다. 개체에 대한 수정은 트랜잭션이 수행될 때만 이루어집니다. 비교하여 다르면 업데이트 명령문을 보내십시오. 그렇지 않으면 명령문이 전송되지 않습니다

3. 오프라인 객체는 객체가 데이터베이스에 존재하지만 객체가 호스트되지 않는다는 것입니다. 세션

【관련 추천】

1. 특별 추천: "php Programmer Toolbox" V0.1 버전 다운로드

2. Java 무료 동영상 튜토리얼

3. YMP 온라인 매뉴얼

위 내용은 최대 절전 상태의 예에 대한 자세한 설명의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!