Tutorial « Framework de persistance : Hibernate

Framework de persistance
(Hibernate)

I. Introduction à Hibernate
Hibernate est un Framework Java de persistance qui permet de faire correspondre des tables de
base de données relationnelles avec des objets java.

Une fois la correspondance entre les deux mondes définie, le programme Java peut manipuler
toutes les données en utilisant que des JavaBean, masquant alors totalement la base de données
sous-jacente et ses spécificités. Le Framework assure le remplissage de ces objets et la mise à
jour de la base en se basant sur leur contenu.

:User :User :User

idUser=1 idUser=2 idUser=3

login=root login=toto login=you
pass=root pass=toto pass=you
email=root@yahoo.fr email=toto@yahoo.fr email=med@yahoo.fr
ville=casa ville=rabat ville=casa

Base de données relationnelle

Hibernate est un Framework de mapping Objet/Relationnel pour applications JAVA (et .NET
avec Nhibernate).

1
 Tutorial « Framework de persistance : Hibernate

• Le terme mapping objet/relationnel (ORM) décrit la technique consistant à faire le lien

entre la représentation objet des données et sa représentation relationnelle basée sur un
schéma SQL.
• Hibernate génère le code SQL :
o Pas de requête SQL à écrire,
o Pas d’Objet ResultSet à gérer,
o Application plus portable. S’adapte à la base de données cible.
• Hibernate s'occupe du transfert des objets Java dans les tables de la base de données
• En plus, il permet de requêter les données et propose des moyens de les récupérer.
• Il peut donc réduire de manière significative le temps de développement qui aurait été
autrement perdu dans une manipulation manuelle des données via SQL et JDBC

II. Mise en œuvre du Framework Hibernate

L'architecture d'Hibernate

Hibernate a besoin de plusieurs éléments pour fonctionner :

• Une classe de type JavaBean qui encapsule les données d'une table donnée nommée «
classe de persistance ».
• Des propriétés de configuration, notamment des informations concernant la connexion
à la base de données. Définit dans un fichier de configuration.
• Un fichier de correspondance qui configure la correspondance entre la classe et la table.

2
 Tutorial « Framework de persistance : Hibernate

III. Exemple d’application

Rappelons que hibernate est un Framework permettant de manipuler des données d’une table
dans une base de données à partir d’un objet java. L’exemple ci-dessous nous permettra de créer
des objets de type produit et les insérer, les modifier, les lister ou les supprimer dans la table
produit.

1. Création de la base de données

Avant de commencer la mise en œuvre d’hibernate, il est indispensable de créer une base de
données. A cet effet, nous allons créer une base de données appelée « GestionDesProduits »
contenant une table « Produit » comme suit :

NB : vous pouvez utiliser NetBeans pour créer la base de données ou un client comme
mySQLWorkbench. Je vais vous présenter par la suite comment créer une table avec NetBeans.

a) Utilisation de NetBeans pour manipuler des bases de données :

Dans l’outil NetBeans, allez dans l’onglet service et clic-droit sur Base de données et demander
une nouvelle connexion.

1. Choisir le driver MYSQL étant donné qu’on souhaite manipuler une base de
données de type My SQL
2. Clique sur Next

3
 Tutorial « Framework de persistance : Hibernate

3. Taper dans le champ password : root et cliquer sur Next et Next et finish

Cet écran contient les informations pour se connecter à une base de données et ceci concerne :

• Host : serveur hébergement le SGBD

• Port : 3306 le port par défaut de MYSQL
• Database : contient le nom de la base de données à laquelle on souhaite nous connecter
• User Name et Password : identifiant pour se connecter au serveur de la base de données

4. Clic-droit sur le lien que vous venez de créer et choisir « execut command ».
5. Taper la commande pour créer une base de données :
« Create database GestionProduits ; »

6. Allez dans « other databases » et cliquer droit sur la base de données que vous venez
de créer et sélectionner « Set As Defautl Catalog » ➔ ceci permet de sélectionner
cette base de données afin de la manipuler.
7. Clic-droit sur tables et choisir « Create Table ».
4
 Tutorial « Framework de persistance : Hibernate

Créer la table produit contient 3 champs dont :

• id correspond à la clé primaire de la table et il est auto-incrément.

