Ausführliche Erläuterung von Beispielen zum Ruhezustand

Dieser Artikel führt hauptsächlich in die drei Zustände des Ruhezustands ein, darunter transient (transienter Zustand), persistent (persistenter Zustand) und getrennt (Offline-Zustand).

Jeder kann mehr erfahren Wer den Ruhezustand studiert hat, weiß möglicherweise, dass der Ruhezustand drei Zustände hat: vorübergehend (vorübergehender Zustand), dauerhaft (beständiger Zustand) und getrennt (Offline-Zustand). Möglicherweise kennen Sie auch den Unterschied zwischen diesen drei Zuständen, z. B. vorübergehend Der Zustand, den ein Objekt hat wurde gerade erstellt und wurde nicht in der Datenbank gespeichert. Der Status „Persistent“ bedeutet, dass es in der Datenbank gespeichert wurde. Der Status „Offline“ bedeutet, dass das Objekt in der Datenbank vorhanden ist, aber nicht in der Sitzung. Aber wissen Sie alles über die besonderen Methoden der Hibernate-Sitzung? Oder können Sie schnell auf einen Blick erkennen, wie viele SQL-Anweisungen ein Testfall nach wiederholtem Aufruf der Speicher- und Aktualisierungsmethoden der Sitzung ausgibt? Dieser Aufsatz wird Ihnen die Antwort geben. Dieser Aufsatz wird eine große Anzahl von Testfällen verwenden, um die Änderungen in diesen drei Zuständen des Ruhezustands zu vertuschen. verstehen.

Okay, lass uns keinen Unsinn reden. Ich glaube, jeder kennt die Bedeutung dieser drei Zustände des Winterschlafs, also beginnen wir unsere Reise in die drei Zustände des Winterschlafs mit einem Bild.

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

Zu diesem Zeitpunkt wissen wir, dass der Ruhezustand stattfinden wird Geben Sie eine Einfügeanweisung aus. Nach dem Ausführen der Speichermethode wird das Benutzerobjekt zu einem dauerhaften Objekt

Der Code lautet wie folgt:

Ruhezustand: Einfügen in t_user (born, Passwort, Benutzername ) Werte (?, ?, ?)

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

nach dem Aufruf von save Nach der Methode ist der Benutzer bereits ein persistentes Objekt und wird im Sitzungscache gespeichert. Zu diesem Zeitpunkt ändert der Benutzer den Wert des -Attributs erneut. Wenn die Transaktion übermittelt wird, wird das Objekt in den Ruhezustand versetzt Das aktuelle Benutzerobjekt wird mit dem im Sitzungscache gespeicherten Benutzerobjekt verglichen. Wenn die beiden Objekte identisch sind, wird die Aktualisierungsanweisung nicht gesendet.

Hibernate: insert into t_user (born, password, username) values (?, ?, ?)
Hibernate: update t_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();

Wie viel wird emittiert? Was ist zu diesem Zeitpunkt mit SQL-Anweisungen? Auf die gleiche Weise ist u nach dem Aufruf der Methode save nun ein persistentes Objekt. Denken Sie daran: Wenn sich ein Objekt in einem persistenten Zustand befindet, können zu diesem Zeitpunkt verschiedene Änderungen am Objekt vorgenommen oder es mehrmals aufgerufen werden. Während der Aktualisierungs- und Speichermethoden sendet Hibernate keine SQL-Anweisungen. Nur wenn Dinge übermittelt werden, vergleicht Hibernate das aktuelle Objekt mit dem zuvor in der Sitzung gespeicherten persistenten Objekt andernfalls wird die Update-Anweisung nicht gesendet

Hibernate: insert into t_user (born, password, username) values (?, ?, ?)
Hibernate: update t_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();

Ich glaube, dass jeder das Ergebnis dieses Testfalls kennen sollte. Ja, der Ruhezustand wird zu diesem Zeitpunkt auch zwei SQL-Anweisungen ausgeben. Das Prinzip ist das gleiche

Hibernate: insert into t_user (born, password, username) values (?, ?, ?)
Hibernate: update t_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();

Mal sehen, wie viele SQL-Anweisungen zu diesem Zeitpunkt ausgegeben werden? Denken Sie auch an eines: Wenn die Sitzung die Lade- und Get-Methoden aufruft und das Objekt zu diesem Zeitpunkt in der Datenbank vorhanden ist, wird das Objekt auch zu einem dauerhaften Objekt und wird von der Sitzung gehostet. Wenn Sie das Objekt zu diesem Zeitpunkt bearbeiten, wird es daher beim Senden der Transaktion auch mit dem persistenten Objekt in der Sitzung verglichen, sodass zwei SQL-Anweisungen

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=?

vorliegen hier gesendet.

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

Wenn wir uns dieses Beispiel noch einmal ansehen, ist der Benutzer persistent Zu diesem Zeitpunkt ist dieses Objekt im Sitzungscache vorhanden. Nachdem wir den Benutzer geändert haben, rufen wir dann die Methode session.clear() auf Beim Absenden der Transaktion wird zu diesem Zeitpunkt festgestellt, dass das Objekt nicht mehr in der Sitzung vorhanden ist. Daher wird hier nur eine SELECT-Anweisung gesendet >

Code kopieren Der Code lautet wie folgt:

Ruhezustand: Wählen Sie user0_.id als id0_0_, user0_.born als born0_0_, user0_.password als password0_0_, user0_ aus. Benutzername als Benutzername0_0_ von t_user user0_, wobei 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)

② Durch Aufrufen der Speichermethode für ein vorübergehendes Objekt oder der Aktualisierungsmethode für ein Offline-Objekt wird das Objekt zu einem dauerhaften Objekt. Änderungen am Objekt werden erst bei der Transaktion vorgenommen Wenn es anders ist, senden Sie eine Aktualisierungsanweisung. Andernfalls wird die Anweisung nicht gesendet.

③ Das ​​Offline-Objekt ist in der Datenbank vorhanden, wird jedoch nicht von der Datenbank gehostet Sitzung

【Verwandte Empfehlungen】

1. Besondere Empfehlung: Version V0.1 von „php Programmer Toolbox“ herunterladen "

2. Kostenloses Java-Video-Tutorial

3. YMP-Online-Handbuch

Das obige ist der detaillierte Inhalt vonAusführliche Erläuterung von Beispielen zum Ruhezustand. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!