Three states of objects in Hibernate and their mutual transformation

Objects in hibernate have three states: Transient state (Transient), Permanent state (Persistent), detached state (Detached)

1. Transient state (Transient)

When we generate an entity object through Java's new keyword, the entity object is in a free state, as follows:

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

At this time, the customer object is in a free state. Why is it said that the customer object is in a free state? This is because at this time, the customer has only obtained a piece of memory space through the JVM, and has not been saved into the database through the save() method of the Session object. Therefore, it has not yet been included in Hibernate's cache management. That is to say, the customer object is still there. Free to roam outside Hibernate cache management. So we can see that the biggest feature of a free object is that there is no record corresponding to it in the database.

Characteristics of transient objects:

(1) Not associated with Session instance

(2) There is no record associated with transient objects in the database

２． Persistent (Persistent)

The persistent object is the entity object that has been saved in the database, and this entity object is still under Hibernate's cache management. Any modifications to this entity object will be synchronized to the database when the cache is cleared. As shown below:

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

At this time, we did not explicitly call the session.update() method to save the update, but the modification to the entity object will still be updated to the database synchronously, because the customer object passes the save method at this time. After saving into the database, it is already a persistent object, and then it is loaded again through the load method. It is still a persistent object, so it is still under the management of the Hibernate cache. At this time, when the tx.commit() method is executed, Hibernate will automatically clear the cache and automatically synchronize the property changes of the persistent object to the database.

Persistent instances have corresponding records in the database and have a persistence identifier (identifier).

Persistent objects are always associated with Session and Transaction. In a Session, for Changes to persistent objects will not immediately change the database. Instead, SQL must be actually run in the database to make changes after the Transaction is terminated, that is, after commit() is executed. Only then will the state of the persistent object be synchronized with the database. Persistent objects before synchronization are called dirty objects.

Convert a transient object to a persistent object:

(1) Associate a transient object with the database through the save() and saveOrUpdate() methods of Session. This transient object The object becomes a persistent object.

(2) The data objects queried using fine(), get(), load() and iterator() methods will become persistent objects.

Characteristics of persistent objects:

(1) Associated with Session instance

(2) has in the database Records associated with persistent objects

3. Detached state (Detached)

When a persistent object leaves Hibernate's cache management, it is in a free state. The biggest difference between a free object and a free object is , the free object may still have a record corresponding to it in the database, but now the free object is out of Hibernate's cache management, and the free object will not have its corresponding data record in the database. As shown below:

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

When the session is closed, the customer object is no longer in Hibernate's cache management, but there is still a data record corresponding to the customer object in the database at this time, so at this time customer The object is in a free state

After the Session associated with the persistent object is closed, the object becomes an unmanaged object. References to detached objects remain valid and the object can continue to be modified.

Characteristics of detached objects:

(1) Essentially the same as transient objects

(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中文网（m.sbmmt.com）！