Vous êtes sur la page 1sur 20

HIBERNATE

Framework de mapping objet-relationnel

Djemal Ahmed
Architecture d'une application Java en
couches
 Une application java est souvent découpée en couches. Considérons une
architecture courante, celle à trois couches :

Couche Couche d’accès aux


utilisateur Couche Métier données (DAO) Données
Interface
1 2 3
 La couche [1], (User Interface) : dialogue avec l'utilisateur, via une interface
graphique Swing, une interface console ou une interface web. Elle a pour rôle de
fournir des données provenant de l'utilisateur à la couche [2] ou bien de
présenter à l'utilisateur
l utilisateur des données fournies par la couche [2]
[2].
 • La couche [2], appelée ici [metier] est la couche qui applique les règles dites
métier, c.a.d. la logique spécifique de l'application, sans se préoccuper de savoir
d'où viennent les données q qu'on lui donne, ni où vont les résultats qu'elle
q produit.
p
 • La couche [3], appelée ici [dao] (Data Access Object) est la couche qui fournit à
la couche [2] des données pré-enregistrées et qui enregistre certains des résultats
fournis par la couche [2].

2 Hibernate java
Couche accès aux données

Il existe différentes possibilités pour implémenter la couche Accès aux


Données

Couche d’accès
Couche Couche Base de 
utilisateur Couche Métier aux données
Interface (DAO) JDBC données
1 2 3

La couche [JDBC] est la couche standard utilisée en Java pour accéder


à des bases de données
données. Elle isole la couche [dao] du SGBD qui gère la
base de données.

3 Hibernate java
Couche HIBERNATE
De multiples efforts ont été faits pour isoler la couche [dao] des aspects propriétaires des 
SGBD  Une solution qui a eu un vrai succès dans ce  domaine ces dernières années  est 
SGBD. Une solution qui a eu un vrai succès dans ce  domaine ces dernières années, est 
celle d'Hibernate

Couche
C h d’
d’accès
è Objets
Obj t image
i Couche Couche BD
aux données de la BD
(DAO) Hibernate JDBC

La couche [Hibernate] vient se placer entre la couche [dao] écrite par le développeur et 
la couche [Jdbc]

Hibernate est un ORM (Object Relational Mapping), un outil qui fait le pont entre le 


modèle relationnel des bases de données et celui des objets manipulés par Java

Le développeur ne voit plus la couche [Jdbc] ni les tables de la BD. Il ne voit que l'image 
objet de BD, fournie par la couche [Hibernate]. Le pont entre les tables de la BD et les 
objets manipulés par la couche [dao] est fait par des fichiers de configuration de type 
j p p p g yp
XML
4 Hibernate java
Hibernate
 Hibernate est un projet open source visant à proposer un
outilil de
d mapping
i entre lles objets
bj et des d données
d é stockées

dans une base de données relationnelle. Ce projet ne
repose sur aucun standard mais il est très populaire
notamment à cause de ses bonnes performances et de
son ouverture avec de nombreuses bases de données.
 Les bases de données supportées sont les principales du
marché : Oracle, MySQL, PostgreSQL, Sybase, SQLServer,
S DB,
Sap DB DB2,Interbase,
DB2 I b ...
 Le site officiel http://www.hibernate.org contient
beaucoup d d'informations
informations sur l'outil
l outil et propose de le
télécharger ainsi que sa documentation.

5 Hibernate java
Architecture Hibernate

6 Hibernate java
Principe de fonctionnement à l’aide d’un
Exemple
Nous allons utiliser Hibernate avec une base de données de type
MySQL possédant une table nommée "personnes"
personnes .

Créez la table personnes


dans la BD bdperso

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


