et Java Hibernate

ISBN : 978-2-409-00582-4
39 €
JPA et Java Hibernate
Apprenez le mapping objet-relationnel (ORM) avec Java
Martial BANON évolue profession-
nellement dans le domaine de la
conception informatique depuis 2005,
autant sur des logiciels embarqués
autonomes que sur des Systèmes
d’Information complexes. Passionné
par son métier, il a occupé des postes
tels que développeur, architecte,
lead-développeur ou encore chef de
projets. Il participe régulièrement à
la formation de jeunes développeurs
rejoignant ses équipes et c’est cette
double compétence technique et
pédagogique dont il fait profiter le
lecteur avec ce livre sur JPA et Java
Hibernate.
Ce livre sur JPA (en version 2.1 au moment de l’écriture) et Java
Hibernate s’adresse aux développeurs et étudiants en informa-
tique, ayant des connaissances en Java et SQL, voulant décou-
vrir ou approfondir leurs compétences sur les outils de mapping
objet-relationnel (ORM ou Object-Relational Mapping en anglais).
De l’explication des concepts des ORM jusqu’à la construction de
requêtes, le lecteur est guidé pas à pas et crée une application
qui utilise cette technologie.
Dans la première partie, l’auteur met en place l’environnement de
travail (serveur de base de données MySQL, environnement de
développement intégré NetBeans) puis il détaille les concepts
importants des ORM.
La seconde partie concerne la réalisation d’une application. L’au-
teur présente les étapes de conception qui permettent d’intégrer
simplement les ORM, de les paramétrer et d’appréhender les dif-
férentes problématiques dans un ordre logique. Au fur et à mesure
des pages, et au sein de chaque chapitre, une explication générale
sur le point étudié est d’abord donnée, afin de situer le contexte et
la problématique. Le modèle de données utilisé tout au long du
livre contient tous les cas standards que le lecteur peut rencontrer
dans une application, tels que les relations 1-1, 1-n, n-1 ou encore
n-n avec la table intermédiaire enrichie, et leurs différentes possibi-
lités d’utilisation.
La dernière partie propose des fonctionnalités plus avancées et
quelques bonnes pratiques de développement telles que l’utilisa-
tion de Maven, la génération automatique des entités...
L’environnement de développement repose sur Java 8, Netbeans
comme IDE, JPA 2.1 comme norme pour l’ORM et Hibernate pour
son implémentation. Bien que l’ouvrage ait été réalisé pour Net-
Beans, le projet peut être réalisé avec l’IDE Eclipse.
Des éléments complémentaires sont en téléchargement sur le site
www.editions-eni.fr.
Pour plus
d’informations :
Avant-propos•Environnementdedé-
veloppement • Concept des ORM •
Préparation d’un projet • Manipu-
lation des données • Requêtes : les
langagesJPQLetHQL•L’APICrite-
ria•Pourallerplusloin•Réalisation
d’un projet
Les chapitres du livre
JPA et Java Hibernate
Mapping objet-relationnel (ORM)
Téléchargement
www.editions-eni.fr
.fr
Sur www.editions-eni.fr:
b Le code source du projet.
b Les scripts pour la base de données.
JPA
et Java Hibernate
Apprenez le mapping
objet-relationnel (ORM)
avec Java
Martial BANON

1
Table des matières
Avant-propos
1. Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
2. Contenu de l'ouvrage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .16
Chapitre 1
Environnement de développement
1. Installation du JDK. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
2. Installation de NetBeans . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .19
3. Installation d'Hibernate . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
4. Installation de MySQL. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
5. Premier lancement de NetBeans . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
5.1 Mise en place des libraires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
5.2 Création du projet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
Chapitre 2
Concept des ORM
1. Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
2. Le concept . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
2.1 La norme : JPA . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
2.2 L'implémentation : Hibernate . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
3. La structuration des données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
3.1 Introduction au mapping. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
3.2 Importance du mapping. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .61
Les éléments à télécharger sont disponibles à l'adresse suivante :
http://www.editions-eni.fr
Saisissez la référence de l'ouvrage EIJHJPA dans la zone de recherche
et validez. Cliquez sur le titre du livre puis sur le bouton de téléchargement.

