Par N.

Chenfour

Site Web : http://www.acs.ma - Email : [email protected]

Tél./Fax : 035 64 18 61 - GSM : 063 05 10 39
Résidence Fès-Carrefour, Bureau N° 6, Lot Walili, Avenue des FAR, Fès - Maroc.
 Table des Matières

Chapitre 1. Présentation du framework Hibernate

Chapitre 2. Réalisation d’une application Hibernate

Chapitre 3. Hibernate Synchronizer

Chapitre 4. Hibernate Tools

Chapitre 5. Configuration et gestion des objets

persistants

Chapitre 6. Mapping à l’aide d’une configuration XML

Chapitre 7. Mapping par les annotations

Chapitre 8. Le Langage HQL

Site Web : http://www.acs.ma - Email : [email protected]

Tél./Fax : 035 64 18 61 - GSM : 063 05 10 39
Résidence Fès-Carrefour, Bureau N° 6, Lot Walili, Avenue des FAR, Fès - Maroc.
Copyright © ACS TechnoCenter / N. Chenfour, Tel : 06 63 05 10 39, email : [email protected] 3
 Chapitre 1. Présentation du
framework Hibernate

1.1 Description du framework Hibernate

Les informations ou données, manipulées par une application quelconque

sont généralement sauvegardées dans une base de données qui pour la
grande majorité des applications est une base de données relationnelle.
L’application quant à elle est basée sur les mécanismes de la
programmation orientée objets. L’utilisation d’un outil d'ORM (object
Relationnal Mapping) s’impose alors afin de soulager le développeur de
l’effort considérable qu’il devrait fournir pour réaliser l’ensemble des
classes lui permettant de convertir les objets en des tuples et
inversement.

Hibernate est l’un des outils les plus populaires, stables et robuste
permettant le mapping objet/relationnel pour les applications Java. Il
s’agit dont d’un ORM (Objet Relational Mapper) qui consiste à faire le lien
entre la représentation objet des données et sa représentation
relationnelle basée sur un schéma SQL.

Hibernate est un framework open source dont le fondateur est Gavin King,
qui fait entre autre partie de l'équipe de développement de JBOSS.

Non seulement, Hibernate s'occupe du transfert des classes Java dans les
tables de la base de données (et des types de données Java dans les
types de données SQL), mais il permet aussi de requêter les données et
propose des moyens de les récupérer. Il peut donc réduire de manière
considérable le temps de développement réalisé habituellement à base de

Copyright © ACS TechnoCenter / N. Chenfour, Tel : 06 63 05 10 39, email : [email protected] 4

l’API JDBC avec plusieurs lignes de code permettant de gérer tous les
transferts des objets nécessaires. Le framework Hibernate libère ainsi le
développeur de plus que 90% des tâches de programmation liées à la
persistance des données. Il offre aussi la gestion automatique du mapping
dan les différents cas que sont la composition, les associations, l’héritage,
le polymorphisme ainsi que la prise en charge des collections Java.

Hibernate rentre ainsi dans le cadre des frameworks basés sur les POJO
(Plain Old Java Object) offrant à un POJO la possibilité d’être persitant
avec un minimum d’effort; en utilisant un simple moteur de persistance.
Le schéma idéal est alors le suivant :

PojoClass pojo = new PojoClass() ;

PersistanceEngine engine = PersistanceEngineFactory.createEngine();

engine.save(pojo);

1.2 Historique des versions

Version Date
Hibernate 3.6.1 03.02.2011
Hibernate 3.3.1 11.09.2008
Hibernate 3.2.5 31.07.2007
Hibernate 2.1.8 30/01/2005
Hibernate 2.0 09/06/2003
Hibernate 1.0 06/07/2002

Copyright © ACS TechnoCenter / N. Chenfour, Tel : 06 63 05 10 39, email : [email protected] 5

1.3 Installation du framework Hibernate

Modules du Framework :
Hibernate se compose de plusieurs modules développés par différentes
équipes et téléchargeables depuis le site officiel du framework :
http://www.hibernate.org

Hibernate Core : c’est le module principal du framework Hibernate.

Il contient les APIs de base et les différentes fonctionnalités de
mapping XML.

Hibernate Annotations : Support des Annotations permettant de

réaliser le mapping sans utilisation de fichiers XML.

Hibernate EntityManager : support de Java Persistance API

Copyright © ACS TechnoCenter / N. Chenfour, Tel : 06 63 05 10 39, email : [email protected] 6

 Hibernate Shards : Ce module permet la partition verticale du
Core Hibernate

Hibernate Validator : Module d’intégrité et de validation des

données implémenté sous forme d'annotations permettant de
contrôler les plages de valeurs autorisées, les formats de chaines de
caractère, la détection des valeurs nulles, etc...

Hibernate Search : Module d’indexation et de requêtage des

données.

Hibernate Tools : Un ensemble outils et de plugins pour Ant et

Eclipse facilitant le développement avec Hibernate.

Interface de Téléchargement :

Copyright © ACS TechnoCenter / N. Chenfour, Tel : 06 63 05 10 39, email : [email protected] 7

Liste des modules téléchargés :

Installation du module Hibernate Core :

Librairies de base du Framework :

antlr-2.7.6.jar hibernate3.jar javassist-3.4.GA.jar jta-1.1.jar

dom4j-1.6.1.jar slf4j-api-1.5.2.jar commons-collections-3.1.jar

Copyright © ACS TechnoCenter / N. Chenfour, Tel : 06 63 05 10 39, email : [email protected] 8

Pour la journalisation :

Log4j.jar slf4j-log4j12.jar

Remarque :
Le projet devra intégrer la bibliothèque « slf4j-log4j12.jar » pour
la prise en charge du système de journalisation utilisé automatiquement
par le framework hibernate.
Il est aussi recommandé de greffer à ce système de journalisation la
bibliothèque log4j « log4j.jar ».
La configuration de cette bibliothèque est réalisée à l’aide d’un fichier XML
« log4j.xml » qui peut être défini comme suit :
Log4j.xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE log4j:configuration PUBLIC
"http://logging.apache.org/log4j/docs/api/org/apache/log4j/xml/log4j.dtd"
"http://logging.apache.org/log4j/docs/api/org/apache/log4j/xml/log4j.dtd">

<log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/">

<appender name="console" class="org.apache.log4j.ConsoleAppender">

<layout class="org.apache.log4j.SimpleLayout" />
</appender>

<root>
<level value="error" />
<appender-ref ref="console" />
</root>

</log4j:configuration>

Ajouté à ça, nous aurons besoin de l’API de connexion avec une base de
données MySQL :

Mysql.jar

Copyright © ACS TechnoCenter / N. Chenfour, Tel : 06 63 05 10 39, email : [email protected] 9

1.4 Bases de données supportées par Hibernate

Hibernate supporte les principales bases de données du marché : DB2,

Oracle, MySQL, PostgreSQL, Sybase, SQL Server, Sap DB, Interbase, ...

Hibernate propose une liste de classes issues de

« org.hibernate.dialect.Dialect » pour chaque base de données
supportée. Ces classes, appelées « dialectes », permettent d’utiliser le
dialecte SQL approprié pour la base de données cible.

Base de données Dialecte (org.hibernate.dialect)

DB2 DB2Dialect
Ingress IngresDialect
HSQLDB HSQLDialect
Microsoft SQL Server SQLServerDialect
MySQL5 MySQL5Dialect
MySQL (< 5.x) MySQLDialect
Oracle OracleDialect
Oracle9i/10g Oracle9Dialect
PostgreSQL PostgreSQLDialect
Progress ProgressDialect
SAP DB SAPDBDialect
Sybase SybaseDialect
TimesTen TimesTenDialect
PointBase PointbaseDialect
Derby DerbyDialect
Firebird FirebirdDialect
FrontBase FrontBaseDialect
Mckoi MckoiDialect
InterBase InterbaseDialect

Copyright © ACS TechnoCenter / N. Chenfour, Tel : 06 63 05 10 39, email : [email protected] 10

1.5 Architecture Générale du Framework Hibernate

Le schéma suivant montre les différentes composantes du framework

Hibernate utilisant une base de données et une ensemble de composants
de configuration pour fournir le service de persistance à une application
Java.

Copyright © ACS TechnoCenter / N. Chenfour, Tel : 06 63 05 10 39, email : [email protected] 11

Copyright © ACS TechnoCenter / N. Chenfour, Tel : 06 63 05 10 39, email : [email protected] 12
 Chapitre 2. Réalisation d’une
application Hibernate

2.1 Principe de base d’une application Hibernate

Application
Objet Objet Objet
Persistant Persistant Persistant
A B C

Session
Hibernate.cfg.xml

Mapping Mapping Mapping

XML XML XML
A.hbm.xml B.hbm.xml C.hbm.xml

Table Table Table

A B C

Base de données

Copyright © ACS TechnoCenter / N. Chenfour, Tel : 06 63 05 10 39, email : [email protected] 13

2.2 Configuration habituelle

Pour pouvoir développer une application avec Hibernate, il faut avoir :

La distribution de Hibernate et d’autres librairies dépendantes

(telles que log4j)
Un schéma de base de données
Des classes persistantes implémentant les entités et associées aux
différentes tables.
Un fichier de configuration Hibernate (hibernate.cfg.xml ou
hibernate. properties)
Un fichier de mapping pour chaque classe persistante. Celui-ci porte
le nom de la classe et postfixé par « .hbm » + l’extension « .xml »