• Une classe « javabean » qui encapsule les données d'une occurrence
d'une table
• Un fichier de correspondance qui configure la correspondance entre la
classe et la table
• Des propriétés de configuration notamment des informations concernant
l connexion à la
la l base
b de
d données
d é
Une fois ces éléments correctement définis, il est possible d'utiliser
Hibernate
be ate dans
a s lee code
co e des
es traitements
t a te e ts à réaliser.
éa se .
7
Utilisation d
d'Hibernate
Hibernate
 Pour utiliser Hibernate dans le code, il est nécessaire de
réaliser plusieurs opérations :
 création d'une instance de la classe
 création d'une instance de la classe SessionFactory
 création d'une instance de la classe Session qui va permettre
d' tili
d'utiliser lles services
i d'Hib
d'Hibernate
t

8 Hibernate java
hibernate annotation cfg xml
hibernate-annotation.cfg.xml
<hibernate-configuration>
<
<session-factory>
i f t >
<!-- Database connection properties - Driver, URL, user, password -->
<property
p p y name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
yqj p p y
<property name="hibernate.connection.url">jdbc:mysql://localhost/TestDB</property>
<property name="hibernate.connection.username">root</property>
<property name="hibernate.connection.password"></property>
" "
<mapping class="com.journaldev.hibernate.model.Employee1"/>
</session-factory>
/session factory
</hibernate-configuration>

9 Hibernate java
Maven Dependencies
<dependency>
<groupId>junit</groupId>
groupId junit /groupId
<artifactId>junit</artifactId>
<version>3.8.1</version>
scope test /scope
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.hibernate</groupId>
<groupId>org hibernate</groupId>
<artifactId>hibernate-core</artifactId>
<version>4.3.5.Final</version>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
if Id l j / if Id
<version>5.1.6</version>
</dependency>

10 Hibernate java
Utilisation d
d'Hibernate
Hibernate
 Une instance de la classe Session est obtenu à partir
d'
d'une fabrique
f b de
d type SessionFactory.
S F
 Cet objet est obtenu à partir de l'instance du type
C fi
Configuration
i en utilisant
ili lla méthode
éh d
buildSessionFactory().
 L méthode
La é h d openSession()
S i () de d la
l classe
l
SessionFactory permet d'obtenir une instance de la
classe Session.
Session
 Par défaut, la méthode openSession() qui va ouvrir
une connexion vers la base de données en utilisant
les informations fournies par les propriétés de
configuration.
11 Hibernate java
Méthode de travail : Hibernate
 Le fichier “HibernateUtil.java” permet de créer le “session
factory “ . Il faut créer une nouvelle classe
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
ppublic class HibernateUtil {
private static final SessionFactory sessionFactory;
static {
try { //Create the SessionFactory
sessionFactory
F = new Configuration().configure("hibernate.cfg.xml").buildSessionFactor
C f () f ("h b f l") b ldS F
y();
} catch (Throwable ex) { // Log the Exception
y p (
System.err.println("SessionFactory y creation failed!!!" + ex);
);
throw new ExceptionInInitializerError(ex);
} }
public static SessionFactory getSessionFactory() {
return sessionFactory;
} }

12 Hibernate java
La persistance d'une
d une nouvelle occurrence
 Pour créer une nouvelle occurrence dans la source de données, il
suffit de :
 créer une nouvelle instance de classe encapsulant les données,
 de valoriser ces propriétés
p p
 et d'appeler la méthode save() de la session en lui passant en
paramètre l'objet encapsulant les données.

 La méthode save() n'a aucune action directe sur la base de données.


 Pour enregistrer les données dans la base,
base il faut réaliser un commit
sur la connexion ou la transaction ou faire appel à la méthode
flush() de la classe Session.

 Voir exemple de code suivant :

13 Hibernate java
import net.sf.hibernate.*;
import
p net.sf.hibernate.cfg.Configuration;
g g
import java.util.Date;
public class TestHibernate1 {
public static void main(String args[]) throws Exception {
Configuration
g config
g = new Configuration();
g ()
config.addClass(Personnes.class);
SessionFactory sessionFactory = config.buildSessionFactory();
Session session = sessionFactory.openSession();
Transaction tx = null;
try {
tx = session.beginTransaction();
Personnes personne = new Personnes("nom3", "prenom3", new Date());
session.save(personne);
session.flush() ;
tx.commit();
} catch (Exception e) {

if (tx != null) {
tx.rollback();
}
throw e;
} finally {
session.close();
}
sessionFactory.close();
}
}
14 Hibernate java
Le langage de requête HQL
 Pour offrir un langage d'interrogation commun à toutes les