2
Apprenez le mapping objet-relationnel (ORM) avec Java
JPA et Java Hibernate
3.3 Différentes techniques de mapping. . . . . . . . . . . . . . . . . . . . . . . 61
4. La connexion aux données. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
4.1 Introduction aux sessions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
4.2 Les différents types de sessions . . . . . . . . . . . . . . . . . . . . . . . . . . 64
4.3 L'utilisation d'une session. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
4.3.1 RESOURCE_LOCAL avec Java SE . . . . . . . . . . . . . . . . . . 64
4.3.2 RESOURCE_LOCAL avec Java EE. . . . . . . . . . . . . . . . . . 65
4.3.3 JTA avec Java EE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
5. L'interrogation des données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
5.1 Introduction aux requêtes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
5.2 Les requêtes natives . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68
5.3 Les requêtes objets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68
5.4 Les requêtes nommées . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
5.5 Les requêtes "implicites". . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
5.6 L'API Criteria. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
6. Le cycle de vie des données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
6.1 Introduction au cache . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
6.2 Les différents niveaux de caches . . . . . . . . . . . . . . . . . . . . . . . . . 74
6.3 Cache de niveau 1 (L1). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
6.4 Cache de niveau 2 (L2). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
6.5 À retenir . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76
Chapitre 3
Préparation d'un projet
1. Présentation du projet du livre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
1.1 Description . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
1.2 Schéma de la base de données . . . . . . . . . . . . . . . . . . . . . . . . . . . 78
2. Les possibilités de mapping . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78
2.1 Fichier de mapping . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79
2.2 Annotation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80

3
Table des matières
3. Paramétrage de l'ORM . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81
3.1 Création du fichier persistence.xml. . . . . . . . . . . . . . . . . . . . . . . 81
3.2 L'unité de persistance . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92
3.3 L'implémentation de JPA utilisée. . . . . . . . . . . . . . . . . . . . . . . . . 93
3.4 Les entités à mapper. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93
3.5 Les propriétés du fichier de persistance. . . . . . . . . . . . . . . . . . . . 94
3.5.1 Le driver de connexion à la base de données . . . . . . . . . . 94
3.5.2 L'URL de la base de données . . . . . . . . . . . . . . . . . . . . . . . 95
3.5.3 Le login. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .95
3.5.4 Le mot de passe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95
3.6 Le chargement du contexte de persistance . . . . . . . . . . . . . . . . . 96
4. Les types persistables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
4.1 Classes définies par l'utilisateur. . . . . . . . . . . . . . . . . . . . . . . . . . 97
4.1.1 Classe d'entité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
4.1.2 Superclasse mappée. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99
4.1.3 Classe intégrable . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100
4.2 Données Java simples. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101
4.3 Valeur multiple. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .102
4.4 Divers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .103
5. Les différents champs. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .104
5.1 Les champs temporaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104
5.2 Les champs persistables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .105
5.2.1 L'annotation @Basic . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105
5.2.2 L'annotation @Column . . . . . . . . . . . . . . . . . . . . . . . . . 107
5.2.3 L’annotation @Temporal . . . . . . . . . . . . . . . . . . . . . . . . 109
6. Les clés primaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111
6.1 Clé primaire simple. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111
6.2 Clé primaire composée. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112
7. Les valeurs générées . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .113
7.1 Valeur fixe. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113
7.2 Valeur incrémentielle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114
7.2.1 GenerationType.AUTO . . . . . . . . . . . . . . . . . . . . . . . . . 114

4
Apprenez le mapping objet-relationnel (ORM) avec Java
JPA et Java Hibernate
7.2.2 GenerationType.IDENTITY. . . . . . . . . . . . . . . . . . . . . . 115
7.2.3 GenerationType.TABLE . . . . . . . . . . . . . . . . . . . . . . . . . 115
7.2.4 GenerationType.SEQUENCE. . . . . . . . . . . . . . . . . . . . . 116
8. Les relations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117
8.1 Les relations 1-1 (OneToOne) . . . . . . . . . . . . . . . . . . . . . . . . . . 117
8.2 Les relations n-1 (ManyToOne) . . . . . . . . . . . . . . . . . . . . . . . . 120
8.3 Les relations 1-n (OneToMany) . . . . . . . . . . . . . . . . . . . . . . . . 120
8.4 Les relations n-n (ManyToMany). . . . . . . . . . . . . . . . . . . . . . . 122
8.5 Les relations n-n avec données sur la jointure . . . . . . . . . . . . . 126
9. Type de chargement des données . . . . . . . . . . . . . . . . . . . . . . . . . . . 129
9.1 Lazy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129
9.2 Eager . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 130
9.3 Mise en place. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 130
10. Particularités sur les entités . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131
10.1 Sérialisation. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131
10.2 Equals et HashCode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132
10.2.1 Implémentation par défaut. . . . . . . . . . . . . . . . . . . . . . . 132
10.2.2 Implémentation basée sur la clé primaire . . . . . . . . . . . 132
10.2.3 Implémentation basée sur une clé métier . . . . . . . . . . . 133
10.2.4 Conclusion. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133
Chapitre 4
Manipulation des données
1. Préparation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135
2. Établissement de la connexion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 136
2.1 EntityManagerFactory. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 136
2.1.1 Avec conteneur JEE, en RESOURCE_LOCAL. . . . . . . . 136
2.1.2 Sans conteneur JEE, en RESOURCE_LOCAL . . . . . . . . 137
2.2 EntityManager . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 144
2.2.1 Avec conteneur JEE, en JTA . . . . . . . . . . . . . . . . . . . . . . 144
2.2.2 Avec conteneur JEE, en RESOURCE_LOCAL. . . . . . . . 145