Actuellement, dans notre projet, nous avons créé 2 classes d'entités. Cependant, ce n'est pas suffisant pour interagir pleinement avec la base de données. Ce chapitre explorera les interfaces principales de Hibernate qui nous permettront d'interagir efficacement avec les classes d'entités et la base de données.

SessionFactory

Chaque processus dans Hibernate a son cycle de vie. Le cycle de vie d'un objet Session est l'un des aspects les plus importants et critiques.

D'après la définition, on peut comprendre que l'interaction avec la base de données se produit dans le cadre d'une seule session. Voici une explication simplifiée :

Pour commencer à interagir avec la base de données, nous devons prendre rendez-vous (ouvrir une session) avec un thérapeute nommé Hibernate (le framework). Mais avant de programmer la session, le thérapeute doit être diplômé de l'école de médecine.

En code, l'analogie est l'objet SessionFactory, qui, comme son nom l'indique, sert de fabrique pour créer des sessions.

Regardons la définition :

C'est assez simple : l'interface SessionFactory est utilisée pour créer et stocker des instances de l'interface Session.

Voici comment l'objet SessionFactory est créé dans le code en utilisant nos deux classes d'entité comme exemple :

Dans la méthode configure(), nous spécifions le fichier qui contient la configuration Hibernate. En utilisant la méthode addAnnotatedClass(), nous indiquons quelles classes sont des entités. Enfin, avec la méthode buildSessionFactory(), nous obtenons l'objet SessionFactory.

Vous pourriez demander : "Mais que se passe-t-il si nous avons 100 classes d'entités ? Devons-nous spécifier chacune d'elles dans la méthode addAnnotatedClass() ?"

Réponse : Oui et non. Nous pouvons déplacer cette partie du code vers la classe de configuration en spécifiant toutes les classes d'entités dans le corps de <session-factory>.

Voici à quoi cela ressemblera :

Maintenant, nous pouvons nous débarrasser des méthodes inutiles lors de la création de l'objet SessionFactory :

Maintenant, à partir de l'objet SessionFactory créé, nous pouvons ouvrir une session dans laquelle nous effectuerons les opérations nécessaires :

Transaction

Toutes les opérations de données doivent être effectuées dans le contexte d'une transaction. Une transaction dans Hibernate garantit la cohérence et l'intégrité des données. Le développeur est responsable de l'initiation et de la finalisation des transactions.

Regardons la définition :

Remarque

Une transaction est une unité logique de travail qui inclut une ou plusieurs opérations sur la base de données. Une opération est une action spécifique effectuée sur les données dans la base de données : créer, lire, mettre à jour, supprimer, etc.

La gestion des Transaction doit être effectuée dans un bloc try-catch-finally car les opérations de transaction peuvent lancer des exceptions qui peuvent affecter négativement les données dans la table. Par conséquent, nous devons nous protéger et, en cas d'erreur, annuler les modifications apportées à la table.

Voici les principales méthodes pour travailler avec les transactions :

• begin() démarre une nouvelle transaction. Toutes les opérations suivantes se dérouleront dans cette transaction ;
• commit() valide la transaction, enregistrant toutes les modifications effectuées pendant la transaction. Après la validation, les modifications sont reflétées dans la base de données ;
• rollback() annule toutes les modifications effectuées pendant la transaction si une erreur se produit.

Alors résumons et comprenons l'algorithme :

• En utilisant l'objet SessionFactory, nous créons une instance de l'interface Session ;
• Ensuite, au sein de la session, nous créons un objet Transaction, dans lequel nous effectuerons des opérations sur la base de données ;
• Ces opérations ne seront pas reflétées dans la base de données tant que la méthode commit() n'est pas utilisée. En cas d'erreur, nous devons annuler toutes les modifications en utilisant la méthode rollback() ;
• Les opérations de transaction sont effectuées dans un bloc try-catch-finally.

Regardons une telle implémentation dans le code :

Voici le modèle qui sera utilisé pratiquement pour chaque opération de base de données.

Création de SessionFactory -> Création de Session -> Ouverture de Transaction -> opérations de base de données -> la méthode commit(), qui confirme les modifications -> fermeture de SessionFactory.

Maintenant, examinons les méthodes de travail avec la base de données.

Manipulation des Données

Considérons les principales méthodes de l'interface Session pour la manipulation des données dans Hibernate.

Remarque

Actuellement, nous examinerons les méthodes fournies par Hibernate. Plus tard, nous utiliserons ces méthodes comme base pour écrire nos propres méthodes pour effectuer des opérations CRUD. De plus, nous développerons des méthodes plus pratiques et spécialisées (comme getEmployeesByName() et ainsi de suite). C'est là que le développement logique le plus intéressant de l'application commence, ce que j'aime personnellement à propos de Java.

Commençons par les méthodes de sauvegarde et de mise à jour :

• persist(Object entity): Enregistre l'objet dans la base de données. Cette méthode doit être utilisée lorsque vous souhaitez enregistrer une nouvelle instance d'un objet ;
• merge(Object entity): Met à jour un objet existant dans la base de données ou l'enregistre s'il n'existe pas. Retourne l'objet, qui peut avoir été modifié à la suite de la fusion.

En code, cela ressemblera à ceci :

Dans le code ci-dessus, nous avons créé un nouvel objet de la classe d'entité Department et l'avons enregistré dans la base de données. Maintenant, nous sommes intéressés à vérifier si cet objet a été enregistré.

Pour ce faire, nous utilisons des méthodes pour lire les données de la table :

• get(Class<T> entityClass, Object id): Récupère un objet par son identifiant. Retourne null si l'objet n'est pas trouvé ;
• refresh(Object entity): Met à jour l'état de l'objet avec les données de la base de données, écrasant toutes les modifications apportées à l'objet.

Remarque

Dans Hibernate, il n'y a pas de méthode de base pour récupérer tous les éléments ou un élément spécifique. Avec Hibernate, nous ne pouvons récupérer des éléments que par leur ID. Plus tard, nous écrirons des méthodes pour récupérer tous les objets ou des objets spécifiques de la table.

Voyons l'implémentation dans le code :

Parlons maintenant des opérations de suppression. Dans Hibernate, il existe également une méthode principale pour supprimer un élément, non pas par ID, mais entièrement en tant qu'entité. La suppression par ID et d'autres cas seront abordés plus tard dans ce cours.

• delete(Object entity): Supprime l'objet de la base de données.

Ce sont les principales méthodes que nous utiliserons pour le moment. Au fur et à mesure que nous rencontrerons de nouvelles méthodes dont nous avons besoin (par exemple, createQuery()), nous les explorerons en pratique.