• Le code désigne le code du produit et il est de type VARCHAR(45)
• Le libellé désigne le libellé du produit et il est de type VARCHAR(100).

Vérifier la création de la table produit dans « tables »

NB : Netbeans étant un client léger pour la gestion des bases de données, la contrainte qui
correspond à gérer l’identifient « id » en auto-increment n’étant pas pris en charge. Pour cela,
vous pouvez l’ajouter dans l’utilitaire « execut command » en exécutant la requête suivant :

« ALTER TABLE `produit` modify `id` INT( 11 ) AUTO_INCREMENT; »

2. Création d’une classe de persistance

Cette classe doit respecter le standard des Javabeans, notamment, encapsuler les propriétés dans
ses champs private avec des getters et setters et avoir un constructeur par défaut.

NB : revenir à l’onglet NetBeans et Créer un nouveau projet « GestionDesProduits »

Pour une meilleure organisation, nous allons créer des packages en suivant l’architecture
d’hibernate comme suit :

5
 Tutorial « Framework de persistance : Hibernate

Dans le package classes.javabeans, créer une classe « Produit » qui encapsulent les données,
cette classe doit avoir les mêmes champs que la table « produit » que vous avez créez au niveau
de votre base de données ainsi que les accesseurs et les modificateurs. Vous auriez aussi besoin
de définir un constructeur vide et un autre avec les attributs « code et libellé ».

NB : Hibernate exige que la classe de persistance définisse un constructeur sans argument.

3. Fichiers de configuration
Une fois la base de données et la table sont créées ainsi que la classe permettant d’encapsuler
les données. Nous allons commencer la configuration d’hibernate pour l’exécuter.

Pour cela, il faut fournir un certain nombre de propriétés concernant la configuration pour qu'il
puisse se connecter à la base de données.

Ces propriétés peuvent être fournies sous plusieurs formes :

• un fichier de configuration nommé hibernate.properties et stocké dans un répertoire

inclus dans le classpath
• un fichier de configuration au format XML nommé hibernate.cfg.xml

6
 Tutorial « Framework de persistance : Hibernate

NB : ce fichier est valable pour tout le projet.

Les infos indispensables sont les suivantes :

• hibernate.connection.driver_class = Le chemin vers le driver JDBC,

• hibernate.connection.url = Le chemin d'accès à la base,
• hibernate.connection.username = Le nom d'utilisateur de la connexion,
• hibernate.connection.password = Le mot de passe de la connexion,

Dans cet exemple, nous allons utiliser le fichier Hibernate.cfg.xml. Pour créer un fichier de
configuration Hibernate :

1. allez dans le projet « GestionDesProduits »

2. clic-droit sur le package « fichiershibernate » et choisir «new/other»
3. chercher « hiberante » et choisir « Hiberante configuration wizard »

4. taper Next et Next et choisir le chemin de la base de données que vous avez creér.

7
 Tutorial « Framework de persistance : Hibernate

Dans l’onglet « jdbc properties » renseigner les informations relatives à la connexion à la base
de données « GestionDesProduits »

En naviguant sur l’onglet source, le fichier de configuration est définit en format XML comme
suit :

8
 Tutorial « Framework de persistance : Hibernate

Vous allez remarquer que la création de ce fichier a automatiquement intégrer l’ensemble des
jar nécessaire pour l’exécution d’hiberante. En plus du driver JDBC pour la connexion à une
base de données MySQL.

4. Création du fichier de mapping

Hibernate a besoin de savoir comment charger et stocker des objets d'une classe persistante. C'est là
qu'intervient le fichier de mapping Hibernate. Le fichier de mapping indique à Hibernate à quelle table
dans la base de données il doit accéder, et quelles colonnes de cette table il devra utiliser.

NB : chaque classe de persistance correspond à un fichier de mapping qui porte le même nom de la
classe avec l’extention hbm.xml.

1. Dans le package fichiershibernate, choisir new/other/hibernate Mapping Wizard

9
 Tutorial « Framework de persistance : Hibernate

2. Donner au fichier du mapping le même nom que la classe persistance

3. Choisir la classe persistance ainsi que la table concernée dans la base de données

Ceci a permis de mapper la classe avec la table dans la base de données, il reste à mapper les attributs
avec chaque champ dans la table produit. Pour cela, dans la balise <class> des balises property pour
définir pour chaque propriété, le nom de la colonne correspondante dans la table produit.