2.3 Structure arborescente d’une application Hibernate

Projet Hibernate

src

Package de l’application
A.java (classe persistante)
A.hbm.xml
B.java (classe persistante)
B.hbm.xml

Hibernate.cfg.xml

Copyright © ACS TechnoCenter / N. Chenfour, Tel : 06 63 05 10 39, email : [email protected] 14

2.4 Développement d’une application Hibernate avec
Eclipse

Nous supposons que l’on dispose d’une base de données MySQL appelée
« stock » et contenant un certain nombre de tables.

Dans notre premier exemple nous aurons besoin d’une table Produit
définie comme suit :

CREATE DATABASE Stock;

USE Stock;

CREATE TABLE Produit (

Ref VARCHAR(15),
Desig VARCHAR(30),
PU FLOAT,
QS FLOAT,

CONSTRAINT XRef UNIQUE (Ref)

);

Copyright © ACS TechnoCenter / N. Chenfour, Tel : 06 63 05 10 39, email : [email protected] 15

Etape N° 1/7 :

Créer un projet Java ordinaire

Etape N° 2/7 :

Créer un répertoire « lib » dans le répertoire du projet :

Copyright © ACS TechnoCenter / N. Chenfour, Tel : 06 63 05 10 39, email : [email protected] 16

Etape N° 3/7 :

Copier les librairies Hibernate utiles dans le répertoire « lib », et

ensuite les ajouter au « Build Path :

Copyright © ACS TechnoCenter / N. Chenfour, Tel : 06 63 05 10 39, email : [email protected] 17

Etape N° 4/7 :

Créer La classe « Produit » qui devrait correspondre à la table

« Produit » : les noms (et types) des propriétés devrais correspondre au
noms (et types) des champs.

package com.acs.formations.hibernate;

public class Produit {

private String ref;
private String desig;
private double pu;
private double qs;

public Produit() {
}

public Produit(String ref, String desig, double pu, double qs) {

this.ref = ref;
this.desig = desig;
this.pu = pu;
this.qs = qs;
}

// getters & setters

// ...

public String toString() {

return "{" + ref + ", " + desig + ", " + pu + ", " + qs + "}";
}
}

Copyright © ACS TechnoCenter / N. Chenfour, Tel : 06 63 05 10 39, email : [email protected] 18

Etape N° 5/7 :

Créer Le fichier « hibernate.cfg.xml » dans le répertoire source

« src » :

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE hibernate-configuration
PUBLIC "-//Hibernate/Hibernate Configuration DTD//EN"
"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">

<hibernate-configuration>

<session-factory>

<property name="hibernate.connection.url">
jdbc:mysql://localhost/stock
</property>

<property name="hibernate.connection.driver_class">
com.mysql.jdbc.Driver
</property>

<property name="hibernate.connection.username">
root
</property>

<property name="hibernate.connection.password"></property>

<property name="dialect">
org.hibernate.dialect.MySQLDialect
</property>

<property name="hibernate.show_sql">false</property>

<mapping resource="com/acs/formations/hibernate/Produit.hbm.xml" />

</session-factory>

</hibernate-configuration>

Copyright © ACS TechnoCenter / N. Chenfour, Tel : 06 63 05 10 39, email : [email protected] 19

Etape N° 6/7 :

Créer Le fichier « Produit.hbm.xml » dans le répertoire

correspondant au package de la classe « Produit » :

com/acs/formations/hibernate

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
<class
name="com.acs.lab.hibernate.Produit"
table="produit"
>
<id
name="ref"
type="string"
column="ref"
length="15"
/>
<property
name="desig"
column="desig"
type="string"
not-null="false"
length="30"
/>
<property
name="pu"
column="pu"
type="java.lang.Double"
not-null="true"
/>
<property
name="qs"
column="qs"
type="java.lang.Double"
not-null="true"
/>
</class>
</hibernate-mapping>

Copyright © ACS TechnoCenter / N. Chenfour, Tel : 06 63 05 10 39, email : [email protected] 20

Etape N° 7/7 :

Créer La classe de test :

public class HibernateTest {

private Session session;

private void openSession() {

Configuration config = new Configuration();
SessionFactory sessionFactory =
config.configure().buildSessionFactory();

Session session = sessionFactory.openSession();

session.beginTransaction();
}

private void closeSession () {

session.getTransaction().commit();

session.close();
}

public HibernateTest() {
openSession();
Produit p = new Produit("C07", "Stylo", 20, 100);
session.save(p);
System.out.println("OK! Sauvegarde bien effectuée...");
closeSession ();
}

public static void main(String[] args) {

new HibernateTest();
}
}

Copyright © ACS TechnoCenter / N. Chenfour, Tel : 06 63 05 10 39, email : [email protected] 21

 Chapitre 3. Hibernate
Synchronizer

1.1 Description du framework Hibernate

Après avoir ajouté le plugin correspondant, on peut vérifier les

fonctionnalités ajoutées à Eclipse :

Copyright © ACS TechnoCenter / N. Chenfour, Tel : 06 63 05 10 39, email : [email protected] 22

Une nouvelle rubrique s’ajoute « Hibernate » permettant de créer un fichier
de configuration Hibernate ainsi que les fichiers de mapping XML

Copyright © ACS TechnoCenter / N. Chenfour, Tel : 06 63 05 10 39, email : [email protected] 23

Fenêtre de configuration Hibernate :

Copyright © ACS TechnoCenter / N. Chenfour, Tel : 06 63 05 10 39, email : [email protected] 24

Sélection du driver approprié. Pour notre cas « com.mysql.jdbc.Driver » :

Copyright © ACS TechnoCenter / N. Chenfour, Tel : 06 63 05 10 39, email : [email protected] 25

Sélection du type de bases de données, avec saisie des paramètres de
connexion :

Copyright © ACS TechnoCenter / N. Chenfour, Tel : 06 63 05 10 39, email : [email protected] 26

Les tables sont automatiquement affichées ; avec la possibilité de sélection
des tables à mapper :

Copyright © ACS TechnoCenter / N. Chenfour, Tel : 06 63 05 10 39, email : [email protected] 27

Génération des fichiers de mapping pour les tables sélectionnées :

Copyright © ACS TechnoCenter / N. Chenfour, Tel : 06 63 05 10 39, email : [email protected] 28

Synchronisation automatique :

Copyright © ACS TechnoCenter / N. Chenfour, Tel : 06 63 05 10 39, email : [email protected] 29

Génération automatique des classes persistantes :

Copyright © ACS TechnoCenter / N. Chenfour, Tel : 06 63 05 10 39, email : [email protected] 30

Copyright © ACS TechnoCenter / N. Chenfour, Tel : 06 63 05 10 39, email : [email protected] 31
Chapitre 4. Hibernate Tools

1.1 Installation de Hibernate Tools

Il ya plusieurs façon de travailler avec Hibernate. Les outils Hibernate ou

« Hibernate Tools » peuvent soit être utilisés standalone via Ant 1.6.x ou
une version supérieure, soit intégrés dans un environnement de
développement tel que Eclipse.

1. Télécharger le plugin Hibernate Tools :

2. Dézipper l’archive puis copier le contenus de deux répertoires

/features et /plugins respectivement sous les répertoires/features
et /plugins d’Eclipse.

3. Démarrer Eclipse

Copyright © ACS TechnoCenter / N. Chenfour, Tel : 06 63 05 10 39, email : [email protected] 32

 1.2 Configuration d’Eclipse

Nous voulons ajouter les bibliothèques utiles du framework Hibernate ainsi

que celle de la connexion MySQL à l’environnement Eclipse.
Une solution adéquate : les ajouter sous forme de « User Libraries »
Et voici les étapes :

Etape N° 1 : Window/preferences, et ensuite « Java/User Libraries. Puis

cliquer sur le bouton « New »

Copyright © ACS TechnoCenter / N. Chenfour, Tel : 06 63 05 10 39, email : [email protected] 33

Etape N° 2 : Saisir le nom de la librairie

Etape N° 3 : « Add Jars »

Copyright © ACS TechnoCenter / N. Chenfour, Tel : 06 63 05 10 39, email : [email protected] 34

Etape N° 4 : Ajouter les Jar qu’il faut, et refaire la même opération pour les
différentes librairies utiles :

Copyright © ACS TechnoCenter / N. Chenfour, Tel : 06 63 05 10 39, email : [email protected] 35

Etape N° 5 : Créer votre Projet Java, click droit et ensuite « Build path » puis
« Add Libraries »

Etape N° 6 : sélectionner « User Library »

Copyright © ACS TechnoCenter / N. Chenfour, Tel : 06 63 05 10 39, email : [email protected] 36

Etape N° 7 : cocher les librairies nécessaires :

On obtient alors la configuration suivante :

Copyright © ACS TechnoCenter / N. Chenfour, Tel : 06 63 05 10 39, email : [email protected] 37

Etape N° 8 : Créer ensuite vos classes persistantes

1.2 Configuration d’Eclipse

• Ouvrir la Perspective Hibernate :

Copyright © ACS TechnoCenter / N. Chenfour, Tel : 06 63 05 10 39, email : [email protected] 38

 • Créer un fichier de Configuration :

Copyright © ACS TechnoCenter / N. Chenfour, Tel : 06 63 05 10 39, email : [email protected] 39

 • Sélectionner le répertoire « src » :

Copyright © ACS TechnoCenter / N. Chenfour, Tel : 06 63 05 10 39, email : [email protected] 40

 • Saisir les informations de configuration

