Trois états d'objets en veille prolongée et leur transformation mutuelle

Les objets en veille prolongée ont trois états : état transitoire (Transient), état persistant (Persistant), état détaché (Détaché )

1. État transitoire (Transient)

Lorsque nous générons un objet entité via le nouveau mot-clé de Java, l'objet entité est dans un état libre, comme suit :

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

A ce moment, l'objet client est dans un état libre. Pourquoi dit-on que l'objet client est dans un état libre ? En effet, à l'heure actuelle, le client n'a obtenu qu'un morceau d'espace mémoire via la JVM et n'a pas été enregistré dans la base de données via la méthode save() de l'objet Session. Par conséquent, il n'a pas encore été inclus dans Hibernate. gestion du cache, ce qui signifie que l'objet client est toujours là. Libre de se déplacer en dehors de la gestion du cache Hibernate. On voit donc que la plus grande caractéristique d’un objet libre est qu’il n’existe aucun enregistrement lui correspondant dans la base de données.

Caractéristiques des objets transitoires :

(1) Non associé à l'instance de session

(2) Il n'y a aucun enregistrement associé aux objets transitoires dans la base de données

２． Persistant (Persistant)

Un objet persistant est un objet entité qui a été enregistré dans la base de données, et cet objet entité est toujours sous la gestion du cache d'Hibernate. Toute modification apportée à cet objet entité sera synchronisée avec la base de données lorsque le cache sera vidé. Comme indiqué ci-dessous :

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

Pour le moment, nous n'avons pas explicitement appelé la méthode session.update() pour enregistrer la mise à jour, mais la modification de l'objet entité sera toujours mise à jour dans la base de données de manière synchrone, car à ce moment-là, l'objet client passe. Après que la méthode save l'a enregistré dans la base de données, c'est déjà un objet persistant, puis il le charge à nouveau via la méthode de chargement. C'est toujours un objet persistant, il est donc toujours sous la gestion de. le cache Hibernate. À ce moment-là, lorsque la méthode tx.commit() est exécutée, Hibernate videra automatiquement le cache et synchronisera automatiquement les modifications de propriétés de l'objet persistant avec la base de données.

Les instances persistantes ont des enregistrements correspondants dans la base de données et ont un identifiant de persistance

Les objets persistants sont toujours associés à une session et à une transaction, car les modifications apportées à l'objet persistant ne changeront pas immédiatement. Au lieu de cela, SQL doit être réellement exécuté dans la base de données pour apporter des modifications après la fin de la transaction, c'est-à-dire après l'exécution de commit(). Ce n'est qu'alors que l'état de l'objet persistant sera synchronisé avec la base de données. Les objets persistants avant la synchronisation sont appelés objets modifiés.

Convertir un objet transitoire en objet persistant :

(1) Associer un objet transitoire à la base de données via les méthodes save() et saveOrUpdate() de Session. Cet objet transitoire L'objet devient un objet persistant.

(2) L'objet de données interrogé à l'aide des méthodes fine(), get(), load() et iterator() deviendra un objet persistant.

Caractéristiques des objets persistants :

(1) est associé à l'instance de Session

(2) dans la base de données Records associé aux objets persistants

3. Détaché

Lorsqu'un objet persistant se détache de la gestion du cache d'Hibernate, il est dans un état libre. La plus grande différence entre un objet libre et un objet libre est l'objet libre. peut toujours avoir un enregistrement correspondant dans la base de données, mais maintenant l'objet libre est hors de la gestion du cache d'Hibernate, et l'objet libre n'aura pas son enregistrement de données correspondant dans la base de données. Comme indiqué ci-dessous :

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

Lorsque la session est fermée, l'objet client n'est plus dans la gestion du cache d'Hibernate, mais à ce moment il y a toujours un enregistrement de données correspondant à l'objet client dans la base de données, donc this Lorsque l'objet client est dans un état libre

Une fois la Session associée à l'objet persistant fermée, l'objet devient un objet détaché. Les références aux objets détachés restent valides et l'objet peut continuer à être modifié.

Caractéristiques des objets détachés :

(1) Essentiellement les mêmes que les objets transitoires

(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）！