Vous êtes sur la page 1sur 17

Mapping objet/relationnel

Hibernate O/R mapping

Un outil de mapping
objet/relationnel pour le monde Java

Yves Bekkers

Hibernate - Y. Bekkers 1 Hibernate - Y. Bekkers 2

Transparence de la persistence
Hibernate
Base de donnes + donnes de config = Sans Hibernate Avec Hibernate
service de persistance Mapping objet-relationnel
Persistance automatise et transparente SGBD
ddobjets
objets mtiers - classes Java - vers une
bases de donnes relationnelles SGBD

Description laide de mta-donnes de la Logique SQ


transformation rversible entre un modle mtier L

relationnel et un modle de classes Logique


mtier

Hibernate - Y. Bekkers 3 Hibernate - Y. Bekkers 4

Fichiers de configuration et de mapping


Faire le lien en Java entre
reprsentation objet des donnes et
reprsentation relationnelle base sur un schma SQL
Configuration d'Hibernate
Fichier
de
mapping

Description de la connection
Hibernate
JDBC

Instances dobjets Instances de relations


Fichier
Java *.cfg.xml
SGBDR

Hibernate - Y. Bekkers 5 Hibernate - Y. Bekkers 6

JDBC - Yves Bekkers 1


Configurer Hibernate Configurer par programme
Il y a trois manires deffectuer la Une instance de
configuration dHibernate pour une org.hibernate.cfg.Configuration
application
pp donne : reprsente
p un ensemble de mappings
pp g des
Par programme classes Java d'une application vers la base
Par un fichier de proprits de donnes SQL.
hibernate.properties Configuration cfg = new Configuration()
Par un document xml hibernate.cfg.xml .addResource("Item.hbm.xml")
.addResource("Bid.hbm.xml");

Hibernate - Y. Bekkers 7 Hibernate - Y. Bekkers 8

viter de cbler en dur dans le Prciser des proprits de