• Explorer la vue « Hibernate Configuration »

Copyright © ACS TechnoCenter / N. Chenfour, Tel : 06 63 05 10 39, email : [email protected] 41

 • Création des fichiers de mapping :

Sélectionner le répertoire et saisir le nom du fichier de Mapping, ensuite

cliquer sur le bouton « next »

Copyright © ACS TechnoCenter / N. Chenfour, Tel : 06 63 05 10 39, email : [email protected] 42

Saisir le nom de la classe :

Le fichier est généré. Il nécessite une édition manuelle (avec auto-

completion : CTRL + espace)

Copyright © ACS TechnoCenter / N. Chenfour, Tel : 06 63 05 10 39, email : [email protected] 43

 • Création automatique des tables :

Si les tables n’existent pas au préalable, il est possible de les créer

automatiquement :

On obtient alors

Copyright © ACS TechnoCenter / N. Chenfour, Tel : 06 63 05 10 39, email : [email protected] 44

 • Execution de Requêtes HQL :

Le module Hibernate Tools offre aussi un environnement d’édition et

d’exécution des requêtes HQL (voir chapitre 8). Pour y accéder, on
procède par un click droit sur la configuration associée au projet dans la
vue « Hibernate Configurations ».

Une vue d’édition s’affiche, on y saisi la requête HQL :

Copyright © ACS TechnoCenter / N. Chenfour, Tel : 06 63 05 10 39, email : [email protected] 45

Le résultat sera affiché en bas sur la vue « Hibernate Query Result » :

Il est aussi possible d’accéder à la traduction de la requête HQL en son

équivalent SQL généré par le framework :

Copyright © ACS TechnoCenter / N. Chenfour, Tel : 06 63 05 10 39, email : [email protected] 46

Copyright © ACS TechnoCenter / N. Chenfour, Tel : 06 63 05 10 39, email : [email protected] 47
 Chapitre 5. Cofiguration et
gestion des objets
persistants
5.1 Eléments de Configuration

Deux types de configurations sont nécessaires pour l’écriture d’une

application Hibernate :
1. Le premier type est représenté par une instance de la classe
« org.hibernate.cfg.Configuration » qui regroupe un ensemble
de propriétés de mapping permettant de localiser la base de
données, le driver de connexion utilisé, le dialect SQL, les fichiers de
mapping etc. Ces propriétés de configuration peuvent être définies
de différentes manières :
- Par programmation : en définissant directement toutes les
propriétés de configuration à l’aide de l’instance de la classe
« org.hibernate.cfg.Configuration ».
- Par l’intermédiaire du fichier XML : hibernate.cfg.xml
- Ou encore à l’aide d’un fichier hibernate.proprties

2. L’autre type consiste à associer à chaque classe persistante le

mapping adéquat vers la table de base de données associée. On
dispose aussi dans ce cas de différentes manières de configuration :
- Par l’intermédiaire des fichiers de mapping XML :
NomDeLaClasse.hbm.xml (voir chapitre 6)
- Ou encore par annotation (voir chapitre 7)

Copyright © ACS TechnoCenter / N. Chenfour, Tel : 06 63 05 10 39, email : [email protected] 48

5.2 Configuration par programmation

Configuration config = new Configuration();

config.addClass(Produit.class);

config.setProperty(
"hibernate.connection.driver_class",
"com.mysql.jdbc.Driver"
);
config.setProperty(
"hibernate.connection.url",
"jdbc:mysql://localhost:3306/stock"
);
config.setProperty(
"hibernate.connection.username",
"root"
);
config.setProperty(
"hibernate.dialect",
"org.hibernate.dialect.MySQLDialect"
);

L’instruction :

config.configure().addClass(Produit.class);

On peut aussi être réalisée en précisant plutot le fichier de mapping :

config.configure().addResource("Produit.hbm.xml");

Ces instructions remplacent la configuration suivante dans le fichier de

configuration XML :

<mapping resource="com/acs/lab/hibernate/Produit.hbm.xml" />

Copyright © ACS TechnoCenter / N. Chenfour, Tel : 06 63 05 10 39, email : [email protected] 49

5.3 Classes persistantes

Les classes persistantes sont les classes d'une application qui

implémentent les entités d'un problème métier (exemple : Produit, Client,
Facture, etc.). Toutes les instances d'une classe persistante ne sont pas
forcément dans l'état persistant - au lieu de cela, une instance peut être
éphémère (NdT : transient) ou détachée.
Une instance de classe persistante peut être dans l’un de trois états :
passager (ou transient), persistant ou détaché. Ces états sont
mesurés par rapport à ce qu’on appelle un « contexte de
persistance ». Celui-ci n’est rien d’autre que l’instance de la classe
Session à travers laquelle toutes les opérations de persistances se
réalisent.

• Règles de conception d’une classe persistante

Quatre règles sont à respecter généralement :

1. la classe doit disposer d’un constructeur sans paramètre
2. Fournir une propriété d'indentifiant
Cette proprété optionnelle, appelée généralement id de type long
(ou de préférence Long), devrait correspondre à la clé primaire de la
table associée.
3. Classe non « final » (Optionnel)
4. fournir des accesseurs pour les propriétés persistantes (Optionnel)

Copyright © ACS TechnoCenter / N. Chenfour, Tel : 06 63 05 10 39, email : [email protected] 50

• Exemple de classes persistantes :

public class Produit {

private Long id;

private String ref;

private String desig;
private double pu;
private double qs;

public Produit() {
}

// autres constructeurs
// …

public Long getId() {

return id;
}
public void setId(Long id) {
this.id = id;
}
public String getRef() {
return ref;
}
public void setRef(String ref) {
this.ref = ref;
}
public String getDesig() {
return desig;
}
public void setDesig(String desig) {
this.desig = desig;
}
public double getPu() {
return pu;
}
public void setPu(double pu) {
this.pu = pu;
}
public double getQs() {
return qs;
}
public void setQs(double qs) {
this.qs = qs;
}
}

Copyright © ACS TechnoCenter / N. Chenfour, Tel : 06 63 05 10 39, email : [email protected] 51

5.4 Etats des instances des classes persistantes

• Etat Passager (Transient)

Dans ce cas l'instance n’a pas encore été associée à un contexte de

persistance. En d’autre terme, on n’a pas encore appelé la méthode
« save » sur l’instance (ou une méthode de récupération par exemple

« get ou load»). Dans ce cas, elle n’a pas encore de valeur pour sa clé
primaire (si une clé « id » est prévue). On dit alors que l’instance ne
possède pas d’identité persistante.

• Etat Persistant

Dans ce cas, l’instance est associée au contexte de persistance. Elle

possède une identité persistante (valeur de clé primaire) et elle peut donc
correspondre à un tuple de la base de données. Pour un contexte de
persistance particulier, Hibernate garantit que l’identité persistante est
équivalente à l'identité Java (emplacement mémoire de l'objet)

• Etat Détaché

Cet état correspond à une instance qui a déjà été associé à un contexte de
persistance, mais le contexte a été fermé ou il a été détaché explicitement
(appel à la méthode « evict() »). L’instance dispose donc d’une identité
persistante, mais qui risque de ne plus être valable (dans le cas d’un
changement de session par exemple).

Copyright © ACS TechnoCenter / N. Chenfour, Tel : 06 63 05 10 39, email : [email protected] 52

5.5 L’objet Session

• Création d’une session

Configuration config = new Configuration();

SessionFactory sessionFactory;

sessionFactory = config.configure().buildSessionFactory();

• Ouverture d’une session

Session session = sessionFactory.openSession();

• Transaction

session.beginTransaction();

traitement() ;
// valider la transaction

session.getTransaction().commit();

pour annuler :

session.getTransaction().rollback();

• Fermeture de la session

session.close

Copyright © ACS TechnoCenter / N. Chenfour, Tel : 06 63 05 10 39, email : [email protected] 53

5.5 Fonctions de manipulation des objets persistants

Soit un objet « session » de la classe session

Et « p » un objet persistant (classe Produit par exemple)

• Méthodes de sauvegarde

1. session.save(p); ou bien session.persist(p);

2. session.saveOrUpdate(p); ou bien session.merge(p);

3. session.update(p);

4. session.flush() ; // MAJ provoquée

Exemple :
void exp01() {
Produit p = new Produit("C07", "Stylo", 20, 100);
session.save(p);
System.out.println("OK! Sauvegarde bien effectuée...");
}

void exp02() {
Produit p = new Produit("C07", "Marqueur", 20, 100);
session.saveOrUpdate(p);
System.out.println("OK! Sauvegarde bien effectuée...");
}

void exp03() {
Produit p = (Produit)session.get(Produit.class, "C02");
session.evict(p);
p.setDesig("Clavier");
session.update(p);
p.setPu(250);
}

Copyright © ACS TechnoCenter / N. Chenfour, Tel : 06 63 05 10 39, email : [email protected] 54

• Suppression

1. Méthode delete()

session.delete(p);

Exemple :
void exp04() {
Produit p = (Produit)session.get(Produit.class, "C02");
Session.delete(p);
}

void exp05() {
session.delete(new Produit("C07"));
}

2. Méthode clear()

La méthode « clear() » permet d’effacer de la session tous les objets

contenus dans celle-ci. Elle permet aussi d’avorter toutes les autres
opérations de mise à jour.

En plus pour les objets non encore enregistrés dans la base de données,
ils ne le seront pas lors de l’opération « commit() » sur la transaction.

Sauf si un appel explicit à la fonction « flush() » a été effectué avant

