Drei Zustände von Objekten im Ruhezustand und ihre gegenseitige Transformation

Objekte im Ruhezustand haben drei Zustände: transienter Zustand (Transient), persistenter Zustand (Persistent), losgelöster Zustand (Detached). )

1. Transienter Zustand (Transient)

Wenn wir ein Entitätsobjekt über das neue Schlüsselwort von Java generieren, befindet sich das Entitätsobjekt in einem freien Zustand, wie folgt:

 Customer customer=new Customer(“zx”,27,images);

Zu diesem Zeitpunkt befindet sich das Kundenobjekt in einem freien Zustand. Warum heißt es, dass sich das Kundenobjekt in einem freien Zustand befindet? Dies liegt daran, dass der Kunde zu diesem Zeitpunkt nur einen Teil des Speicherplatzes über die JVM erhalten hat und nicht über die save()-Methode des Session-Objekts in der Datenbank gespeichert wurde. Daher wurde dieser noch nicht in Hibernate aufgenommen Cache-Verwaltung, was bedeutet, dass das Kundenobjekt außerhalb der Hibernate-Cache-Verwaltung weiterhin frei verfügbar ist. Wir können also sehen, dass das größte Merkmal eines freien Objekts darin besteht, dass es in der Datenbank keinen entsprechenden Datensatz gibt.

Eigenschaften vorübergehender Objekte:

(1) Nicht mit Sitzungsinstanz verknüpft

(2) Es gibt keinen Datensatz, der vorübergehenden Objekten in der Datenbank zugeordnet ist

２． Persistent (Persistent)

Ein persistentes Objekt ist ein Entitätsobjekt, das in der Datenbank gespeichert wurde, und dieses Entitätsobjekt steht immer noch unter der Cache-Verwaltung von Hibernate. Alle Änderungen an diesem Entitätsobjekt werden mit der Datenbank synchronisiert, wenn der Cache geleert wird. Wie unten gezeigt:

Customer customer=new Customer(“zx”,27,images);
tx=session.beginTransaction();
session.save(customer);
customer=(Customer)session.load(Customer.class,”1”);
customer.setAge(28);
tx.commit();

Zu diesem Zeitpunkt haben wir die Methode session.update() nicht explizit aufgerufen, um die Aktualisierung zu speichern, aber die Änderung am Entitätsobjekt wird weiterhin synchron in der Datenbank aktualisiert. Denn zu diesem Zeitpunkt ist das Kundenobjekt bereits ein persistentes Objekt, nachdem die Speichermethode es in der Datenbank gespeichert hat, und lädt es dann erneut über die Lademethode. Es ist immer noch ein persistentes Objekt und wird daher weiterhin verwaltet Wenn zu diesem Zeitpunkt die Methode tx.commit() ausgeführt wird, löscht Hibernate automatisch den Cache und synchronisiert die Eigenschaftsänderungen des persistenten Objekts automatisch mit der Datenbank.

Persistente Instanzen verfügen über entsprechende Datensätze in der Datenbank und eine Persistenzkennung.

Persistente Objekte sind in einer Sitzung immer mit einer Sitzung und einer Transaktion verknüpft, da sich Änderungen am persistenten Objekt nicht sofort ändern Stattdessen muss SQL tatsächlich in der Datenbank ausgeführt werden, um Änderungen vorzunehmen, nachdem die Transaktion beendet wurde, d. h. nachdem commit() ausgeführt wurde. Erst dann wird der Status des persistenten Objekts mit der Datenbank synchronisiert. Persistente Objekte vor der Synchronisierung werden als Dirty Objects bezeichnet.

Konvertieren Sie ein transientes Objekt in ein persistentes Objekt:

(1) Verknüpfen Sie ein transientes Objekt mit der Datenbank über die Methoden save() und saveOrUpdate() von Session. Dieses vorübergehende Objekt Das Objekt wird zu einem dauerhaften Objekt.

(2) Das mit den Methoden „fine()“, „get()“, „load()“ und „iterater()“ abgefragte Datenobjekt wird zu einem persistenten Objekt.

Eigenschaften persistenter Objekte:

(1) ist mit der Sitzungsinstanz

(2) in den Datenbankdatensätzen verknüpft im Zusammenhang mit persistenten Objekten

３. Getrennt