programme les noms de fichiers configuration par programme
Configuration cfg = new Configuration() Configuration cfg = new Configuration()
.addClass(org.hibernate.auction.Item.class) .addClass(org.hibernate.auction.Item.class)
.addClass(org.hibernate.auction.Bid.class)
.addClass(org.hibernate.auction.Bid.class);
.setProperty("hibernate.dialect",
Hibernate va rechercher les fichiers de mappings "org.hibernate.dialect.MySQLInnoDBDialect")
.setProperty("hibernate.connection.datasource
/org/hibernate/auction/Item.hbm.xml ", "java:comp/env/jdbc/test")
et .setProperty("hibernate.order_updates",
"true");
/org/hibernate/auction/Bid.hbm.xml
dans le classpath
Hibernate - Y. Bekkers 9 Hibernate - Y. Bekkers 10

Fichiers de proprits Exemple de document


hibernate.cfg.xml
Ce n'est pas le seul moyen de passer des proprits
de configuration Hibernate. Les diffrentes <!DOCTYPE hibernate-configuration PUBLIC
options sont : "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-
1. Passer une instance de java.util.Properties configuration-3.0.dtd">
Configuration.setProperties().
Co gu at o .set ope t es().
<hibernate-configuration>
2. Placer hibernate.properties dans un rpertoire racine du
<session-factory>
classpath
...
3. Positionner les proprits System en utilisant java -
</session-factory>
Dproperty=value.
</hibernate-configuration>
4. Inclure des lments <property> dans le fichier
hibernate.cfg.xml (voir plus loin).

Hibernate - Y. Bekkers 11 Hibernate - Y. Bekkers 12

JDBC - Yves Bekkers 2


hibernate.cfg.xml
hibernate.cfg.xml
(2) autres proprits
(1) connection la base
<!-- JDBC connection pool (use the built-in) -->
<property name="connection.driver_class"> <property name="connection.pool_size">1</property>
<!-- SQL dialect -->
org.hsqldb.jdbcDriver
<property name="dialect">
</property> org.hibernate.dialect.HSQLDialect
<property name="connection.url"> </property>
jdb h ldb fil
jdbc:hsqldb:film <!
<!-- Enable Hibernate's automatic session context management -->
>
<property name="current_session_context_class">thread</property>
</property>
<!-- Disable the second-level cache -->
<property name="connection.username">sa</property> <property name="cache.provider_class">
<property name="connection.password"></property> org.hibernate.cache.NoCacheProvider
</property>
<!-- Echo all executed SQL to stdout -->
<property name="show_sql">true</property>
<!-- Drop and re-create the database schema on startup -->
<property name="hbm2ddl.auto">create</property>

Hibernate - Y. Bekkers 13 Hibernate - Y. Bekkers 14

Types Java Types SQL


Java SGBD
1. Valeurs composes : entits persistantes
Mapping Instance dobjet Java ligne dans une table
2 Valeurs simples :
2.
Type simple Java Colonne dans une table type SQL
Objet relationnel Transferts automatiques dans les deux sens
Via JDBC
Java SGBD Rduit le temps de dveloppement
Code SQL et JDBC gnr automatiquement

Hibernate - Y. Bekkers 15 Hibernate - Y. Bekkers 16

Conserver des vnements

Application
Event
Un premier exemple Objets id
persistants
titre
Hibernate
Agenda compos dvnements date
config.xml mapping

Base de donnes

Hibernate - Y. Bekkers 17 Hibernate - Y. Bekkers 18

JDBC - Yves Bekkers 3


De quoi est compose lapplication ?
Une classe : entit persistante
Un Java bean
Un document de mapping
Associer des proprits Java des proprits dun
1 - Entit persistante
SGBD relationnel
l ti l
Un document de configuration
Informations de connection la base et rfrences aux Java bean
mapping

! Dans cet exemple pas de SGBD au dpart !

Hibernate - Y. Bekkers 19 Hibernate - Y. Bekkers 20

Entit persistante Event Getters


public Long getId() {
Java bean Event reprsente un vnement Event
return id; Event
id }
public class Event { titre id
public Date getDate() {
private Long id;
date titre
Attributs cachs return
etu date;
private String titre;
} date
private Date date;
public String getTitre() {
public Event() { return titre;
Constructeur sans argument }
}

Getter + setter (page suivante)
}

Hibernate - Y. Bekkers 21 Hibernate - Y. Bekkers 22

Setters Constructeur sans argument


private void setId(Long id) {
this.id = id;
Event Le constructeur sans argument est requis
}
id pour toute classe persistante :
titre
public void setDate(Date
p ( date)) { Hibernate cr des instances dobjets
d objets en
date
this.date = date; utilisant la rflexion Java et les informations
} prises la base de donnes.
public void setTitre(String titre) {
this.titre = titre;
}

Hibernate - Y. Bekkers 23 Hibernate - Y. Bekkers 24

JDBC - Yves Bekkers 4


Identifiant unique dvnement
La proprit id contient la valeur d'un identifiant
unique pour un vnement particulier.
Toutes les classes d'entits persistantes (ainsi que 2 - Mapping O/R
les classes dpendantes
p de moindre importance)
p )
ont besoin d'une proprit identifiante
Les identifiants uniques servent Hibernate et Java SGBDR
lapplication
Noter que la mthode setId() est prive :
lapplication na pas modifier ces identifiants
On va laisser cette tche de gestion Hibernate

Hibernate - Y. Bekkers 25 Hibernate - Y. Bekkers 26

Structure dun document de mapping Fichier de mapping


<hibernate-mapping> Event
<hibernate-mapping> <class name="Event" table="EVENTS"> id
<id name="id" column="EVENT_ID"> titre
<class >...</class> <generator class="increment"/> date
<class >...</class> </id>
<property name="date" type="timestamp"
... column="EVENT_DATE"/>
</hibernate-mapping> <property name="titre"/>
</class>
</hibernate-mapping>