l’appel à « clear() »

Copyright © ACS TechnoCenter / N. Chenfour, Tel : 06 63 05 10 39, email : [email protected] 55

Exemple :
void exp06() {
Produit p = new Produit("C100", "NouveauProduit", 20, 100);
session.save(p);
session.load(Produit.class, "C01");
session.clear();
System.out.println("p1 = " + session.contains(p1));
System.out.println("p2 = " + session.contains(p2));
}

Resultat :
p1 = false

p2 = false

Remarque 1 :

Les objets issus de la base ne seront plus attachés à la session après un

appel à la méthode « clear() ». En plus toute opération de mise à jour
sur ces objets se terminera en erreur.

Exemple :
void exp07() {
Produit p1 = (Produit)session.get(Produit.class, "C01");
session.clear();
p1.setDesig(p1.getDesig()+"-001"); Î Erreur
}

Resultat :
ERROR - could not initialize proxy - no Session
org.hibernate.LazyInitializationException: could not initialize proxy - no
Session
...

Copyright © ACS TechnoCenter / N. Chenfour, Tel : 06 63 05 10 39, email : [email protected] 56

Remarque 2 :

Pour remettre un objet dans la session vidée, il suffira d’appeler la

méthode « refresh() » sur celui-ci, après quoi toutes les opération de mise
à jour sur l’objets redeviendront possibles.
void exp08() {
Produit p1 = (Produit)session.get(Produit.class, "C01");
session.clear();
...
session.refresh(p1);
p1.setDesig(p1.getDesig()+"-001"); Î MAJ. effectuée
}

• Récupération d’objets

P = (ClassePersistante) session.get(ClassePersistante.class, clé);

Ou bien
P = (ClassePersistante) session.load(ClassePersistante.class, clé);

La méthode « get » retourne « null » si l’objet est introuvable, alors que

la méthode « load » déclenche une erreur.

Exemple :

void exp09() {
Produit p = (Produit)session.get(Produit.class, "C01");
System.out.println(p);
}

Copyright © ACS TechnoCenter / N. Chenfour, Tel : 06 63 05 10 39, email : [email protected] 57

Remarque :

Pour déterminer si un objet est contenu ou pas dans la session (et donc
dans la base de données), on pourra utiliser la méthode : contains :

Syntaxe :

If (session.contains(objetPersistant) ) ...

Exemple :
void exp10 () {
Produit p = new Produit("C09", "Table", 20, 100);
session.persist(p);
...
if (session.contains(p)) {;
System.out.println("Existe");
}
else {
System.out.println("N'existe pas");
}
}

Copyright © ACS TechnoCenter / N. Chenfour, Tel : 06 63 05 10 39, email : [email protected] 58

• Méthodes de synchronisation

1. La méthode flush()

Elle permet de reporter tous les changements (ajout, suppression,

modification) sur la base de données. Ce qui permettra de synchroniser la
session avec la base de données dans le sens : Session Æ Database.

Syntaxe :

session.flush() ;

Remarque :

La synchronisation est, le cas échéant, réalisée lors d’un appel à commit()

sur l’objet Transaction.

session.getTransaction().commit();

2. La méthode refresh()

Elle permet de mettre à jour un objet persistant « attaché à la session »

en fonction ne nouvelles modifications sur la base de données. Ce qui
permettra encore de synchroniser la base de données avec la session mais
dans le sens : Database Æ Session.

Syntaxe :

session.refresh(objetPersistant) ;

Copyright © ACS TechnoCenter / N. Chenfour, Tel : 06 63 05 10 39, email : [email protected] 59

Exemple1 : Sans utilisation de refresh() :
void exp11() {
Produit p = (Produit)session.load(Produit.class, "C01");
System.out.println("avant : " + p);

String q = "update Produit set qs=0 where ref='C01'";

session.createSQLQuery(q).executeUpdate();
System.out.println("après : " + p);
}

Résultat :

avant : {C01, Clavier, 30.5, 10.0}

après : {C01, Clavier, 30.5, 10.0}

Exemple2 : Avec utilisation de refresh() :

void exp12() {
Produit p = (Produit)session.load(Produit.class, "C01");
System.out.println("avant : " + p);

String q = "update Produit set qs=0 where ref='C01'";

session.createSQLQuery(q).executeUpdate();
session.refresh(p) ;
System.out.println("après : " + p);
}

Résultat :

avant : {C01, Clavier, 30.5, 10.0}

après : {C01, Clavier, 30.5, 0.0}

Copyright © ACS TechnoCenter / N. Chenfour, Tel : 06 63 05 10 39, email : [email protected] 60

 3. La méthode isDirty()

Détermine si la session est synchrone avec la base de données :

Exemple :
void exp13() {
Produit p = (Produit)session.get(Produit.class, "C01");
System.out.println(p + " : " + session.isDirty());
p.setQs(p.getQs()+10);
System.out.println(p+ " : " + session.isDirty());
}

Résultat :

{C01, Clavier, 30.5, 0.0} : false

{C01, Clavier, 30.5, 10.0} : true

4. La méthode evict() ;

Cette méthode permet de détacher un objet de la session, ce qui

permettra de le modifier sans que les nouveaux changements soit
reportés sur la base de données.

Syntaxe :

session.evict(objetPersistant) ;

Remarque :

Pour rattacher l’objet à la session (avec mise à jour de celle-ci), il suffit

d’appeler la méthode « update() » sur l’objet.

Copyright © ACS TechnoCenter / N. Chenfour, Tel : 06 63 05 10 39, email : [email protected] 61

Exemple :

void exp14() {
Produit p = (Produit)session.get(Produit.class, "C01");
session.evict(p);
p.setDesig(p.getDesig() + "-001");
...
session.update(p);
}

• Gestion des transactions

1. Début d’une transaction

session.beginTransaction();

2. Récupérer la transaction en cours

Transaction t = session.getTransaction() ;

2. Valider les opérations d’une transaction

session.getTransaction().commit();

3. Annuler les opérations d’une transaction

session.getTransaction().rollback();

Copyright © ACS TechnoCenter / N. Chenfour, Tel : 06 63 05 10 39, email : [email protected] 62

• Requêtes SQL

Syntaxe :

SQLQuery SQL = session.createSQLQuery("une requête");

L’objet retourné « SQLQuery » appartient au package

« org.hibernate »

1. Requête SELECT :

Exemple :
void exp15() {
String query = "select * from produit";
SQLQuery SQL = session.createSQLQuery(query);
SQL.addEntity(Produit.class);

List<Produit> list = SQL.list();

for (Produit p : list) {
System.out.println(p);
}
}

2. Requêtes de mise à jour :

Exemple :
void exp16() {
String query = "update Produit set qs=0 where ref='C01'";
SQLQuery SQL = session.createSQLQuery(query);
SQL.executeUpdate();
}

Copyright © ACS TechnoCenter / N. Chenfour, Tel : 06 63 05 10 39, email : [email protected] 63

3. Requêtes DDL :

Exemple :
void exp17() {
String query = "create table client(…)";
SQLQuery SQL = session.createSQLQuery(query);
SQL.executeUpdate();
}

• Requêtes HQL

Syntaxe :

Query query = session.createQuery("requête");

L’objet retourné « Query » appartient au package « org.hibernate »

Exemple :

void exp18() {
Query query = session.createQuery("from Produit");
List<Produit> produits = query.list();
for (Produit p : produits) {
System.out.println(p);
}
}

Remarque :

Pour plus de détails sur les requêtes HQL, voir le chapitre 8.

Copyright © ACS TechnoCenter / N. Chenfour, Tel : 06 63 05 10 39, email : [email protected] 64

Copyright © ACS TechnoCenter / N. Chenfour, Tel : 06 63 05 10 39, email : [email protected] 65
Chapitre 6. Mapping à l’aide
d’une configuration XML

6.1 Anatomie du fichier de Mapping

Un fichier des mapping a généralement la forme ci-dessous, mais il peut

être plus compliqué pour couvrir un certain nombre d’associations entre
les entités.

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package=”nomDuPackage”>
<class
name="NomDeLaClassePersistante"
table="NomDeLaTable"
>
<id
name="nomDeLaPropriétéId"
column="nomDeL’attrubutAssocié"
type="son type"
length="taille"
>
<generator class=” … ” />
</id>
<property
name=" nomDeLaPropriété"
column=" nomDeL’attrubutAssocié "
type=" son type "
not-null="true/false"
length="taille"
/>
…
</class>
</hibernate-mapping>

Copyright © ACS TechnoCenter / N. Chenfour, Tel : 06 63 05 10 39, email : [email protected] 66

6.2 L’élément <hibernate-mapping>

<hibernate-mapping
schema="…"
catalog="…"
default-cascade="…"
default-access="field|property|ClassName"
default-lazy="true|false"
auto-import="true|false"
package="…"
/>

(1) schema (optionnel) : Le nom d'un schéma de base de données.

(2) catalog (optionnel) : Le nom d'un catalogue de base de données.

(3) default-cascade (optionnel - par défaut vaut : none) : Un type de

cascade par défaut.

(4) default-access (optionnel - par défaut vaut : property) : Comment

hibernate accèdera aux propriétés. On peut aussi redéfinir sa propre
implémentation de PropertyAccessor.

(5) default-lazy (optionnel - par défaut vaut : true) : Valeur par défaut
pour un attribut lazy non spécifié : celui des mappings de classes et
de collection.

