Exposé sur :

Réalisé par :
La création
o
o
o
o
Problématique
Mapping Objet/Relationnel
Qu’est ce que hibernate?
Configuration du projet hibernate
Problématique
L’utilisation du JDBC (Java DataBase
Connectivity) implique que le développeur
implémente lui-même l'interaction avec les
bases de données et les requêtes SQL qui
sont nécessaires à la persistance des
données de son application.
Solution
mapping Objet/Relationnel
La technique du mapping relationnelobjet (également appelé ORM pour Object
Relational Mapping) permet de faire le lien
entre le modèle des classes et le schéma
relationnel et de réaliser les transcriptions
nécessaires au passage de l’objet vers le
relationnel.
Solution
mapping Objet/Relationnel
Grace à cette notion de mapping le
temps de développement de l’application
est réduit, en éliminant une grande partie
du code SQL à écrire pour interagir avec la
base de données.
Solution
mapping Objet/Relationnel
Cette technique permet ainsi de faire automatiquement
les transcriptions suivantes:
Mode objet
Mode relationnel
classe
table
instance
enregistrement
attribut
colonne
association
Clé étrangère
Qu’est ce que l’hibernate?
Hibernate est un outil de mapping
Objet/Relationnel. C’est un framework
open source qui permet de faire
correspondre des tables de base de
données relationnelles avec des objets java.
Qu’est ce que l’hibernate?
Hibernate permet de gérer les
transactions coté base de données,
et de manipuler facilement les
données et assurer leur persistance
au niveau de la base de données.
Les surplus de hibernate
• hibernate se charge de générer le code SQL.
• récupération de données optimisée.
• portabilité du code si changement de base de
données.
Hibernate a besoin de plusieurs éléments
pour fonctionner :
• Configuration du projet Eclipse.
• Une classe javabean qui encapsule les
données d'une occurrence de table.
• Un fichier de configuration qui assure la
correspondance entre la classe et la table
(mapping).
Configuration d’un projet
hibernate
1. Etablir la connexion entre MySql et Eclipse.
2. Etablir la connexion entre Hibernate et
Eclipse.
3. Etablir la connexion entre Hibernate et
MySql.
La mise en route
o
o
o
o
Création entité jpa
Configuration hibernate
Contexte de persistance et sessions
Génération de base de donnée
Création entité jpa
• Créer une classe qui va encapsuler les
données Cette classe doit respecter le
standard des Javabeans, notamment,
encapsuler les propriétés dans ses champs
private avec des getters et setters et avoir un
constructeur par défaut.
Création entité jpa
Premier mapping
• Afin que JPA puisse faire le lien entre un objet
Java et la base de données, les classes à
mapper sont définies en tant qu’entité JPA.
Pour ce faire, on les déclare avec l'annotation
@Entity. Elle doit également comporter au
moins un attribut déclaré comme clé primaire
à l'aide de l'annotation @Id.
• Comme nous l’avons vu, la classe est déclarée
avec l’annotation @Entity , qui indique que la
classe est une entité JPA et qu’elle doit donc
être mappée .
• La norme de l’API JPA nécessite également que
l’on précise quel est l’id de la table .
L’annotation @GeneratedValue indique à l’API
comment gérer l’incrément des identifiants.
Ici, nous avons choisi un incrément
automatique.
Des annotations supplémentaires
• Ajoutons maintenant quelques annotations
supplémentaires pour préciser le mapping que
nous désirons. Toutes ces nouvelles
annotations sont facultatives, mais souvent
nécessaires : dans notre exemple, nous avons
notamment besoin de préciser que l'attribut
beginDate est de type DATE et non DATETIME.
• En supplément de l’annotation @Entity, la JPA
propose de préciser le nom de la table en
utilisant l’annotation @Table .
• Pour chaque attribut, l’annotation @Column
indique le nom que l’on désire donner au
champ dans la table.
Configuration d'Hibernate
• Notre première entité JPA étant désormais écrite, il
faut maintenant paramétrer Hibernate pour qu’il
puisse se connecter à notre base de données.
• Avant toute chose, il est à noter qu’Hibernate est
capable de créer des tables et de faire toutes sortes
d’opérations sur celles-ci ainsi que sur leurs entrées.
Toutefois, la base de données en elle-même doit
préalablement exister, et donc avoir été créée
manuellement.
• Pour créer la base de données, utilisons l’outil
PhpMyAdmin fourni par Wamp Server.
•
•
•
•
•
Pour exécuter Hibernate, il faut lui fournir un certain
nombre de propriétés concernant sa configuration
pour qu'il puisse se connecter à la base de données.
Ces propriétés peuvent être fournies sous plusieurs
formes :
un fichier de configuration nommé
hibernate.properties et stocké dans un répertoire
inclus dans le classpath
un fichier de configuration au format XML nommé
hibernate.cfg.xml
utiliser la méthode setProperties() de la classe
Configuration
définir des propriétés dans la JVM en utilisant
l'option -Dpropriété=valeur
Les principales propriétés pour configurer la connexion
JDBC sont :
• hibernate.connection.driver_class:
nom pleinement qualifié de la classe du pilote JDBC
• hibernate.connection.url :
URL JDBC désignant la base de données
• hibernate.connection.username:
nom de l'utilisateur pour la connexion
• hibernate.connection.password :
mot de passe de l'utilisateur
nous précisons qu’à l’initialisation d’Hibernate, les
tables correspondant aux entités mappées doivent
être créées. Différentes valeurs sont possibles pour
ce paramètre hbm2ddl.auto :
• validate: valide le schéma, aucune modification n’est
faite sur la structure de la base ;
• update: met à jour le schéma existant ;
• create: crée le schéma en supprimant les données
préalablement existantes ;
• create-drop: même comportement que create avec
suppression du schéma en fin de session.
Contexte de persistance et sessions
Pour utiliser Hibernate dans le code, il est nécessaire de
réaliser plusieurs opérations :
• création d'une instance de la classe
• création d'une instance de la classe SessionFactory
• création d'une instance de la classe Session qui va
permettre d'utiliser les services d'Hibernate
• Pour gérer les accès à la base de données, Hibernate
utilise des sessions. Ce sont des instances de la classe
org.hibernate.session qui permettent d'encapsuler
une connexion JDBC.
• Les sessions sont créées par une instance de la classe
SessionFactory, dont le rôle est de parser le fichier de
configuration Hibernate, de se connecter à la base de
données et de fournir des Sessions à la demande.
Habituellement, une seule instance de
SessionFactory est créée dans toute l'application.
• nous allons créer une classe
HibernateUtils chargée de créer et de
gérer la SessionFactory. La méthode
getSession() de cette classe sera appelée
à chaque fois que nous voudrons accéder
à la base de données.
• La SessionFactory instanciée se charge de lire le
fichier hibernate.cfg.xml et d’initialiser Hibernate
pour une utilisation ultérieure., la méthode
getSession() utilise la sessionFactory pour créer une
nouvelle session Hibernate, que nous pourrons alors
utiliser pour accéder à la base de données.
• Notons que nous effectuons ici les premiers imports
spécifiques à Hibernate. L’entité JPA , elle, ne dépend
jamais d’Hibernate mais seulement de
javax.persistence. De cette manière, nous pourrons
conserver notre modèle tel quel si nous décidons un
jour d'utiliser une autre implémentation de JPA
qu'Hibernate.
Génération base de donnée
• La couche JPA de notre programme est désormais
constituée d’une entité JPA et du fichier de
configuration d’Hibernate. Le but est maintenant de
compléter notre projet pour pouvoir générer la base
de données et tester l’enregistrement d’un premier
objet.
Cette classe a pour but de créer le schéma de la base
de données et d’y insérer l’Event que l’on vient de
créer. Pour ce faire, on suit les étapes suivantes.
• Ouverture d’une session Hibernate à l’aide de la
SessionFactory gérée dans la classe HibernateUtils :
c'est cet objet qui permet de créer un pont entre
l'application Java et Hibernate.
• Création d’une transaction : chaque accès à la base
de données en écriture doit se faire à l'intérieur
d'une transaction. L'appel à la méthode commit(), au
moment de la fermeture de la transaction, permet
de synchroniser la base de données et d'y effectuer
les modifications nécessaires.
• Création de l'objet Event à enregistrer
• Enregistrement de l'objet à l'aide de la
méthode save qu'Hibernate transformera en
une opération SQL insert.
• Fermeture de la transaction et
synchronisation du programme Java avec la
base de données.
• Fermeture de la session : l'opération de
sauvegarde est terminée, le lien avec
Hibernate peut être fermé.
La manipulation
o Langage HQL
o CRUD
o Les associations
o Relations (one-to-one)(many-to-one )(many-tomany)
o Conclusion
Découverte du langage HQL
• Découvrir HQL
• Création de la classe de tests
• Afficher et vider la table EVENTS
– Vider la table EVENTS
– Afficher le contenu de la table EVENTS
– Test des méthodes de suppression et d'affichage
Hibernate Query Language
C’est quoi HQL ?
d'interrogation
commun
à toutes
les
basesexécuter
de données
•• IlLangage
est aussi possible
d'utiliser l'API
Criteria
qui va en
interne
une requête HQL.
Le point d'entrée est d'obtenir une instance de type Criteria en invoquant la méthode
Hibernate
courante
: elle attend
paramètre
classe des
• createCriteria()
indépendant de
delalasession
base de
données
sous jacente
: la en
requête
SQLlasera
objets
attendus
en résultat.àL'API
permet
de préciser
les différents
critères
seront
générée
par Hibernate
partir
du HQL
en fonction
de la base
de qui
données
utilisés
pourvia
générer
la requête. L'API Criteria utilise HQL en sous-jacent.
précisée
un dialect.
•• Le
langage
HQL
est proche
de SQL
avec une utilisation
sous
d'objets
des noms de
les
entités
utilisées
dans
les requêtes
HQL sont
desforme
objets
et des
certaines
entités
C'est Hibernate
quietseses
charge
de générer la requête
à partir
propriétés.
La .syntaxe
de HQL
fonctionnalités
de baseSQL
sont
très de la
requête
HQL
tenant compte du contexte
similaire
à en
SQL.
Le test
classe de tests prête ---> CRUD
Manipulation d'objets et
opérations CRUD
o Création d'un objet
o Récupération d'un objet
o Modification d'un objet
o Suppression d'un objet
• Arrivé à ce point , nous savons désormais comment
mapper une classe et comment manipuler les objets
mappés. Mais un projet utilisant Hibernate
nécessite bien évidemment plusieurs classes,
souvent liées entre elles par diverses associations,
qu'il faut elles aussi mapper et transformer en clés
étrangères ou en tables de jointure. C'est
notamment le cas de l'étude de cas que nous vous
proposons.
Gestion des associations
• Arborescence du projet
• Configuration du projet
 Structure générale
 Fichier de configuration