• L'élément id est la déclaration de la propriété de l'identifiant, name="id" déclare le nom de la

propriété Java - Hibernate utilisera les méthodes getter et setter pour accéder à la propriété.
• L'attribut column indique à Hibernate quelle colonne de la table produit que nous utilisons pour
cette clef primaire.
• L'élément generator imbriqué spécifie la stratégie de génération de l'identifiant, dans ce cas nous
avons utilisé increment, laquelle est une méthode très simple utile surtout pour les tests.

Hibernate supporte aussi les identifiants générés par les bases de données, globalement uniques
« native », ainsi que les identifiants assignés par l'application « assigned ».

NB : si vous revenez dans le fichier de configuration, vous allez remarquer que hibernate a intégré
automatiquement le fichier de mapping que vous venez de créer.

10
 Tutorial « Framework de persistance : Hibernate

5. Démarrage d’hibernate
Il est temps de charger et de stocker quelques objets « produit », pour ce faire, nous devons compléter
la configuration avec du code d'infrastructure en utilisant une classe « HibernateUtil.java ».

La classe HibernateUtil utilise une SessionFactory qui permet d’établir la connexion avec la source de
données à partir du fichier de configuration « hibernate.cfg.xml ». La classe SessionFactory serait
instanciée autant de fois qu'il y a des demandes de connexion à la base, il est donc plus adapté de rendre
une même instance de SessionFactory accessible par ces demandes.

Cette classe possède une méthode appelée getSessionFactory() qui retourne la session hibernate en cours
si elle existe sinon elle se charge d’ouvrir une nouvelle session.

Nous créerons une classe d'aide HibernateUtil qui s'occupe du démarrage et rend la gestion des Sessions
plus facile. Cela est possible via l’outil Netbeans.

1. Dans le package fichiershibernate, clic-droit et choisir new/other/HibernateUtil.java

11
 Tutorial « Framework de persistance : Hibernate

6. Charger et stocker des objets

Finalement nous pouvons utiliser Hibernate pour charger et stocker des objets. Nous pouvons utiliser la
classe « gestiondesproduits.java » contenant la méthode main pour faire le test d’exécution. Ou créer
une nouvelle classe avec une méthode main.

Pour commencer, il faut commencer par la création d’un objet sessionFactory pour ouvrir une connexion
à la base de données. Ceci se fait en utilisant la méthode getSessionFactory de HibernateUtil.

SessionFactory sessionFactory = HibernateUtil.getSessionFactory();

Session session = sessionFactory.openSession();

Nous allons traiter 4 exemples :

Pour chaque exemple, une requête SQL de type Insert, Update, Delete ou select sera générée
automatiquement. Et chaque requête correspond à une transaction pour cela, on doit demander de
commencer une transaction avec l’instruction « Transaction tx = session.beginTransaction() » et à la fin
du traitement, nous devons envoyé un commit pour la validation de la transaction via la méthode
« tx.commit() »

Créer une classe « ProduitService.java » contenant les méthodes d’insertion, de mise à jour, de
suppression et de liste des produits. Ces méthodes doivent être statiques.

Exemple d’insertion d’un produit dans la base de données :

public static int Create(Produit p) {

SessionFactory sessionFactory = HibernateUtil.getSessionFactory();
Session session = sessionFactory.openSession();
Transaction tx = session.beginTransaction();
int limonadeID = (int)session.save(p);
tx.commit();
System.out.println("Produit crée est " + p);
return limonadeID;
}

12
 Tutorial « Framework de persistance : Hibernate

Chargement des objets avec session.load(), Update et delete :

La méthode session.load() est utilisée afin de charger un objet de la base de données et remplir ses
attributs. Cette méthode prend deux arguments :

• Le type de l’objet : exemple Produit.class

• L’identifiant de l’objet à charger

Cette méthode rend un objet de type Object que vous pouvez caster avec la classe concernée.

Session.update(Object) : permet de mettre à jour un objet dans la base de données

Session.delete(Object) : permet de supprimer un objet de la base de données

Exemple de modification d’un produit dans la base de données :

