Commençons à apprendre Hibernate avec les bases des interfaces et des annotations. La première chose à faire est d'intégrer Hibernate dans votre projet. Tout commence, comme toujours, par l'importation des dépendances.

Importation et Configuration de Hibernate

Commençons par la procédure familière d'importation de Hibernate dans le projet. Pour ce faire, nous devons ouvrir le fichier pom.xml déjà familier et y ajouter l'importation de la dépendance Hibernate. Vous pouvez trouver la dernière version de Hibernate à ce lien.

Comme vous pouvez le voir, j'utilise la version 6.3.1, qui était la dernière au moment de la création de ce cours. Votre version peut varier légèrement, mais je crois que les annotations et fonctions principales resteront les mêmes qu'auparavant.

Une importation ne suffira pas pour nous, donc nous devons importer une autre dépendance pour connecter notre application au système de gestion de base de données (SGBD) MySQL. Plus précisément, nous devons importer le connecteur JDBC pour MySQL, que nous utiliserons pour nous connecter à la base de données.

Vous pouvez trouver la dernière version à ce lien.

hibernate.cfg.xml

Nous avons terminé le processus d'importation, et maintenant nous devons configurer correctement Hibernate. Nous le ferons dans le fichier hibernate.cfg.xml, qui devrait être situé dans le dossier src/main/resources.

Je vais vous fournir un modèle de ce à quoi la configuration devrait ressembler à ce stade du cours, puis je vous expliquerai ce que cela signifie :

1. Déclaration XML et DOCTYPE :

   • <?xml version="1.0" encoding="utf-8"?> déclare qu'il s'agit d'un fichier XML version 1.0 avec encodage UTF-8 ;
   • <!DOCTYPE hibernate-configuration SYSTEM "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd"> spécifie le type de document et se réfère au DTD pour la configuration Hibernate, aidant à la validation de la structure du fichier XML.

2. Configuration de la Session Factory :

   • L'élément <hibernate-configuration> englobe toute la configuration Hibernate ;
   • À l'intérieur de <session-factory>, les paramètres pour la session factory Hibernate sont spécifiés, gérant les sessions de base de données.

3. Configuration JDBC :

   • hibernate.connection.driver_class : classe du pilote JDBC pour la connexion à la base de données, ici pour MySQL.
   • hibernate.connection.url : URL de connexion à la base de données ;
   • hibernate.connection.username : Nom d'utilisateur pour l'accès à la base de données ;
   • hibernate.connection.password : Mot de passe pour l'accès à la base de données.

4. Configuration du Dialecte :

   • hibernate.dialect : Indique à Hibernate quel dialecte SQL utiliser pour générer des requêtes SQL spécifiques à la base de données, ici pour MySQL.

5. Paramètres d'Affichage et de Formatage SQL :

   • show_sql : Si true, Hibernate affiche toutes les requêtes SQL dans la console ;
   • format_sql : Si true, formate les requêtes SQL pour une meilleure lisibilité.

6. Gestion des Sessions :

   • hibernate.current_session_context_class : Spécifie comment gérer le contexte de la session actuelle, ici via les threads (thread), permettant l'utilisation de SessionFactory.getCurrentSession() pour obtenir la session actuelle dans le thread.

Cette configuration initialise et configure l'environnement Hibernate, définissant comment l'application se connecte à la base de données, quels paramètres SQL utiliser, et comment gérer les sessions pour les interactions avec la base de données.

Dans notre cas, tout ce que vous devez spécifier dans cette configuration est le lien vers votre base de données (si son nom est différent de celui que nous avons créé dans le chapitre précédent), le nom d'utilisateur MySQL, qui est généralement 'root', et le mot de passe. Vous pouvez trouver l'adresse de votre base de données et la table avec laquelle vous travaillerez dans MySQL Workbench, comme montré dans les captures d'écran :

Entité

Maintenant que nous avons configuré la connexion à la base de données et Hibernate, il est temps de commencer à travailler avec les entités. Commençons par comprendre ce qu'est une classe-entité dans Hibernate :