base de données,
données Hibernate propose son propre langage
nommé HQL (Hibernate Query Language)

 HQL est proche de SQL avec une utilisation sous forme


d'objets des noms de certaines entités : il n'y a aucune
référence aux tables ou aux champs car ceux ci sont
référencés respectivement par leur classe et leurs propriétés.

 C'est Hibernate qui se charge de générer la requête SQL à


ppartir de la requête
q HQL
Q en tenant comptep du contexte ((type
yp
de base de données utilisée défini dans le fichier de
configuration et la configuration du mapping).

15 Hibernate java
La méthode createQuery()
 méthode createQuery() de la classe Session permet
d'effectuer une recherche d'occurrences grâce à la
requête fournie en paramètre.
 Si la requête nécessite des paramètres, ces derniers
son signalés
g par
p ?
 Il seront passés grâce à méthode setType appliquée à
ll’objet
objet de type Query résultant de ll’appel
appel de la
méthode createQuery()
 LL’exécution
exécution de la requête se fait via la méthode list()
appelé sr l’objet de type Query

16 Hibernate java
Exemple : rechercher toutes les occurrences
d'une
d une table
import net.sf.hibernate.*;
import net.sf.hibernate.cfg.Configuration;
net sf hibernate cfg Configuration;
import java.util.*;
public class TestHibernate3 {
public static void main(String args[]) throws Exception {
Configuration config = new Configuration();
config.addClass(Personnes.class);
SessionFactory sessionFactory = config.buildSessionFactory();
Session session = sessionFactory.openSession();
try {
Query req = session.createQuery(" from Personnes ");
List personnes = req.list();
for (int i = 0; i < personnes.size(); i++) {
Personnes personne = (Personnes) personnes.get(i);
System.out.println("nom = " + personne.getNomPersonne());
} } finally { session.close(); }sessionFactory.close();
}} 17 Hibernate java
La mise à jour d
d'une
une occurrence
 Pour mettre à jour une occurrence dans la source de
d
données,
é il suffit
ffi d'appeler
d' l lla méthode
é h d update()
d () ded la
l
session en lui passant en paramètre l'objet encapsulant les
données.
données

 Le mode de fonctionnement de cette méthode est


similaire à celui de la méthode save().

 La méthode saveOrUpdate() laisse Hibernate choisir


entre l'utilisation de la méthode save() ou update() en
fonction de la valeur de l'identifiant dans la classe
encapsulant les données.

18 Hibernate java
La suppression d'une ou plusieurs
occurrences
 La méthode delete() de la classe Session permet de
supprimer une occurrence passée en paramètre.
 Pour supprimer une occurrence encapsulée dans une
classe, il suffit d'invoquer la classe en lui passant en
paramètre l'instance de la classe.

19 Hibernate java
Les relations
 Un des fondements du modèle de données relationnelles repose sur
les relations qui peuvent intervenir entre une table et une ou
plusieurs autres tables ou la table elle même.

 Hibernate propose de transcrire ces relations du modèle relationnel


dans le modèle objet. Il supporte plusieurs types de relations :
• relation de type 1 - 1 (one-to-one)
(one to one)
• relation de type 1 - n (many-to-one)
• relation de type
yp n - n ((many-to-many)
y y)
 Dans le fichier de mapping, il est nécessaire de définir les relations
entre la table concernée et les tables avec lesquelles elle possède
des relations.
relations
 Nous pouvons utiliser les annotations pour le même objectif

20 Hibernate java

Vous aimerez peut-être aussi