public static void update(Produit p){

SessionFactory sessionFactory = HibernateUtil.getSessionFactory();
Session session = sessionFactory.openSession();
Transaction tx = session.beginTransaction();
p.setLibellé("Limonade coca 150 ml");
session.update(p);
tx.commit();
System.out.println("Produit modifié est " + p);
}
Exemple de suppression d’un produit dans la base de données :

public static void delete(Produit p){

SessionFactory sessionFactory = HibernateUtil.getSessionFactory();
Session session = sessionFactory.openSession();
Transaction tx = session.beginTransaction();
session.delete(p);
tx.commit();
System.out.println("Produit supprimé est " + p);
}
Liste des produits dans la base de données :

public static List listProduit(){

SessionFactory sessionFactory = HibernateUtil.getSessionFactory();
Session session = sessionFactory.openSession();
Transaction tx = session.beginTransaction();
List listPr = session.createQuery("from Produit").list();
return listPr;
}

Dans une requête de type « select » pour pouvez intégrer des clauses where en utilisant le Le langage de
requêtage d’hibernate « HQL ». Ci-dessous un lien pour tutoriel d’utilisation de ce langage.

https://www.tutorialspoint.com/hibernate/hibernate_query_language.htm

13
 Tutorial « Framework de persistance : Hibernate

Exemple : nous allons créer une méthode dans la classe « ProduitService.java » qui permet de trouver
un produit en donnant son code :

public static List findCode(String code){

SessionFactory sessionFactory = HibernateUtil.getSessionFactory();
Session session = sessionFactory.openSession();
Transaction tx = session.beginTransaction();
String hql = "from Produit where code = :code";
Query hqlQuery = session.createQuery(hql);
hqlQuery.setParameter("code", code);
List listPr = hqlQuery.list();
return listPr;
}

Test de l’exécution dans une méthode main de la classe gestionDesProduits.java

Vous pouvez vérifier les requêtes SQL qui ont été générées automatiquement dans la console. Ceci se
fait en activant la propriété du fichier de configuration.

<property name="show_sql">true</property>

public static void main(String[] args) {

//Création d'un nouveau produit

Produit limonade = new Produit("SE12", "Limonade coca 50 ml");
int limonadeID = ProduitService.Create(limonade);

//modification d'un produit

ProduitService.update(limonade);

//suppression d'un produit

ProduitService.update(limonade);

//lister les produits

List listPr = ProduitService.listProduit();
Iterator i = listPr.iterator();
while (i.hasNext()) {
Produit pri = (Produit) i.next();
System.out.println(pri.toString());
}

//afficher un produit par son code

List listPrID = ProduitService.findByCode(code);
Produit pr = (Produit) listPrID.get(0);
System.out.println("produit findby code is " + pr);

}
}

14
 Tutorial « Framework de persistance : Hibernate

7. Les annotations Hibernate

Dans le chapitre précédent, nous avons présenté le concept de mapping en utilisant un fichier de mapping
XML. Rappelons que dans ce chapitre, nous avons mappé pour chaque classe, le nom de la table et pour
chaque attribut de la classe le nom de la colonne.

Il existe d’autres méthodes pour définir un modèle O/R autre que les fichiers de mapping et ceci se fait
via des annotations directement intégrées au code java.

Exemple d’annotations :

a) Les entités
Une entité, déclarée par l’annotation @Entity définit une classe Java comme étant persistante et donc
associée à une table dans la base de données. Cette classe doit être implantée selon les normes des beans:
propriétés déclarées comme n’étant pas publiques (private ), et accesseurs avec set et get, nommés selon
les conventions habituelles.

Par défaut, une entité est associée à la table portant le même nom que la classe. Il est possible d’indiquer
le nom de la table par une annotation @Table. Exemple de la table produit

@Entity
@Table(name="produit")
public class Produit {
...
}

b) Identifiant d’une entité

Toute entité doit avoir une propriété déclarée comme étant l’identifiant de la ligne dans la table
correspondante.

L’identifiant est indiqué avec l’annotation @Id. Pour produire automatiquement les valeurs
d’identifiant, on ajoute une annotation @GeneratedValue avec un paramètre Strategy. Voici deux
possibilités pour ce paramètre:

15
 Tutorial « Framework de persistance : Hibernate

• Strategy = GenerationType.AUTO. Hibernate produit lui-même la valeur des identifiants grâce