Hibernate - Y. Bekkers 27 Hibernate - Y. Bekkers 28

DTD du dialecte
hibernate-mapping
lment <class>
Permet dassocier une classe Java une table de la
base de donnes
<!DOCTYPE hibernate-mapping PUBLIC Ce sont les classes dentits persistantes
"-//Hibernate/Hibernate Mapping DTD 3.0//EN" Attributs de llment <class>
"http://hibernate.sourceforge.net/hibernate- Attribut name : nom de la classe Java
mapping-3.0.dtd"> Attribut table : nom de la table correspondante
<class name="Event" table="EVENTS">
...
</class>
Contenu : voir suite

Hibernate - Y. Bekkers 29 Hibernate - Y. Bekkers 30

JDBC - Yves Bekkers 5


lment <id> (1)
Contenu dun lment <class>
Identifiant unique pour les vnements
Identifiant unique <id name="id" column="EVENT_ID">
lment <id> <generator class="increment"/>
Proprits </id>

lment
l t <property> Attributs de lllment
lment <id>
name : nom de lattribut dans la classe Java
column : (optionnel) nom de la proprit dans
la table SQL
type : (optionnel) type de mapping Hibernate
de lidentifiant
Hibernate - Y. Bekkers 31 Hibernate - Y. Bekkers 32

lment <id> (2) Stratgies de gnration des identifiants


lment contenu <generator> Attribut class de llment <generator>
Attribut class spcifie le mode (la stratgie) de <generator class="increment"/>
gestion de lidentifiant unique
Valeurs possibles
Hibernate supporte aussi les identifiants
increment : Gnre des identifiants de type
gnrs par les bases de donnes,
donnes
Java long, short ou int
globalement uniques,
identity, sequence : Gnre des
ainsi que les identifiants assigns par l'application
identifiants long, short ou int
n'importe quelle stratgie que vous avez crit en
extension. Spcifique aux bases DB2, MySQL, MS SQL
Server, Sybase et HypersonicSQL

Hibernate - Y. Bekkers 33 Hibernate - Y. Bekkers 34

Autres stratgies de gnration lment <property>


hilo : Hibernate gnre des identifiants de L'lment <property> dclare une proprit de la classe
long, short ou int partir dune table au sens JavaBean.
ddie et dun algorithme performant Attributs de llment <property>
name : nom de la proprit, avec une lettre initiale en minuscule.
native : Gnre des identifiants long, short column : (optionnel - par dfaut au nom de la proprit) : le nom
ou int Choisit identity, sequence ou de la colonne mappe. Cela peut aussi tre indiqu dans le(s) sous-
hilo selon les possibilits offertes par la base l
lment(s)( ) <column>
type : (optionnel) : nom indiquant le type de mapping Hibernate.
de donnes sous-jacente Ici il faut spcifier un choix parmi date, timestamp ou time
assigned : Laisse lapplication effectuer elle- car Hibernate ne peut infrer seul ce type
mme laffectation avant que la mthode <property name="date" type="timestamp"
save() ne soit appele column="EVENT_DATE"/>

Hibernate - Y. Bekkers 35 Hibernate - Y. Bekkers 36

JDBC - Yves Bekkers 6


Fichier de mapping - rappel Attribut column par dfaut
<class name="Event" table="EVENTS"> Event <property name="date"
<id name="id" column="EVENT_ID"> id type="timestamp"
<generator class="increment"/> titre column="EVENT_DATE"/>
</id>
/id date <property name="titre"/>
<property name="date"
Le nom de la colonne est le mme que le nom de la
type="timestamp" column="EVENT_DATE"/>
proprit Java
<property name="titre"/>
</class>

Hibernate - Y. Bekkers 37 Hibernate - Y. Bekkers 38

Attribut type par dfaut Types basiques de mapping