Pour qu'une classe soit considérée comme une classe entité dans Hibernate, elle doit répondre à quelques exigences :

• Annotation @Entity : La classe doit être annotée avec @Entity, indiquant à Hibernate que cette classe est une classe entité. Cette annotation dit à Hibernate de traiter la classe comme une entité qui doit être mappée à une table de base de données ;

• Constructeur sans argument : La classe entité doit avoir un constructeur sans argument public ou protected. Hibernate utilise ce constructeur pour instancier des objets de la classe Entity ;

• Attribut Identifiant : Chaque classe entité doit avoir une clé primaire, qui est mappée à l'aide de l'annotation @Id. Cet attribut sert d'identifiant unique pour chaque instance d'entité ;

• Attributs de Classe : Les attributs de la classe représentent les colonnes de la table. Ceux-ci peuvent être mappés aux colonnes de la base de données à l'aide d'annotations comme @Column ;

• Modificateurs d'Accès : Bien que ce ne soit pas une exigence stricte, c'est une bonne pratique de rendre les champs private et de fournir des getters et setters publics. Hibernate peut accéder aux champs directement ou via ces getters et setters.

Un exemple de classe Entity du chapitre précédent :

Comme vous pouvez le voir, nous répliquons les valeurs du tableau dans cette classe d'entité. Nous utilisons également Project Lombok pour économiser de l'espace sur votre écran :).

Nous utilisons des annotations comme @NoArgsConstructor, et @Data de Project Lombok pour que cette classe réponde aux exigences d'une classe d'entité.

Ensuite, allons-y étape par étape. Nous avons nommé la classe Employee car cette classe sert de modèle et de représentation d'un objet de la table employees. Nous spécifions le nom de la table dans les paramètres de l'annotation @Table comme suit : @Table(name = "employees"). Nous marquons également cette classe avec l'annotation @Entity.

Remarque

En Java, beaucoup de choses sont faites à l'aide d'annotations, vous rencontrerez donc souvent un grand nombre d'annotations. Par exemple, le framework Spring Boot est également presque entièrement construit sur des annotations et est constamment utilisé dans le développement.

Dans la classe Employee, il y a un champ id, qui représente un identifiant unique. Comme indiqué dans les exigences, nous l'avons désigné avec l'annotation @Id et @GeneratedValue. La deuxième annotation est utilisée pour incrémenter automatiquement la valeur de l'attribut id lors de l'ajout d'un élément, garantissant qu'il n'y a pas d'ID en double dans la table. De cette façon, nous pouvons maintenir l'unicité de chaque élément dans la table.

Remarque

Par exemple, si le maximum id dans la table est 5, lors de l'ajout d'un nouvel élément, nous n'avons pas besoin de spécifier un nouvel id ; il est automatiquement incrémenté et attribué la valeur 6.

Chacun des autres attributs, qui correspondent directement aux colonnes de la table employees, nous les annotons avec @Column, où nous spécifions le nom de la colonne dans la table. Cela permet à Hibernate d'identifier précisément les colonnes dont nous avons besoin.

Algorithme de Résumé

Eh bien, récapitulons l'algorithme :

• Une classe d'entité représente une table, et les objets de cette classe représentent des lignes dans cette table, stockant leurs valeurs ;
• Une telle classe devrait avoir des champs identiques aux colonnes de la table. Des champs supplémentaires peuvent également être ajoutés si requis par la logique métier ;
• La classe doit être marquée avec l'annotation @Entity, et les champs appropriés doivent utiliser des annotations comme @Column, @Id, et @GeneratedValue ;
• Il est bon de pratique de rendre les champs de cette classe private et d'y accéder via des getters et setters ;
• Des méthodes supplémentaires peuvent être ajoutées à ces classes si la logique métier l'exige, mais ce n'est pas recommandé. Les méthodes pour travailler avec cette classe devraient être placées dans des interfaces et classes d'implémentation séparées. Cela est guidé par le modèle de conception DAO.

Dans les prochains chapitres, vous allez créer votre propre classe d'entité qui répond à toutes ces normes. En pratique, vous comprenez toujours comment et quoi utiliser.