web-dev-qa-db-fra.com

Quelle est l'utilisation de session.flush () dans Hibernate

Lorsque nous mettons à jour un enregistrement, nous pouvons utiliser session.flush() avec Hibernate. Quel est le besoin de flush()?

javahibernateorm
89
CHANTI

Le vidage de la session force Hibernate à synchroniser l’état en mémoire de Session avec la base de données (c’est-à-dire à écrire les modifications dans la base de données). Par défaut, Hibernate effacera automatiquement les modifications pour vous:

  • avant certaines exécutions de requêtes 
  • lorsqu'une transaction est validée

Le fait de vider explicitement la Session donne un contrôle plus fin qui peut être requis dans certaines circonstances (pour obtenir un ID attribué, pour contrôler la taille de la session, ...).

119
Pascal Thivent

Comme nous l'avons dit à juste titre dans les réponses ci-dessus, en appelant flush(), nous forçons hibernate à exécuter les commandes SQL sur la base de données. Mais comprenez que les changements ne sont pas encore "engagés". Ainsi, après avoir effectué le vidage et avant la validation, si vous accédez directement à la base de données (par exemple à partir de l'invite SQL) et vérifiez les lignes modifiées, vous ne verrez PAS les modifications. 

Ceci est identique à l'ouverture de 2 sessions de commande SQL. Et les modifications effectuées en 1 session ne sont visibles pour les autres que lorsqu'elles sont validées.

59
Kaushik Lele

Je sais seulement que lorsque nous appelons session.flush(), nos instructions sont exécutées dans la base de données mais ne sont pas validées.

Supposons que nous n'appelons pas la méthode flush() sur un objet de session et que si nous appelons la méthode commit, elle effectuera en interne le travail consistant à exécuter des instructions sur la base de données, puis à les valider.

commit=flush+commit (en cas de fonctionnalité)

Ainsi, je conclus que lorsque nous appelons method flush () sur un objet Session, il ne reçoit pas de validation, mais frappe la base de données, exécute la requête et est également restauré.

Afin de commettre, nous utilisons commit () sur l'objet Transaction.

21
Shoaib Chikate

Le vidage de la session obtient les données actuellement dans la session synchronisées avec ce qui se trouve dans la base de données.

Plus sur le site web d'Hibernate:

flush() est utile car il n'y a absolument aucune garantie quant au moment où la session exécute les appels JDBC, uniquement l'ordre dans lequel ils sont exécutés - à l'exception de l'utilisation de flush().

12
miku

Vous pouvez utiliser flush pour forcer les contraintes de validation à être réalisées et détectées à un emplacement connu plutôt que lorsque la transaction est validée. Il se peut que commit soit appelé implicitement par une logique de structure, par une logique déclarative, par le conteneur ou par un modèle. Dans ce cas, toute exception levée peut être difficile à détecter et à gérer (elle pourrait être trop élevée dans le code).

Par exemple, si vous save() un nouvel objet EmailAddress, qui a une contrainte unique sur l'adresse, vous n'obtiendrez une erreur que lorsque vous aurez validé.

L'appel de flush() force l'insertion de la ligne et génère une exception s'il y a un doublon.

Cependant, vous devrez restaurer la session après l'exception.

9
rghome

Je voudrais juste associer toutes les réponses données ci-dessus et aussi relier la méthode Flush () à Session.save () afin de donner plus d'importance 

Hibernate save () peut être utilisé pour enregistrer une entité dans une base de données. Nous pouvons invoquer cette méthode en dehors d’une transaction, c’est pourquoi je n’aime pas cette méthode pour sauvegarder les données. Si nous l'utilisons sans transaction et que nous avons des cascades entre entités, seule l'entité principale est enregistrée, à moins que la session ne soit vidée.

flush (): force la session à se vider. Il est utilisé pour synchroniser les données de session avec la base de données.