(6) auto-import (optionnel - par défaut vaut : true) : Spécifie si l'on peut
utiliser des noms de classes non qualifiés (des classes de ce mapping)
dans le langage de requête.

(7) package (optionnel) : Préfixe de package par défaut pour les noms de
classe non qualifiés du document de mapping.

Si deux classes possèdent le même nom de classe (non qualifié), vous

devez indiquer auto-import="false". Hibernate lancera une exception si
vous essayez d'assigner à deux classes le même nom importé.

Copyright © ACS TechnoCenter / N. Chenfour, Tel : 06 63 05 10 39, email : [email protected] 67

6.3 L’élément <class>

Dans la documentation de référence de Hibernate (voir ci-dessous),

l’élément <class> est caractérisé par plusieurs attributs, mais nous nous
contentons généralement de ce qui a été présenté dans le premier
paragraphe de ce chapitre :

Extrait de la documentation de référence :

<class
name="ClassName" (1)
table="tableName" (2)
discriminator-value="discriminator_value" (3)
mutable="true|false" (4)
schema="owner" (5)
catalog="catalog" (6)
proxy="ProxyInterface" (7)
dynamic-update="true|false" (8)
dynamic-insert="true|false" (9)
select-before-update="true|false" (10)
polymorphism="implicit|explicit" (11)
where="arbitrary sql where condition" (12)
persister="PersisterClass" (13)
batch-size="N" (14)
optimistic-lock="none|version|dirty|all" (15)
lazy="true|false" (16)
entity-name="EntityName" (17)
check="arbitrary sql check condition" (18)
rowid="rowid" (19)
subselect="SQL expression" (20)
abstract="true|false" (21)
node="element-name"
/>

Copyright © ACS TechnoCenter / N. Chenfour, Tel : 06 63 05 10 39, email : [email protected] 68

(1) name (optionnel) : Le nom Java complet de la classe (ou interface) persistante. Si cet
attribut est absent, il est supposé que ce mapping ne se rapporte pas à une entité POJO.
(2) table (optionnel - par défaut le nom (non-qualifié) de la classe) : Le nom de sa table en
base de données.
(3) discriminator-value (optionnel - par défaut le nom de la classe) : Une valeur
permettant de distinguer les sous-classes dans le cas de l'utilisation du polymorphisme.
Les valeurs null et not null sont autorisées.
(4) mutable (optionnel, vaut true par défaut) : Spécifie que des instances de la classe sont
(ou non) immuables.
(5) schema (optional): Override the schema name specified by the root <hibernate-
mapping> element.

(6) catalog (optional): Override the catalog name specified by the root <hibernate-
mapping> element.

(7) proxy (optionnel) : Spécifie une interface à utiliser pour l'initialisation différée (lazy
loading) des proxies. Vous pouvez indiquer le nom de la classe elle-même.
(8) dynamic-update (optionnel, par défaut à false) : Spécifie que les UPDATE SQL doivent
être générés à l'exécution et contenir uniquement les colonnes dont les valeurs ont été
modifiées.
(9) dynamic-insert (optionnel, par défaut à false): Spécifie que les INSERT SQL doivent
être générés à l'exécution et ne contenir que les colonnes dont les valeurs sont non
nulles.
(10) select-before-update (optionnel, par défaut à false): Spécifie que Hibernate ne doit
jamais exécuter un UPDATE SQL sans être certain qu'un objet a été réellement modifié.
Dans certains cas, (en réalité, seulement quand un objet transient a été associé à une
nouvelle session par update()), cela signifie que Hibernate exécutera un SELECT SQL
pour s'assurer qu'un UPDATE SQL est véritablement nécessaire.
(11) polymorphism (optionnel, vaut implicit par défaut) : Détermine si, pour cette classe,
une requête polymorphique implicite ou explicite est utilisée.
(12) where (optionnel) spécifie une clause SQL WHERE à utiliser lorsque l'on récupère des
objets de cette classe.
(13) persister (optionnel) : Spécifie un ClassPersister particulier.
(14) batch-size (optionnel, par défaut = 1) : spécifie une taille de batch pour remplir les
instances de cette classe par identifiant en une seule requête.
(15) optimistic-lock (optionnel, par défaut = version) : Détermine la stratégie de verrou
optimiste.
(16) lazy (optionnel) : Déclarer lazy="true" est un raccourci pour spécifier le nom de la
classe comme étant l'interface proxy.
(17) entity-name (optionnel) : Hibernate3 permet à une classe d'être mappée plusieurs fois
(potentiellement à plusieurs tables), et permet aux mappings d'entité d'être représentés

Copyright © ACS TechnoCenter / N. Chenfour, Tel : 06 63 05 10 39, email : [email protected] 69

 par des Maps ou du XML au niveau Java. Dans ces cas, vous devez indiquer un nom
explicite arbitraire pour les entités.
(18) check (optionnel) : expression SQL utilisée pour générer une contrainte de vérification
multi-lignes pour la génération automatique de schéma.
(19) rowid (optionnel) : Hibernate peut utiliser des ROWID sur les bases de données qui
utilisent ce mécanisme. Par exemple avec Oracle, Hibernate peut utiliser la colonne
additionnelle rowid pour des mises à jour rapides si cette option vaut rowid. Un
ROWID représente la localisation physique d'un tuple enregistré.
(20) subselect (optionnel) : Permet de mapper une entité immuable en lecture-seule sur un
sous-select de base de données. Utile pour avoir une vue au lieu d'une table en base,
mais à éviter. Voir plus bas pour plus d'information.
(21) abstract (optionnel) : Utilisé pour marquer des superclasses abstraites dans des
hiérarchies de <union-subclass>.

Il est tout à fait possible d'utiliser une interface comme nom de classe persistante. Vous devez
alors déclarer les classes implémentant cette interface en utilisant l'élément <subclass>.
Vous pouvez faire persister toute classe interne static. Vous devez alors spécifier le nom de la
classe par la notation habituelle des classes internes c'est à dire eg.Foo$Bar.

Les classes immuables, mutable="false", ne peuvent pas être modifiées ou supprimées par
l'application. Cela permet à Hibernate de faire quelques optimisations mineures sur les
performances.

Copyright © ACS TechnoCenter / N. Chenfour, Tel : 06 63 05 10 39, email : [email protected] 70

6.4 Définition d’un identificateur

Les classes mappées doivent déclarer la clé primaire de la table. La

plupart des classes auront aussi une propriété de type javabean
présentant l'identifiant unique d'une instance. L'élément <id> sert à
définir le mapping entre cette propriété et la clé primaire dans la base.

<id
name="propertyName" (1)
type="typename" (2)
column="column_name" (3)
unsaved-value="null|any|none|undefined|id_value" (4)
access="field|property|ClassName"> (5)

<generator class="generatorClass"/>
</id>

(1) name (optionnel) : Nom de la propriété qui sert d'identifiant.

(2) type (optionnel) : Nom indiquant le type Hibernate.
(3) column (optionnel - le nom de la propriété est pris par défaut) : Nom
de la clef primaire.
(4) unsaved-value (optionnel - par défaut une valeur "bien choisie") : Une
valeur de la propriété d'identifiant qui indique que l'instance est
nouvellement instanciée (non sauvegardée), et qui la distingue des
instances transients qui ont été sauvegardées ou chargées dans une
session précédente.
(5) access (optional - defaults to property): The strategy Hibernate
should use for accessing the property value.

Si l'attribut name est absent, Hibernate considère que la classe ne

possède pas de propriété identifiant.

L'attribut unsaved-value est important ! Si l'identifiant de votre classe n'a

pas une valeur par défaut compatible avec le comportement standard de
Java (zéro ou null), vous devez alors préciser la valeur par défaut.

La déclaration alternative <composite-id> permet l'acccès aux données

d'anciens systèmes qui utilisent des clefs composées. Son utilisation est
fortement déconseillée pour d'autres cas.

Copyright © ACS TechnoCenter / N. Chenfour, Tel : 06 63 05 10 39, email : [email protected] 71

6.5 l’élément <générator>

L'élément fils <generator> nomme une classe Java utilisée pour générer
les identifiants uniques pour les instances des classes persistantes. Si des
paramètres sont requis pour configurer ou initialiser l'instance du
générateur, ils sont passés en utilisant l'élément <param>.

<id name="id" type="long" column="…">

<generator class="org.hibernate.id.TableHiLoGenerator">

<param name="table">uid_table</param>

<param name="column">next_hi_value_column</param>

</generator>

</id>

Tous les générateurs implémente l’interface suivante :

« org.hibernate.id.IdentifierGenerator »

Voici une liste de générateurs possibles (documentation de référence) :

increment

Génère des identifiants de type long, short ou int qui ne sont

uniques que si aucun autre processus n'insère de données dans la
même table. Ne pas utiliser en environnement clusterisé.

identity

Utilisation de la colonne identity de DB2, MySQL, MS SQL Server,

Sybase et HypersonicSQL. L'identifiant renvoyé est de type long,
short ou int.

sequence

Utilisation des séquences dans DB2, PostgreSQL, Oracle, SAP DB,

McKoi ou d'un générateur dans Interbase. L'identifiant renvoyé est
de type long, short ou int

Copyright © ACS TechnoCenter / N. Chenfour, Tel : 06 63 05 10 39, email : [email protected] 72

hilo

Utilise un algorithme hi/lo pour générer de façon efficace des

identifiants de type long, short ou int, en prenant comme source de
valeur "hi" une table et une colonne (par défaut
hibernate_unique_key et next_hi respectivement). L'algorithme hi/lo
génère des identifiants uniques pour une base de données
particulière seulement.