Wenn ein persistentes Objekt aus der Cache-Verwaltung von Hibernate ausbricht, befindet es sich in einem freien Zustand. Der größte Unterschied zwischen einem freien Objekt und einem freien Objekt ist das freie Objekt Möglicherweise gibt es noch einen entsprechenden Datensatz in der Datenbank, aber jetzt befindet sich dieses freie Objekt außerhalb der Cache-Verwaltung von Hibernate und das freie Objekt verfügt nicht über den entsprechenden Datensatz in der Datenbank. Wie unten gezeigt:

Customer customer=new Customer(“zx”,27,images);
tx=session.beginTransaction();
session.save(customer);
customer=(Customer)session.load(Customer.class,”1”);
customer.setAge(28);
tx.commit();
session.close();

Wenn die Sitzung geschlossen ist, befindet sich das Kundenobjekt nicht mehr in der Cache-Verwaltung von Hibernate, aber zu diesem Zeitpunkt gibt es noch einen Datensatz, der dem Kundenobjekt in der Datenbank entspricht this Wenn sich das Kundenobjekt in einem freien Zustand befindet

Nachdem die mit dem persistenten Objekt verknüpfte Sitzung geschlossen wurde, wird das Objekt zu einem getrennten Objekt. Verweise auf losgelöste Objekte bleiben gültig und das Objekt kann weiterhin geändert werden.

Merkmale losgelöster Objekte:

(1) Im Wesentlichen die gleichen wie transiente Objekte

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

持久对象转为脱管对象：

当执行 close() 或 clear(),evict() 之后，持久对象会变为脱管对象。

瞬时对象转为持久对象：

通过 Session 的 update(),saveOrUpdate() 和 lock() 等方法，把脱管对象变为持久对象。

三种状态相互转化的状态图如下：

4 ．结合 save(),update(),saveOrUpdate() 方法说明对象的状态

(1)Save() 方法将瞬时对象保存到数据库，对象的临时状态将变为持久化状态。当对象在持久化状态时，它一直位于 Session 的缓存中，对它的任何操作在事务提交时都将同步到数据库，因此，对一个已经持久的对象调用 save()或 update() 方法是没有意义的。如：

Student stu = new Strudnet();
stu.setCarId(“200234567”);
stu.setId(“100”);
// 打开 Session, 开启事务
session.save(stu);
stu.setCardId(“20076548”);
session.save(stu); // 无效
session.update(stu); // 无效
// 提交事务，关闭 Session

(2)update() 方法两种用途重新关联脱管对象为持久化状态对象，显示调用 update() 以更新对象。调用 update() 只为了关联一个脱管对象到持久状态，当对象已经是持久状态时，调用 update() 就没有多大意义了。如：

// 打开 session ，开启事务 
stu = (Student)session.get(Student.class,”123456”);
stu.setName(“Body”);
session.update(stu); // 由于 stu 是持久对象，必然位于 Session 缓冲中，
对 stu 所做的变更将 // 被同步到数据库中。所以 update() 是没有意义的，可以不要这句效果一样的。
// 提交事务，关闭 Session

Hibernate 总是执行 update 语句，不管这个脱管对象在离开 Session 之后有没有更改过，在清理缓存时 Hibernate总是发送一条 update 语句，以确保脱管对象和数据库记录的数据一致，如：

Student stu = new Strudnet();
stu.setCarId(“1234”);
// 打开 Session1, 开启事务
session1.save(stu);
// 提交事务，关闭 Session1
stu.set(“4567”); // 对脱管对象进行更改
// 打开 Session2, 开启事务
session2.update(stu);
// 提交事务，关闭 Session2

注：即使把 session2.update(stu); 这句去掉，提交事务时仍然会执行一条 update() 语句。

如果希望只有脱管对象改变了， Hibernate 才生成 update 语句，可以把映射文件中  标签的 select-before-update 设为 true, 这种会先发送一条 select 语句取得数据库中的值，判断值是否相同，如果相同就不执行 update语句。不过这种做法有一定的缺点，每次 update 语句之前总是要发送一条多余的 select 语句，影响性能。对于偶尔更改的类，设置才是有效的，对于经常要更改的类这样做是影响效率的。

(3)saveOrUpdate() 方法兼具 save() 和 update() 方法的功能，对于传入的对象， saveOrUpdate() 首先判断其是脱管对象还是临时对象，然后调用合适的方法。

 以上就是Hibernate中对象的三种状态及相互转化的内容，更多相关内容请关注PHP中文网（www.php.cn）！