Lorsque vous appelez session.flush (), les instructions sont exécutées dans la base de données mais ne seront pas validées . Si vous n'appelez pas session.flush () et si vous appelez session.commit (), la méthode commit () en interne exécute la déclaration et commet.

Donc commit () = flush + commit . So session.flush () exécute simplement les instructions de la base de données (mais pas les commits) et les instructions ne sont plus dans la mémoire. Cela oblige simplement la session à se vider.

Quelques points importants:

Nous devons éviter de sauvegarder hors des limites de la transaction, sinon les entités mappées ne seront pas sauvegardées, ce qui entraînerait une incohérence dans les données. Il est très normal d'oublier de purger la session car elle ne génère aucune exception ni aucun avertissement . Par défaut, Hibernate effacera automatiquement les modifications pour vous: Avant certaines exécutions de requêtes Lorsqu'une transaction est validée .__ Permettre de vider explicitement la session donne un contrôle plus fin qui peut être nécessaire dans certaines circonstances (pour obtenir un ID attribué, pour contrôler la taille de la session)

3
Sundar Gsv

La méthode flush() force Hibernate à vider la session. Vous pouvez configurer Hibernate pour qu'il utilise le mode de vidage pour la session à l'aide de setFlushMode() method. Pour obtenir le mode de vidage de la session en cours, vous pouvez utiliser getFlushMode() method. Pour vérifier si la session est sale, vous pouvez utiliser isDirty() method. Par défaut, Hibernate gère le vidage des sessions.

Comme indiqué dans la documentation:

https://docs.jboss.org/hibernate/orm/5.2/userguide/html_single/chapters/flushing/Flushing.html

Flushing

Flushing est le processus de synchronisation de l'état de la persistance contexte avec la base de données sous-jacente. Le EntityManager et le Hibernate Session expose un ensemble de méthodes via lesquelles le fichier développeur d'application peut changer l'état persistant d'une entité.

Le contexte de persistance agit comme un cache transactionnel à écriture différée, mettre en file d'attente tout changement d'état d'une entité. Comme tout cache en écriture-derrière, change sont d'abord appliqués en mémoire et synchronisés avec la base de données pendant temps de chasse. L'opération de vidage prend chaque changement d'état d'entité et le traduit en une instruction INSERT, UPDATE ou DELETE.

La stratégie de rinçage est donnée par le flushMode du courant en cours d'exécution Hibernate Session. Bien que JPA ne définisse que deux rinçages stratégies ( AUTO et COMMIT ), Hibernate a beaucoup spectre plus large de types de chasse:

  • ALWAYS: Vide la session avant chaque requête;
  • AUTO: Ceci est le mode par défaut et ne vide la session que si nécessaire.
  • COMMIT: La session essaie de retarder le vidage jusqu'à ce que la transaction en cours soit validée, bien que le vidage soit prématuré également
  • MANUAL: le vidage de session est délégué à l'application, qui doit appeler explicitement Session.flush() pour pouvoir appliquer le le contexte de persistance change.

Par défaut, Hibernate utilise le mode de vidage AUTO qui déclenche un rincer dans les cas suivants:

  • avant de commettre une transaction;
  • avant d'exécuter une requête JPQL/HQL qui chevauche les actions d'entité en file d'attente;
  • avant d'exécuter une requête SQL native qui n'a pas de synchronisation enregistrée.
1
Aleksey Bykov

Appeler EntityManager#flush a des effets secondaires . Il est facilement utilisé pour les types d'entité avec des valeurs d'identifiant générées (valeurs de séquence): un tel identifiant n'est disponible que lors d'une synchronisation avec la couche de persistance sous-jacente. Si cet ID est requis avant la fin de la transaction en cours (à des fins de journalisation, par exemple), le vidage de la session est requis.

0
johanwannheden

Avec cette méthode, vous évoquez le processus de vidage. Ce processus se synchronise l'état de votre base de données avec l'état de votre session en détectant les changements d'état et en exécutant les instructions SQL respectives.

0
lennoxGER