seqhilo

Utilise un algorithme hi/lo pour générer efficacement des identifiants

de type long, short ou int, étant donné un nom de séquence en
base.

uuid

Utilise un algorithme de type UUID 128 bits pour générer des

identifiants de type string, unique au sein d'un réseau (l'adresse IP
est utilisée). Le UUID en codé en une chaîne de nombre
héxadécimaux de longueur 32.

guid

Utilise une chaîne GUID générée par la base pour MS SQL Server et
MySQL.

native

Choisit identity, sequence ou hilo selon les possibilités offertes par la

base de données sous-jacente.

assigned

Laisse l'application affecter un identifiant à l'objet avant que la

métode save() soit appelée. Il s'agit de la stratégie par défaut si
aucun <generator> n'est spécifié.

select

Récupère une clef primaire assignée par un trigger en sélectionnant

la ligne par une clef unique quelconque.

foreign

Utilise l'identifiant d'un objet associé. Habituellement utilisé en

conjonction avec une association <one-to-one> sur la clef primaire.

Copyright © ACS TechnoCenter / N. Chenfour, Tel : 06 63 05 10 39, email : [email protected] 73

6.6 L’élément <property>

L’élément <property> permlettant de mapper une propriété d’objet

persistant à un attribut de table est définit par plusieurs propriétés telles
que indiquées dans la documentation de référence est caractérisé comme
suit:

<property
name="propertyName" (1)
column="column_name" (2)
type="typename" (3)
update="true|false" (4)
insert="true|false" (4)
formula="arbitrary SQL expression" (5)
access="field|property|ClassName" (6)
lazy="true|false" (7)
unique="true|false" (8)
not-null="true|false" (9)
optimistic-lock="true|false" (10)
generated="never|insert|always" (11)
node="element-name|@attribute-name|element/@attribute|."
index="index_name"
unique_key="unique_key_id"
length="L"
precision="P"
scale="S"
/>

Copyright © ACS TechnoCenter / N. Chenfour, Tel : 06 63 05 10 39, email : [email protected] 74

(1) name : nom de la propriété, avec une lettre initiale en minuscule.

(2) column (optionnel - par défaut au nom de la propriété) : le nom de la colonne mappée.
Cela peut aussi être indiqué dans le(s) sous-élément(s) <column>.
(3) type (optionnel) : nom indiquant le type Hibernate.

(4) update, insert (optionnel - par défaut à true) : indique que les colonnes mappées
devraient être incluses dans des UPDATE SQL et/ou des INSERT. Mettre les deux à false
empêche la propagation en base de données (utile si vous savez qu'un trigger affectera la
valeur à la colonne).
(5) formula (optionnel) : une expression SQL qui définit la valeur pour une propriété
calculée. Les propriétés calculées ne possède pas leur propre mapping.
(6) access (optional - defaults to property): The strategy Hibernate should use for
accessing the property value.
(7) lazy (optionnel - par défaut à false): Indique que cette propriété devrait être chargée
en différé (lazy loading) quand on accède à la variable d'instance pour la première fois.
(8) unique (optionnel): Génère le DDL d'une contrainte d'unicité pour les colonnes. Permet
aussi d'en faire la cible d'un property-ref.
(9) not-null (optionnel): Génère le DDL d'une contrainte de non nullité pour les colonnes.

(10) optimistic-lock (optionnel - par défaut à true): Indique que les mises à jour de cette
propriété peuvent ou non nécessiter l'acquisition d'un verrou optimiste. En d'autres
termes, cela détermine s'il est nécessaire d'incrémenter un numéro de version quand
cette propriété est marquée obsolète (dirty).
(11) generated (optional - défaut ànever): Indique que la valeur de ce timestamp est
générée par la base de données.
typename peut être:

• Nom d'un type basique Hibernate (ex: integer, string, character, date,
timestamp, float, binary, serializable, object, blob).
• Nom d'une classe Java avec un type basique par défaut (ex: int, float, char,
java.lang.String, java.util.Date, java.lang.Integer, java.sql.Clob).
• Nom d'une classe Java sérialisable.
• Nom d'une classe ayant un type spécifique (ex: com.illflow.type.MyCustomType).

Si vous n'indiquez pas un type, Hibernate utlisera la réflexion sur le nom de la propriété pour
tenter de trouver le type Hibernate correct. Hibernate essayera d'interprêter le nom de la classe
retournée par le getter de la propriété en utilisant les régles 2, 3, 4 dans cet ordre. Cependant,
ce n'est pas toujours suffisant. Dans certains cas vous aurez encore besoin de l'attribut type
(Par exemple, pour distinguer Hibernate.DATE et Hibernate.TIMESTAMP, ou pour préciser
un type spécifique).

Copyright © ACS TechnoCenter / N. Chenfour, Tel : 06 63 05 10 39, email : [email protected] 75

6.6 Les associations

6.6.1 Ensembles et Association « many-to-many »

Nous ajoutons à notre classe exemple, une nouvelle classe « Facture »

dont le code est définie ci-dessus. Une facture peut contenir plusieurs
produits et un produit peut être référencé par plusieurs factures. C’est une
association « many-to-many »

package com.acs.formations.hibernate;

import java.util.Date;
import java.util.HashSet;
import java.util.Set;