<property name="date" Java Hibernate SQL
type="timestamp"
column="EVENT_DATE"/> java.lang.String string VARCHAR
<property name="titre"/>
java.math.BigDecimal big_decimal NUMERIC
Les types ne sont ni des types Java ni des java.math.BigInteger
big_integer (NUMBER)
types SQL, ce sont des types Hibernate java.util.date, Date, time, TIMESTAMP,
dtection automatique (utilisant la rflexion timestamp DATE

sur la classe Java)


Hibernate - Y. Bekkers 39 Hibernate - Y. Bekkers 40

Utilisation dun fichier de mapping


Hibernate
Sauver le fichier : event.hbm.xml
Le suffixe hbm.xml est une convention Utilisation des objets persistants
dans la communaut des dveloppeurs
Hibernate.
Ranger ce fichier cot des sources Java
Ils doivent tre visible via le classpath

Hibernate - Y. Bekkers 41 Hibernate - Y. Bekkers 42

JDBC - Yves Bekkers 7


Rendre une instance persistante
Utilisation
session.save(objet)
Session session = new Configuration()
Pour rendre persistante un instance ffmre (transiante)
.configure().buildSessionFactory()
Gnration dune commande INSERT uniquement excute au
Transaction tx = moment du lancement de la mthode session.commit()
Event
session.beginTransaction(); Gnration de lidentificateur de linstance (de type Serializable
id ?
// crer un vnement et retourn par la mthode) sauf si de type assigned ou
Event theEvent = new Event(); tit
titre composite
theEvent.setTitre(title); date session.merge(objet)
theEvent.setDate(theDate); Fusionne une instance dtache avec une instante persistante
session.save(theEvent); // sauver lvnement (existante ou charge depuis la base)
Effectue un SELECT avant pour dterminer sil faut faire INSERT
ou UPDATE ou rien
tx.commit(); Aucun code JDBC
! !
Hibernate - Y. Bekkers 43 Hibernate - Y. Bekkers 44

tats dun objet persistant


Sessions et persistance dobjet
new
ffmre Ramasse-miette
Transient
Le but principal dune session get() save()
permettre la cration, la lecture et leffacement load()
Query.list()
saveOrUpdate()
persist()
Delete() Dtruit
Remove()
dinstances dobjets mapps sur des classes dentits Query.uniqueResult()
Query.iterate()
merge()

persistantes
persistantes. Query.scroll()
find() Persistant
getReference()
Une instance est dans un des trois tats : Query.getResultList()
Query.getSingleResult() Evict()
update()
saveOrUpdate()
Ramasse-miette

transient: jamais persistant, non associ une session, Close()


Clear()
merge()
lock()

persistent: associ une unique session


Dtach
detached: persistent au pralable, mais plus associ
aucune session Ramasse-miette

Hibernate - Y. Bekkers 45 Hibernate - Y. Bekkers 46

Rendre persistante les modifications apportes Rendre persistante les modifications apportes
une instance persistante une instance dtache
Pas de mthode particulire Pas de surveillance possible des instances dtaches
ncessit de r-attacher les instances en rendant persistant les
Toute modification dune instance persistante modifications apportes
transactionnelle (objet charg, sauvegard, cr ou session.merge(objet)
requt par la Session) est rendu persistant par la Effectue un SELECT avant llUPDATE pour rcuprer les donnes
mthode flush() dans la base et les fusionner avec les modifications apportes
Retourne linstance persistante correspondante
Surveillance (dirty checking) de toutes les instances En accord avec les spcifications EJB 3.0
persistantes par la session session.update(objet)
Instance persistante modifie = instance sale (dirty) Force la mise jour (UPDATE) de lobjet dans la base
Lve une exception si une instance de mme identificateur existe
Synchronisation avec la base dfinitive une fois la dans la Session
transaction sous-jacente valide
Hibernate - Y. Bekkers 47 Hibernate - Y. Bekkers 48

JDBC - Yves Bekkers 8


Dtacher une instance persistante Dtacher une instance persistante
Plus (pas) de surveillance de linstance par Extraction dfinitive de lentit correspondante
la Session dans la base de donnes
Plus (pas) aucune modification rendue session.delete(objet)
persistante de manire transparente Enregistrement correspondant plus(pas) prsent dans la
Trois moyens de dtacher une instance : base
Instance toujours prsente dans la JVM tant que lobjet
En fermant la session : session.close()
est rfrenc instance effmre (transient)
En vidant la session : session.clear() Objet ramass par la ramasse miette ds quil nest plus
En dtachant une instance particulire rfrenc
session.evict(objet)

Hibernate - Y. Bekkers 49 Hibernate - Y. Bekkers 50

Dtacher/rattacher un objet
Mthodes dune session et requtes sql
persistent - 1
save() et persist()
SQL INSERT
Premire unit de travail
delete() Session session = HibernateUtil
SQL DELETE .getSessionFactory().getCurrentSession();
g y g
update() ou merge() session.beginTransaction();
SQL UPDATE.
Personne aPerson = (Personne) session
Modification dune instance persistante dtecte au
moment du flush() .load(Personne.class, personId);
SQL UPDATE. session.getTransaction().commit();
saveOrUpdate() and replicate() Lobjet aperson est dtach
INSERT ou UPDATE.

Hibernate - Y. Bekkers 51 Hibernate - Y. Bekkers 52

Dtacher/rattacher un objet
Objets Hibernate utiliss
persistent - 2
Seconde unit de travail org.hibernate.SessionFactory;
Session session2 = HibernateUtil org.hibernate.cfg.Configuration;
.getSessionFactory().getCurrentSession();
g y g org.hibernate.Session;
g
session2.beginTransaction(); org.hibernate.Transaction;
aPerson.setAge(age);
session2.update(aPerson);
Lobjet aperson est de nouveau persistant

Hibernate - Y. Bekkers 53 Hibernate - Y. Bekkers 54

JDBC - Yves Bekkers 9


Transaction typique
Session sess = factory.openSession();
Transaction tx;
try {
tx = sess.beginTransaction();
//do some work
...
Requtes dinterrogation
tx.commit();
}
catch (Exception e) {
if (tx!=null) tx.rollback();
throw e;
}
finally {
sess.close();
}
Hibernate - Y. Bekkers 55 Hibernate - Y. Bekkers 56

Trois types de requtes SELECT Deux moyens deffacer


SQL Avec chargement
sess.createSQLQuery().list() Acteur p = (Acteur) sess.load(Acteur.class, currentId);
sess.delete(p);
HQL
sess.createQuery().list()
Criteria Sans chargement
String sqlReqest = "DELETE FROM acteur
sess.createCriteria().list()
WHERE p="+currentId;
int i = sess.createSQLQuery(sqlReqest).executeUpdate();

Hibernate - Y. Bekkers 57 Hibernate - Y. Bekkers 58

Requte SQL
Requtes HQL
La mthode list() rend en rsultat une liste de tableaux dOject
List<Object[]> result = sess.createSQLQuery( result = sess.createQuery("from Personne p,
"SELECT * FROM personne").list(); Vedette v where p.p=v.id.p and v.id.f=18
for (Object[] o : result) { order by p.nom asc").list();
Integer
g p = (Integer)o[0];
g for (Object[] o : result) {
String nom = (String)o[1]; Personne p = (Personne)o[0];
String email = (String)o[2]; Vedette v = (Vedette)o[1];
... ...
} }
Chaque objet du tableau est un attribut typ de la ligne rsultat On obtient deux objets une Personne et une Vedette
par ligne rsultat
Hibernate - Y. Bekkers 59 Hibernate - Y. Bekkers 60

JDBC - Yves Bekkers 10


Requtes criteria Ajouter un filtre un criteria
Recherche sur une classe persistante donne Criteria crit =
Criteria crit = sess.createCriteria(Personne.class);
sess.createCriteria(Personne.class);
crit.add(Expression.eq("nom","dupont"));
List<Personne> personnes =
crit.list(); List<Personne> personnes = crit
crit.list();
list();
for(Personne personne : personnes) { for (Personne personne : personnes) {
System.out.println(personne); sess.delete(personne);
} }
On obtient directement une liste dobjets de la classe
considre

Hibernate - Y. Bekkers 61 Hibernate - Y. Bekkers 62

Lquation Hibernate Rsum


1 JavaBeans
2 fichier de mapping
JavaBeans
3 fichier de configuration
+ SGBDR 4 utilisation
+ Donnes de mapping et de configuration
----------------------------------------------------
= Persistence de donnes

Hibernate - Y. Bekkers 63 Hibernate - Y. Bekkers 64

Intgrer Hibernate dans une


application
1. Installer dans votre projet la librairie Hibernate et
ses librairies dpendantes
2. Crer vos objets mtier (classes persistantes - Associations
javabeans)
3. Crer le fichier Hibernate.cfg.xml qui dcrit
laccs la base de donnes
4. Choisir un dialect SQL pour la base
5. Crer un fichier individuel de mapping pour
chaque classes persistantes

Hibernate - Y. Bekkers 65 Hibernate - Y. Bekkers 66

JDBC - Yves Bekkers 11


Cls trangres - 1 Modifier la classe Event
Ajouter le champ responsable
Event Personne
public class Event { Event
id id private Long id; id
titre nom private
i t String
St i tit
titre; titre
Date * 1 age private Date date; Date
Responsable Responsable
private Personne responsable;

...
Association unidirectionnelle plusieurs 1
}

Hibernate - Y. Bekkers 67 Hibernate - Y. Bekkers 68

Mapping des personnes


Crer une classe Personne
Fichier Personne.hbm.xml
public class Personne { <hibernate-mapping>
<class name="fr.ifsic.events.Personne"
private Long id; Personne table="PERSONNE" >
private String
p g nom; id <id name="id"
name id column
column="PERSONNE
PERSONNE_ID
ID">
>
private int age; nom <generator class="native" />
age </id>
... <property name="nom" />
<property name="age" type="integer"/>
}
</class>
</hibernate-mapping>
Hibernate - Y. Bekkers 69 Hibernate - Y. Bekkers 70

Mapping des Events


Association unidirectionnelle plusieurs 1 Dterminer le type de la classe
<hibernate-mapping> <many-to-one
<class name="fr.ifsic.events.Event"
table="EVENTS" >
name="responsable"
<id name="id" column="EVENT_ID"> column="responsable" optionnels
<generator class="native" /> not-null="true"
</id>
<property name="date" type="timestamp" class="fr.ifsic.events.Personne"
l "f if i t P "
column="EVENT_DATE"/> >
<property name="titre" />
<many-to-one name="responsable"
column="responsable" not-null="true" Lattribut class est optionnel,
class="fr.ifsic.events.Personne"/> il peut tre dtermin par reflexion sur le type
</class> Java de lattribut name="responsable"
</hibernate-mapping>
Hibernate - Y. Bekkers 71 Hibernate - Y. Bekkers 72

JDBC - Yves Bekkers 12


Cls trangres - 2 Ncssit dune table de jointure
Event Personne Event PersonneEvent Personne
* *
id participants events id id Event_id id
titre nom titre Personne id
Personne_id nom
Date * 1 age Date age
Responsable
responsable

Association bidirectionnelle plusieurs plusieurs

Hibernate - Y. Bekkers 73 Hibernate - Y. Bekkers 74

Modifier la classe Personne Types Java pour une collection


persistante
Utiliser un Set Personne
public class Personne { java.util.Set
id
java.util.Collection
nom
private Long id; java.util.List
age
private String nom; j
java.util.Map
il
events java.util.SortedSet
private int age;
private Set events = new HashSet(); java.util.SortedMap
Ou bien toute implmentation de linterface
... org.hibernate.usertype.UserCollectionType
}
Hibernate - Y. Bekkers 75 Hibernate - Y. Bekkers 76

Modifier la classe Event Mapping des personnes


Event Fichier Personne.hbm.xml
Ajouter le champ participants id
<hibernate-mapping>
<class name="fr.ifsic.events.Personne"
titre table="PERSONNE" >
public class Event {
date ...
private Long id; responsable
private String titre; < t name="events"
<set " t " t
table="PersonEvents">
bl "P E t ">
participants <key column="personId"/>
private Date date;
private Personne responsable; <many-to-many column="eventId"
private Set participants = new HashSet(); class="Event"/>
</set>
</class>
... </hibernate-mapping>
}
Hibernate - Y. Bekkers 77 Hibernate - Y. Bekkers 78

JDBC - Yves Bekkers 13


Mapping des Evnement
Fichier Event.hbm.xml
<hibernate-mapping>
<class name="fr.ifsic.events.Event" table="EVENT" >
...
<set name="participants" table="PersonEvents">
Manipuler des objets persistants
<key column="eventId"/>
<many-to-many column="personneId"
class="Personne"/>
</set>
</class>
</hibernate-mapping>

Hibernate - Y. Bekkers 79 Hibernate - Y. Bekkers 80

Cration dobjets Personne Cration dobjets Event


Personne createAndStorePersonne(String nom, int Event createAndStoreEvent(String title, Date theDate,
age) { Personne responsable) {
Session session = Session session =
HibernateUtil.getSessionFactory().getCurrentSessi HibernateUtil.getSessionFactory().getCurrentSession();
on(); Transaction tx = session.beginTransaction();
Transaction tx = session.beginTransaction();
Personne p = new Personne();
(); Event theEvent = new Event();
theEvent.setTitre(title);
p.setNom(nom);
theEvent.setDate(theDate);
p.setAge(age);
theEvent.setResponsable(responsable);

session.save(p); session.save(theEvent);
tx.commit(); tx.commit();
return p; return theEvent;
} }

Hibernate - Y. Bekkers 81 Hibernate - Y. Bekkers 82

Peupler la base Ajouter des participants un


Ajouter des personnes vnement
Personne p1 = createAndStorePersonne("marcel", 25);
void addParticipant(Personne[] persons, Event e) {
Personne p2 = createAndStorePersonne("jules", 42);
Session session = HibernateUtil.
Personne p3 = createAndStorePersonne("toto", 10);
getSessionFactory().getCurrentSession();
Ajouter des vnements Transaction tx = session.beginTransaction();
Event e1
1 = createAndStoreEvent("My
dS (" Event",
"
for (Personne p : persons) {
new Date(), p2);
e.getParticipants().add(p);
Event e2 = createAndStoreEvent("another Event",
}
new Date(), p1);
session.update(e);
Crer une liste de personnes tx.commit();
Personne[] listP = { p1, p2 }; }
addParticipant(listP, e1);

Hibernate - Y. Bekkers 83 Hibernate - Y. Bekkers 84

JDBC - Yves Bekkers 14


Les tables initialises Rcuprer une instance persistante
si on connat son identifiant
Personne_id nom age
P_id E_id
1 Marcel 25 Cas o on est certain que lobjet existe
1 1 Personne p = (Personne)
2 Jules 42
2 1 sess.load(Personne.class,1524);
3 Toto 10
Cas o on nest pas certain que lobjet existe
Personne p = (Personne)
id date titre Responsable sess.get(Personne.class,id);
1 Xxx My event 2 if (p==null) {
2 Yyy Another event 1 // crer lobjet didentifiant id
}
Hibernate - Y. Bekkers 85 Hibernate - Y. Bekkers 86

Excution de requtes
Requtage si on ne connat pas didentifiant
Nom de classe
Par une requte simple
Quand utiliser les requtes session.beginTransaction();
Lorsque lon ne connait pas lidentification dune entit List<Event> result = session.createQuery("from
Event").list();
Deux sortes de requtes session.getTransaction().commit();
HQL
List cats = session.createQuery( "from Cat as cat
where cat.birthdate < ?") Par une requte paramtre
.setDate(0, date) session.beginTransaction();
.list(); List<Personne> result = session.createQuery("from
SQL PERSONNE as p WHERE p.nom = ?")
List cats = session.createSQLQuery( "SELECT {cat.*} .setString(0,nom).list();
FROM CAT {cat} WHERE ROWNUM<10", "cat", Cat.class session.getTransaction().commit();
).list();
Commencent 0 (et non 1 comme JDBC)
!
Hibernate - Y. Bekkers 87 Hibernate - Y. Bekkers 88

Paramtres nomms Requte qui retournent des tuples


Iterator kittensAndMothers = sess.createQuery(
Par une requte paramtre "select kitten, mother from Cat kitten join
session.beginTransaction(); kitten.mother mother")
.list()
List<Personne> result = .iterator();
session.createQuery("from PERSONNE as p
WHERE p.nom = :nom") while ( kittensAndMothers.hasNext() ) {
Object[] tuple = (Object[])
.setString("nom",nom).list(); kittensAndMothers.next();
session.getTransaction().commit(); Cat kitten = tuple[0];
Cat mother = tuple[1];
....
}

Hibernate - Y. Bekkers 89 Hibernate - Y. Bekkers 90

JDBC - Yves Bekkers 15


Requettes par critres
Criteria crit =
sess.createCriteria(Cat.class).
Add(Restrictions.eq("p",
Diverses
currentId));
crit.setMaxResults(50);
List cats = crit.list();

Hibernate - Y. Bekkers 91 Hibernate - Y. Bekkers 92

Identifiants composs
Chargement la demande
<composite-id>
<key-property name="nom"/>
<key-property name="prnom"/>
</composite-id>

On peut utiliser comme contenu des mappings


<key-property>
<many-to-one>
Les classes persistantes doivent surcharger les
mthodes
equals()
hashCode()

Hibernate - Y. Bekkers 93 Hibernate - Y. Bekkers 94

Table unique avec discriminant - 1


<class name="Payment" class="PAYMENT">
<id name="id" type="long"
Hritage column="PAYMENT_id">
<generator class="native"/>
class native />
</id>
<discriminator column="PAYMENT_TYPE"
type="string"/>
<property="montant"/>
...
</class>
Hibernate - Y. Bekkers 95 Hibernate - Y. Bekkers 96

JDBC - Yves Bekkers 16


Table unique avec discriminant - 2 Une table par classe fille - 1
<subclass name="carte" <class name="Payment" class="PAYMENT">
discriminator="CREDIT"> <id name="id" type="long"
<property name="cctype" column="CCTYPE"/> column="PAYMENT_id">
... <generator class="native"/>
l i /
</subclass> </id>
<subclass name="cheque" <property="montant"/>
discriminator="CHEQUE"> ...
... </class>
</subclass>

Hibernate - Y. Bekkers 97 Hibernate - Y. Bekkers 98

Une table par classe fille - 2 Outils


<joined-subclass name="carte"> Plugin Eclipse
<property name="cctype" column="CCTYPE"/>
JBoss Eclipse IDE
<key column="PAYMENT_id"/>
...
http://www.hibernate.org/6.html
</joined-subclass> Ant
<joined-subclass name="cheque">
<key column="PAYMENT_id"/>
...
</joined-subclass>

Hibernate - Y. Bekkers 99 Hibernate - Y. Bekkers 100

JDBC - Yves Bekkers 17

Vous aimerez peut-être aussi