d'Hibernate
 Fichier HibernateUtils.java
Relation one-to-one
(1--1)
• Création des entités JPA Address et Event
– La classe Address
– La classe Event
• Enregistrement des objets
– La classe Main
– Implémentation de testCreate()
• L'annotation Cascade
– Définition des cascades
– Ajout d'une cascade dans le projet
cascades
• Il existe différents types de Cascade en JPA, qui
peuvent se cumuler. Les principales sont :
– CascadeType.PERSIST pour les opérations de persistance
(méthodes persist() et save()),
– CascadeType.MERGE pour les opérations de merge
(méthode merge()),
– CascadeType.REMOVE pour la suppression (méthode
delete()),
– CascadeType.ALL pour cumuler toutes les opérations de
Cascade.
Dans event
Relation many-to-one
(1--n)
• Implémentation de l'association
– Relation bidirectionnelle
– Mapping de la classe User
– Modifications du mapping de la classe Event
• Modifications de la classe de test
–
–
–
–
Affichage du contenu de la table USERS
Modification de l'affichage de la table EVENTS
Enregistrement de nouveaux utilisateurs
L'importance des cascades
Relation many-to-many
(n--n)
• Mapping d'une relation many-to-many
– La classe Guest
– Ajouts dans l'entité Event
• Test du mapping
– Méthode printGuests()
– Méthode testCreate()
• Dans l'entité Event, ajoutons l'attribut relatif
aux Items et le mapping, cette fois en
@OneToMany:
Test du mapping
Conclusion