public class Facture {

private Long num;
private Date date;
private Set produits;

public Facture(Date date) {

super();
this.date = date;
produits = new HashSet<Produit>();
}

public Facture() {
produits = new HashSet<Produit>();
}

public String toString() {

return "{" + num + " : " + produits + "}";
}

public void addProduit(Produit p) {

produits.add(p);
}

//getters et setters pour toues les propriétés

// …

Copyright © ACS TechnoCenter / N. Chenfour, Tel : 06 63 05 10 39, email : [email protected] 76

Facture.hbm.xml
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="com.acs.formations.hibernate">
<class name="Facture">
<id
name="num"
type="long"
>
<generator class="native"></generator>
</id>
<property
name="date"
type="date"
not-null="true"
/>
<set name="produits" table="achat">
<key
column="facture"
foreign-key="fk_produit_facture"
/>
<many-to-many class="Produit"
column="produit"
foreign-key="fk_facture_produit"
/>
</set>
</class>
</hibernate-mapping>

Copyright © ACS TechnoCenter / N. Chenfour, Tel : 06 63 05 10 39, email : [email protected] 77

Exemples :

void exp01() {
Produit p1 = new Produit("P01", "Clavier", 200, 10);
Produit p2 = new Produit("P02", "Ecran", 1200, 5);
Facture f = new Facture(new Date(2009, 3, 2));
f.addProduit(p1);
f.addProduit(p2);

getSession().saveOrUpdate(p1);
getSession().saveOrUpdate(p2);

getSession().save(f);
System.out.println("OK!!");
}

void exp02() {
Facture f = (Facture)getSession().get(Facture.class,
new Long(1));
System.out.println(f);
}

void exp03() {
Produit p1 = (Produit)getSession().get(Produit.class, "P02");
Facture f = new Facture(new Date(2009, 3, 2));
f.addProduit(p1);

getSession().save(f);
System.out.println("OK!! : " + f);
}

Copyright © ACS TechnoCenter / N. Chenfour, Tel : 06 63 05 10 39, email : [email protected] 78

Un autre exemple sans donner de valeurs aux associations :

void exp04() {
Facture f = new Facture(new Date(2009, 3, 2));

getSession().save(f);
System.out.println("OK!! : " + f);
}

void exp05() {
Facture f = (Facture)getSession().get(Facture.class, new
Long(4));
System.out.println("OK!! : " + f);
}

void exp06() {
Facture f = (Facture)getSession().get(Facture.class, new
Long(4));
Produit p1 = (Produit)getSession().get(Produit.class, "P02");
f.addProduit(p1);

System.out.println("OK!! : " + f);

}

Copyright © ACS TechnoCenter / N. Chenfour, Tel : 06 63 05 10 39, email : [email protected] 79

6.6.2 Association « many-to-one »

Ajoutons la classe client et faisant la liaison avec les factures. Une facture
appartient à un et un seul client. Un client peut avoir plusieurs factures.

public class Client {

private Long id;

private String nom;

private String prenom;
private String adresse;

public Client() {
super();
}

public Client(String nom, String prenom) {

super();
this.nom = nom;
this.prenom = prenom;
}

public Client(String nom, String prenom, String adresse) {

this.nom = nom;
this.prenom = prenom;
this.adresse = adresse;
}

// getters et setters pour toues les propeiétés

//…

@Override
public String toString() {
return "Client N° " + id + " (" + nom + " " + prenom + " : "
+ adresse + ")";
}
}

Copyright © ACS TechnoCenter / N. Chenfour, Tel : 06 63 05 10 39, email : [email protected] 80

Ajoutons un champ client dans la classe facture et redéfinissons la
méthode toString() pour prendre en compte l’affichage du client :

Public class Facture {

...
private Client client;
...
public Client getClient() {
return client;
}

public void setClient(Client client) {

this.client = client;
}
...
public String toString() {
return "{" + num + " " + client + " : " + produits + "}";
}

Dans le fichier de mapping « facture.hbm.xml » s’ajoute la définition de

l’association :

<many-to-one
name="client"
class="Client"
foreign-key="fk_facture_client"
/>

Copyright © ACS TechnoCenter / N. Chenfour, Tel : 06 63 05 10 39, email : [email protected] 81

Exemple :

void exp07() {
Facture f = new Facture(new Date(2009, 3, 2));
Client c = new Client("X", "Y");
Produit p1 = new Produit("P01", "Clavier", 200, 10);
Produit p2 = new Produit("P02", "Ecran", 1200, 5);
f.setClient(c);
f.addProduit(p1);
f.addProduit(p2);

// l’ordre est sans importance

getSession().save(f);
getSession().save(p1);
getSession().save(p2);
getSession().save(c);

System.out.println("OK!! : " + f);

}

Remarque :

L’extraction de la facture attache aussi le client et les produits Î un

changement quelconque sur ces entités sera enregistré automatiquement
dans la base de données après le « commit() »

void exp08() {
Facture f = (Facture)getSession().get(Facture.class,
new Long(1));
Client c = f.getClient();
c.setAdresse("Sidi Maarouf...");
System.out.println("OK!! : " + f);
}

Copyright © ACS TechnoCenter / N. Chenfour, Tel : 06 63 05 10 39, email : [email protected] 82

6.6.3 Association « one-to-one »

Une association « one-to-one » est réalisée de la même manière qu’une

association « many-to-one »

6.6.4 Association « one-to-many »

Ajoutons la classe Founisseur. Plusieurs produits sont assurés par un seul

fournisseur. On supposera qu’un même produit n’est assuré que par un et
un seul fournisseur Î une association « one-to-many ».

La classe « Fournisseur » est définie comme suit :

public class Fournisseur {

private Long id;

private String nom;

private String prenom;
private String adresse;
private Set<Produit> produits = new HashSet<Produit>();

public Fournisseur() {}
public Fournisseur(String nom, String prenom) {
this.nom = nom;
this.prenom = prenom;
}
public Fournisseur(String nom, String prenom, String adresse) {
this.nom = nom;
this.prenom = prenom;
this.adresse = adresse;
}
public void addProduit(Produit p) {
produits.add(p);
}
public String toString() {
return "Fourisseur N° " + id + " (" + nom + " " + prenom
+ " : " + adresse + ") : " + produits;
}

// getters et setters pour toutes les propriétés

}

Copyright © ACS TechnoCenter / N. Chenfour, Tel : 06 63 05 10 39, email : [email protected] 83

Fournisseur.hbm.xml

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="com.acs.formations.hibernate">
<class name="Fournisseur">
<id
name="id"
type="long"
>
<generator class="increment"></generator>
</id>
<property name="nom" length="20"/>
<property name="prenom" length="20"/>
<property name="adresse" length="60"/>
<set name="produits">
<key
column="fournisseur"
foreign-key="fk_produit_fournisseur"
/>
<one-to-many class="Produit" />
</set>
</class>
</hibernate-mapping>

Ne pas oublier d’ajouter les mapping au niveau du fichier de configuration

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE hibernate-configuration PUBLIC
"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
<session-factory>

...
<mapping resource="com/acs/formations/hibernate/Produit.hbm.xml" />
<mapping resource="com/acs/formations/hibernate/Facture.hbm.xml" />
<mapping resource="com/acs/formations/hibernate/Client.hbm.xml" />
<mapping resource="com/acs/formations/hibernate/Fournisseur.hbm.xml" />
</session-factory>
</hibernate-configuration>

Copyright © ACS TechnoCenter / N. Chenfour, Tel : 06 63 05 10 39, email : [email protected] 84

Le schéma de la base de données devient comme suit :

Copyright © ACS TechnoCenter / N. Chenfour, Tel : 06 63 05 10 39, email : [email protected] 85

Exemples :

void exp09() {
Fournisseur f = new Fournisseur("X", "Y");
Produit p1 = new Produit("P01", "Clavier", 200, 10);
Produit p2 = new Produit("P02", "Ecran", 1200, 5);
f.addProduit(p1);
f.addProduit(p2);

getSession().save(f);
getSession().save(p1);
getSession().save(p2);

System.out.println("OK!! : " + f);

}

void exp10() {
Fournisseur f = (Fournisseur)getSession().get(Fournisseur.class,
new Long(1));
System.out.println("OK!! : " + f);
}

Copyright © ACS TechnoCenter / N. Chenfour, Tel : 06 63 05 10 39, email : [email protected] 86

Copyright © ACS TechnoCenter / N. Chenfour, Tel : 06 63 05 10 39, email : [email protected] 87
Chapitre 7. Mapping par les
annotations

7.1 Introduction au système de Mapping par Annotation

Avant le système d’annotation introduit par le JDK 5.0 vers la fin de

l’année 2004, le seul moyen de Mapping dans Hibernate était XML. Les
annotations sont une alternative au Mapping XML le dépassant par son
caractère intuitif, directement réalisé sur les classes de persistance et
beaucoup mois encombrante que les configuration XML.

La solution de mapping par annotation dans hibernate est issue de la

norme EJB 3. Ainsi, les classes persistantes configurées par annotation
représentent directement des entités pour un environnement EJB 3 et
peuvent alors directement injectées dans un projet EJB 3.

7.2 Configuration requise

Deux contraintes sont à assurer :

1. Ajouter un lien vers les bibliothèques suivantes :

hibernate-annotations.jar ejb3-persistence.jar hibernate-commons-annotations.jar

Issues du module des annotations :

Copyright © ACS TechnoCenter / N. Chenfour, Tel : 06 63 05 10 39, email : [email protected] 88

 2. Créer la session en se basant sur la classe
« AnnotationConfiguration » :

public void open() {

AnnotationConfiguration config = new AnnotationConfiguration();

SessionFactory factory = config.configure().buildSessionFactory();

session = factory.openSession();

session.beginTransaction();

7.3 Annotation simple d’une classe persistante

package com.acs.formations.hibernate;

import javax.persistence.Entity;
import javax.persistence.Id;

@Entity
public class Produit {

@Id
private String ref;

private String desig;

private double pu;

private double qs;

...

Copyright © ACS TechnoCenter / N. Chenfour, Tel : 06 63 05 10 39, email : [email protected] 89

Pour l’utilisation de Hibernate Tools, on crée une console de configuration
basée sur les annotations :

Copyright © ACS TechnoCenter / N. Chenfour, Tel : 06 63 05 10 39, email : [email protected] 90

Ajouter au fichier de configuration Hibernate le mapping vars la classe :

<hibernate-configuration>
<session-factory>

...

<mapping class="com.acs.formations.hibernate.Produit"/>
</session-factory>
</hibernate-configuration>

Un exemple de persistance ordinaire :

void exp01() {
Produit p1 = new Produit("P01", "Clavier", 200, 10);
Produit p2 = new Produit("P02", "Ecran", 1200, 5);
getSession().save(p1);
getSession().save(p2);
System.out.println("OK!!");
}

Copyright © ACS TechnoCenter / N. Chenfour, Tel : 06 63 05 10 39, email : [email protected] 91

7.4 Annotation @Table

@Entity
@Table(name="produits")
public class Produit {
@Id
private String ref="";
private String desig="";
private double pu=0;
private double qs=0;

Copyright © ACS TechnoCenter / N. Chenfour, Tel : 06 63 05 10 39, email : [email protected] 92

Ensuite :

On obtient :

Copyright © ACS TechnoCenter / N. Chenfour, Tel : 06 63 05 10 39, email : [email protected] 93

7.5 Annotation @GeneratedValue

@Entity
@Table(name="produits")
public class Produit {
@Id
@GeneratedValue
private Long id;

private String ref="";

private String desig="";
private double pu=0;
private double qs=0;

L’insertion de deux produits donnera :

1, 'Clavier', 200, 10, 'P01'
2, 'Ecran', 1200, 5, 'P02'

Un exemple de récupération d’un produit par sa clé :

void exp02() {

Produit p = (Produit)getSession().get(Produit.class,

new Long(1));

System.out.println("p = " + p);

@Entity

Copyright © ACS TechnoCenter / N. Chenfour, Tel : 06 63 05 10 39, email : [email protected] 94

7.5 Annotation @Column

@Entity
@Table(name="produits")
public class Produit {
@Id
@GeneratedValue
private Long id;

@Column(length=20, unique=true, nullable=false)

private String ref="";

@Column(length=30)
private String desig="";

@Column(name="prix")
private double pu=0;

@Column(name="quantite")
private double qs=0;

Copyright © ACS TechnoCenter / N. Chenfour, Tel : 06 63 05 10 39, email : [email protected] 95

7.5 Annotation @Transient pour exclure une propriété
de la persistance

@Table(name="produit")
public class Produit {
@Id
@GeneratedValue
private Long id;

@Column(length=20, unique=true, nullable=false)

private String ref="";

@Column(length=30)
private String desig="";

@Column(name="prix")
private double pu=0;

@Column(name="quantite")
private double qs=0;

@Transient
private double total;
}

Copyright © ACS TechnoCenter / N. Chenfour, Tel : 06 63 05 10 39, email : [email protected] 96

7.6 Association « many-to-many »

@Entity
public class Facture {
@Id
@GeneratedValue
private Long num;

private Date date;

@ManyToMany
private Set<Produit> produits;

Résultat :

Copyright © ACS TechnoCenter / N. Chenfour, Tel : 06 63 05 10 39, email : [email protected] 97

Un autre Exemple :

@Entity
public class Facture {
@Id
@GeneratedValue
private Long num;

private Date date;

@ManyToMany(cascade=CascadeType.ALL)
private Set<Produit> produits;

void exp03() {
Produit p1 = new Produit("P01", "Clavier", 200, 10);
Produit p2 = new Produit("P02", "Ecran", 1200, 5);
Facture f = new Facture(new Date(2009, 3, 2));
f.addProduit(p1);
f.addProduit(p2);

getSession().save(f);
System.out.println("OK!!");
}

! Suppression !!!!
void exp04() {
Facture f = (Facture)getSession().get(Facture.class,
new Long(1));

getSession().delete(f);
System.out.println("OK!!");
}

Copyright © ACS TechnoCenter / N. Chenfour, Tel : 06 63 05 10 39, email : [email protected] 98

7.7 Association « many-to-many » avec @JoinTable
@Entity
public class Facture {
@Id
@GeneratedValue
private Long num;

private Date date;

@ManyToMany(cascade=CascadeType.ALL)
@JoinTable(
name="achat",
joinColumns={@JoinColumn(name="facture")},
inverseJoinColumns={@JoinColumn(name="produit")}
)
private Set<Produit> produits;

Résultat :

Copyright © ACS TechnoCenter / N. Chenfour, Tel : 06 63 05 10 39, email : [email protected] 99

7.7 Association « many-to-one »
@Entity
public class Client {
@Id
private Long id;

private String nom;

private String prenom;
private String adresse;

@Entity
public class Facture {
@Id
@GeneratedValue
private Long num;

private Date date;

@ManyToMany(cascade=CascadeType.ALL)
@JoinTable(
name="achat",
joinColumns={@JoinColumn(name="facture")},
inverseJoinColumns={@JoinColumn(name="produit")}
)
private Set<Produit> produits;

@ManyToOne
Client client;

Copyright © ACS TechnoCenter / N. Chenfour, Tel : 06 63 05 10 39, email : [email protected] 100

Le Schéma résultant est le suivant :

7.7 Association « many-to-one » avec @JoinColumn

@ManyToOne
@JoinColumn(name="client")
Client client;

Résultat

Copyright © ACS TechnoCenter / N. Chenfour, Tel : 06 63 05 10 39, email : [email protected] 101

7.7 Association « one-to-many »
@Entity
public class Fournisseur {
@Id
private Long id;

private String nom;

private String prenom;
private String adresse;

@OneToMany
private Set<Produit> produits = new HashSet<Produit>();

Résultat

Copyright © ACS TechnoCenter / N. Chenfour, Tel : 06 63 05 10 39, email : [email protected] 102

7.7 Association « one-to-many » avec JoinColumn

@OneToMany
@JoinColumn(name="fournisseur")
private Set<Produit> produits = new HashSet<Produit>();

Le Schéma final de la base de données :

Copyright © ACS TechnoCenter / N. Chenfour, Tel : 06 63 05 10 39, email : [email protected] 103

Copyright © ACS TechnoCenter / N. Chenfour, Tel : 06 63 05 10 39, email : [email protected] 104
 Chapitre 8. Le Langage HQL

8.1 Introduction

Hibernate offre un langage de requêtes commun à toutes les bases de

données. Ce langage est nommé HQL acronyme de Hibernate Query
Language. Hibernate propose en plus d’autres façons d’interroger la
base de données soit avec du SQL natif à la base de données soit avec
l’API Criteria pour des requêtes par critères, soit par l’intermédiaire
de l’API JPA (Java Persistance API)

HQL est un langage de requêtes orientées objets, qui supporte l’héritage

et le polymorphisme. HQL utilise les classes et les propriétés au lieu
des tables et des colonnes. Il n’y a alors pas de référence aux tables et
aux champs car ceux-ci sont référencés indirectement par les classes
persistantes qui leurs sont associées. Ce sont ces derniers qui sont
interrogeable par HQL.

Le langage HQL permet de faire des jointures (inner, outer), des sous
requêtes etc. Il offre aussi la possibilité d’utiliser les expressions et les
fonctions (exemple : sum, count(), etc. )

Exemple de requêtes :

from Produit p where lower(p.desig) = 'clavier'

Copyright © ACS TechnoCenter / N. Chenfour, Tel : 06 63 05 10 39, email : [email protected] 105

8.2 Création et exécution de requêtes

Les requêtes HQL sont représentées par une instance de

« org.hibernate.Query ». Cette interface offre des implémentations
fournissant des méthodes pour la liaison des paramètres, la gestion des
ensembles de résultats, et pour l'exécution de la requête réelle. Une
requête est généralement exécutée en invoquant « list() », le résultat de
la requête sera chargée complètement dans une collection en mémoire.
Les instances d'entités récupérées par une requête sont dans un état
persistant. La méthode « uniqueResult() » offre un raccourci si vous
savez que votre requête retournere un seul objet.

Exemple 1 :

String req = "from Produit p where p.desig like '%QuelqueChose%'"

Query query = session.createQuery( req );

List list = query.list();

Exemple 2 :

String req = "from Produit p order by p.desig asc "

Query query = session.createQuery(req);

query.setMaxResults(5);

List list = query.list();

Copyright © ACS TechnoCenter / N. Chenfour, Tel : 06 63 05 10 39, email : [email protected] 106

Exemple 3 :

String req = "from Produit p where p.pu > 250 and desig like 'C%'";

Query query = session.createQuery(req);

List list = query.list();

8.3 Les expressions

Les expressions permises dans la clause where incluent la plupart des

possibilités habituelles avec SQL :

• opérateurs mathématiques +, -, *, /
• opérateur de comparaison binaire =, >=, <=, <>, !=, like
• opérateurs logiques and, or, not
• Parenthèses ( ), indiquant un regroupement
• in, not in, between, is null, is not null, is empty, is not empty,
member of and not member of
• "Simple" case, case ... when ... then ... else ... end, and
"searched" case, case when ... then ... else ... end
• concatenation de chaîne de caractères ...||... ou concat(...,...)
• current_date(), current_time(), current_timestamp()
• second(...), minute(...), hour(...), day(...), month(...), year(...),
• N'importe quel fonction ou opérateur défini par EJB-QL 3.0 :
substring(), trim(), lower(), upper(), length(), locate(), abs(),
sqrt(), bit_length(), mod()
• coalesce() et nullif()
• str() pour convertir des valeurs numériques ou temporelles vers
une chaîne de caractères lisible
• cast(... as ...), où le second argument est le nom d'un type
Hibernate, et extract(... from ...) si le cast() ANSI et extract()
sont supportés par la base de données sous-jacente

Copyright © ACS TechnoCenter / N. Chenfour, Tel : 06 63 05 10 39, email : [email protected] 107

 • La fonction HQL index(), qui s'applique aux alias d'une collection
indexée jointe
• Les fonctions HQL qui s'appliquent expressions représentant des
collections : size(), minelement(), maxelement(), minindex(),
maxindex(), ainsi que les fonctions spéciales elements() et
indices qui peuvent être quantifiées en utilisant some, all,
exists, any, in.
• N'importe quelle fonction scalaire supportée par la base de
données comme sign(), trunc(), rtrim(), sin()
• Les paramètres positionnels de JDBC ?
• paramètres nommés :name, :start_date, :x1
• littéral SQL 'foo', 69, '1970-01-01 10:00:01.0'
• Constantes Java public static finaleg.Color.TABBY
• in et between peuvent être utilisés comme suit :

8.4 utilisation de paramètres dans les requêtes

Des méthodes de Query sont fournies pour lier des valeurs à des
paramètres nommés ou à des paramètres de style JDBC. Contrairement à
JDBC, les numéros des paramètres d'Hibernate commencent à zéro. Les
paramètres nommés sont des identifiants de la forme :nom dans la
chaîne de caractères de la requête. Les paramètres nommés sont
insensibles à l'ordre de leur place dans la chaîne de la requête et ils
peuvent apparaître plusieurs fois dans la même requête

L’interface Query propose les setters qu’il faut pour associer à chaque
paramètre une valeur en fonction du type de la valeur (setInteger,
setString, etc). Chacune de ces méthodes possède 2 surcharges ; une
précisant le nom du paramètre et sa valeur, l’autre l’indice du paramètre
et sa valeur.

Copyright © ACS TechnoCenter / N. Chenfour, Tel : 06 63 05 10 39, email : [email protected] 108

Exemple :

String q = "from Produit where pu > :pu";

Query query = session.createQuery(q);

query.setDouble("pu", 250);

List list = query.list();

8.5 Itération des résultats

La classe Session propose une méthode « iterate() » qui renvoie un

itérateur (de type Iterator ) sur la collection des éléments trouvés.

Exemple :

String q ="from Client p where p.nom = :x";

Query query = session.createQuery(q);

query.setString("x","...");

Iterator p = query.iterate();

while (p.hasNext(); ) {

Client client = (Client) p.next();

Copyright © ACS TechnoCenter / N. Chenfour, Tel : 06 63 05 10 39, email : [email protected] 109

8.6 Accès aux métadonnées
Hibernate donne l’accès aux métadonnées via la méthode
« getClassMetadata() » de la « SessionFactory », qui peut être elle-même
obtenu depuis l’objet « Session ».

Exemple : Récupérer les noms des colonnes

ClassMetadata cm =
session.getSessionFactory().getClassMetadata(Produit.class);

String names[] = cm.getPropertyNames();

cm.getPropertyType(names[0]);

Remarque :

Les fonctionnalités HQL sont assez nombreuses, pour plus de détails se

référer au guide de référence Hibernate.

Copyright © ACS TechnoCenter / N. Chenfour, Tel : 06 63 05 10 39, email : [email protected] 110