à une table hibernate_sequence.
• Strategy = GenerationType.IDENTITY. Hibernate s’appuie alors sur le mécanisme propre au
SGBD pour la production de l’identifiant. Dans le cas de MySQL, c’est l’option AUTO-
INCREMENT.

@Id
@GeneratedValue(Strategy = GenerationType.AUTO)
private Integer id;
private void setId(Integer i) { id = i; }
public Integer getId() { return id; }

Si la clé est auto-incrémentée dans MySQL, l’annotation est la suivante.

@Id
@GeneratedValue(Strategy = GenerationType.IDENTITY)
private Integer id;

c) Les colonnes
Par défaut, toutes les propriétés non-statiques d’une classe-entité sont considérées comme devant être
stockées dans la base. Pour indiquer des options (et aussi pour des raisons de clarté à la lecture du code)
on utilise le plus souvent l’annotation @Column, comme par exemple:

@Column (name="code")
private String Code;
public void setCode(String n) {code= n;}
public String getCode() {return code;}

@Column (name="libelle")
private String libelle;
public void setLibelle(String n) {libelle= n;}
public String getLibelle() {return libelle;}

Cette annotation est utile pour indiquer le nom de la colonne dans la table, quand cette dernière est
différente du nom de la propriété en java.

Les principaux attributs pour @Column.

• name indique le nom de la colonne dans la table;

• length indique la taille maximale de la valeur de la propriété;
• nullable (avec les valeurs false ou true) indique si la colonne accepte ou non des valeurs
à NULL (au sens « base de données » du terme: une valeur à NULL est une absence de valeur);
• unique indique que la valeur de la colonne est unique

Dans un objet métier, on peut très bien avoir des propriétés que l’on ne souhaite pas rendre persistantes
dans la base. Il faut alors impérativement les marquer avec l’annotation @Transient.

16
 Tutorial « Framework de persistance : Hibernate

Une fois la classe de persistance a été créée, il faut l’intégrer dans le fichier de configuration. Pour cela,
il faut ajouter dans la balise <sessionFactory>.

<mapping class="classes.javabeans.Vente"/>

Exercice :

Nous allons créer une classe vente en utilisant les annotations pour la mapper avec la table vente de la
base de données. Définir les accesseurs et les modificateurs ainsi que les constructeurs.

1. Créer Une table dans la base de données « gestionDesProduits » appellée vente

2. Créer la classe « VenteService.java » contenant les méthodes create, update, delete et listVente.
3. Tester l’exécution dans la classe « GestionDesProduits.java »

Documentation sur les annotations

Pour avoir plus de documentation sur les annotations du mapping, vous pouvez consulter le lien ci-
dessous :

http://docs.jboss.org/hibernate/orm/3.3/reference/en/html/mapping.html

17
 Tutorial « Framework de persistance : Hibernate

IV. TP : Framework de persistance : Hibernate

Exercice 1 :

On souhaite créer une application pour la gestion des étudiants, pour ce faire nous proposons le
diagramme de classe suivant :

1. Dans votre projet « gestionDesEtudiants »

2. rajouter dans l’entité « Etudiant » les annotations (Entity, Id, GeneratedValue, Column,
Table…).
3. Créer une base de données nommée « Etudiant » sous MySql.
4. Créer le fichier de configuration Hibernate « hibernate.cfg.xml » dans le package
« ma.projet.config ».
5. Créer la classe HibernateUtil permettant de créer une instance de la classe « SessionFactory »
dans le package « ma.projet.util ».
6. Créer la classe service « EtudiantService » dans le package « ma.projet.service » et créer les
méthodes :
a. CreateEtudiant(Etudiant et) : int
b. UpdateEtudiant (Etudiant et) : boolean
c. deleteEtudiant((Etudiant et) :boolean
d. findById(int id) : Etudiant
e. findAll() : List : List<Etudiant>

7. Dans une classe de test :

▪ Créer cinq étudiants,
▪ Afficher la liste des étudiants,
▪ Afficher les informations de l’étudiant dont id = 2,
▪ Supprimer l’étudiant dont id = 3,
▪ Modifier les informations de l’étudiant dont id = 1,
▪ Afficher la liste des étudiants dont la moyenne > 12,
▪ Afficher la liste des étudiants dont le nom commence par « A »

18