JPA et Java Hibernate : apprenez le mapping objet-relationne (ORM) avec Java

Auteur(s) :

Banon, Martial Découvrir l'auteur

Résumé

Pour découvrir ou approfondir ses compétences avec les outils de mapping objet-relationnel. Des concepts des ORM jusqu'à la construction de requêtes, l'implémentation ou l'utilisation du mapping au sein d'une application, l'auteur explique chaque point en suivant une progression logique. Avec des éléments complémentaires en téléchargement sur le site de l'éditeur. ©Electre 2017

Éditeur(s)
- Editions ENI
Date
- cop. 2017
Notes
- La couv. porte en plus : "Fichiers complémentaires à télécharger" ; "Informatique technique"
- La 4ème de couv. porte en plus : "Sur www.editions-eni.fr : le code source du projet, les scripts pour la base de données"
- Contient un "flshcode" permettant d'accéder à un contenu via Internet
Langues
- Français
Description matérielle
- 1 vol. (392 p.) : ill.; ; 21 cm
Collections
- Expert IT
Sujet(s)
ISBN
- 978-2-409-00582-4
Indice
- 681.225 Java
Quatrième de couverture
- JPA et Java Hibernate
  Apprenez le mapping objet-relationnel (ORM) avec Java
  Ce livre sur JPA (en version 2.1 au moment de l'écriture) et Java Hibernate s'adresse aux développeurs et étudiants en informatique, ayant des connaissances en Java et SQL, voulant découvrir 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'auteur présente les étapes de conception qui permettent d'intégrer simplement les ORM, de les paramétrer et d'appréhender les diffé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 possibilités d'utilisation.
  La dernière partie propose des fonctionnalités plus avancées et quelques bonnes pratiques de développement telles que l'utilisation 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 NetBeans, le projet peut être réalisé avec l'IDE Eclipse.
Tables des matières
- - JPA et Java Hibernate
  - Apprenez le mapping objet-relationnel (ORM) avec Java
  - Avant-propos
  - 1. Introduction15
  - 2. Contenu de l'ouvrage16
  - Chapitre 1
  - Environnement de développement
  - 1. Installation du JDK17
  - 2. Installation de NetBeans19
  - 3. Installation d'Hibernate26
  - 4. Installation de MySQL27
  - 5. Premier lancement de NetBeans48
  - 5.1 Mise en place des libraires49
  - 5.2 Création du projet54
  - Chapitre 2
  - Concept des ORM
  - 1. Introduction57
  - 2. Le concept58
  - 2.1 La norme : JPA59
  - 2.2 L'implémentation : Hibernate60
  - 3. La structuration des données60
  - 3.1 Introduction au mapping60
  - 3.2 Importance du mapping61
  - 3.3 Différentes techniques de mapping61
  - 4. La connexion aux données63
  - 4.1 Introduction aux sessions63
  - 4.2 Les différents types de sessions64
  - 4.3 L'utilisation d'une session64
  - 4.3.1 RESOURCE_LOCAL avec Java SE64
  - 4.3.2 RESOURCE_LOCAL avec Java EE65
  - 4.3.3 JTA avec Java EE66
  - 5. L'interrogation des données67
  - 5.1 Introduction aux requêtes67
  - 5.2 Les requêtes natives68
  - 5.3 Les requêtes objets68
  - 5.4 Les requêtes nommées69
  - 5.5 Les requêtes « implicites »70
  - 5.6 L'API Criteria71
  - 6. Le cycle de vie des données73
  - 6.1 Introduction au cache73
  - 6.2 Les différents niveaux de caches74
  - 6.3 Cache de niveau 1 (Ll)75
  - 6.4 Cache de niveau 2 (L2)75
  - 6.5 À retenir76
  - Chapitre 3
  - Préparation d'un projet
  - 1. Présentation du projet du livre77
  - 1.1 Description77
  - 1.2 Schéma de la base de données78
  - 2. Les possibilités de mapping78
  - 2.1 Fichier de mapping79
  - 2.2 Annotation80
  - 3. Paramétrage de l'ORM81
  - 3.1 Création du fichier persistence.xml81
  - 3.2 L'unité de persistance92
  - 3.3 L'implémentation de JPA utilisée93
  - 3.4 Les entités à mapper93
  - 3.5 Les propriétés du fichier de persistance94
  - 3.5.1 Le driver de connexion à la base de données94
  - 3.5.2 L'URL de la base de données95
  - 3.5.3 Le login95
  - 3.5.4 Le mot de passe95
  - 3.6 Le chargement du contexte de persistance96
  - 4. Les types persistables97
  - 4.1 Classes définies par l'utilisateur97
  - 4.1.1 Classe d'entité97
  - 4.1.2 Superclasse mappée99
  - 4.1.3 Classe intégrable100
  - 4.2 Données Java simples101
  - 4.3 Valeur multiple102
  - 4.4 Divers103
  - 5. Les différents champs104
  - 5.1 Les champs temporaires104
  - 5.2 Les champs persistables105
  - 5.2.1 L'annotation @Basic105
  - 5.2.2 L'annotation @Column107
  - 5.2.3 L'annotation @Temporal109
  - 6. Les clés primaires111
  - 6.1 Clé primaire simple111
  - 6.2 Clé primaire composée112
  - 7. Les valeurs générées113
  - 7.1 Valeur fixe113
  - 7.2 Valeur incrémentielle114
  - 7.2.1 GenerationType.AUTO114
  - 7.2.2 GenerationType.IDENTITY115
  - 7.2.3 GenerationType.TABLE115
  - 7.2.4 GenerationType.SEQUENCE116
  - 8. Les relations117
  - 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 jointure126
  - 9. Type de chargement des données129
  - 9.1 Lazy129
  - 9.2 Eager130
  - 9.3 Mise en place130
  - 10. Particularités sur les entités131
  - 10.1 Sérialisation131
  - 10.2 Equals et HashCode132
  - 10.2.1 Implémentation par défaut132
  - 10.2.2 Implémentation basée sur la clé primaire132
  - 10.2.3 Implémentation basée sur une clé métier133
  - 10.2.4 Conclusion133
  - Chapitre 4
  - Manipulation des données
  - 1. Préparation135
  - 2. Établissement de la connexion136
  - 2.1 EntityManagerFactory136
  - 2.1.1 Avec conteneur JEE, en RESOURCE_LOCAL136
  - 2.1.2 Sans conteneur JEE, en RESOURCE_LOCAL137
  - 2.2 EntityManager144
  - 2.2.1 Avec conteneur JEE, en JTA144
  - 2.2.2 Avec conteneur JEE, en RESOURCE_LOCAL145
  - 2.2.3 Sans conteneur JEE, en RESOURCE_LOCAL145
  - 2.3 État d'une entité147
  - 3. Les transactions147
  - 3.1 Exécution d'une transaction148
  - 3.2 Méthodes diverses sur les transactions149
  - 3.2.1 Vérifier que la transaction est active149
  - 3.2.2 Empêcher la modification via la transaction150
  - 4. Création d'une entité152
  - 4.1 Création d'une entité simple152
  - 4.2 Création d'une arborescence d'entités154
  - 4.2.1 Relation avec identifiant différent154
  - 4.2.2 Relation avec identifiant partagé157
  - 4.2.3 L'annotation @PrePersist160
  - 4.2.4 Le générateur générique d'Hibernate162
  - 4.3 Cascade avec une table de jointure164
  - 4.4 Création d'une entité avec clé primaire composée167
  - 5. Récupération d'une entité169
  - 5.1 Entité avec une clé primaire simple170
  - 5.2 Entité avec une clé primaire composée171
  - 5.3 Depuis une entité déjà chargée171
  - 5.3.1 FetchType.EAGER172
  - 5.3.2 FetchType.LAZY173
  - 5.4 Depuis une requête spécifique175
  - 5.5 Référence d'une entité176
  - 5.5.1 Chargement différé176
  - 6. Suppression d'une entité178
  - 6.1 Suppression simple179
  - 6.2 Suppression en cascade179
  - 6.3 Suppression d'une relation182
  - 7. Modification d'une entité184
  - 7.1 Modification des champs d'une entité184
  - 7.1.1 Depuis une entité managée185
  - 7.1.2 Depuis une entité non managée185
  - 7.2 Modification des relations d'une entité186
  - 7.2.1 Cas général186
  - 7.2.2 Cas particulier : @ManyToMany187
  - 7.3 Cas particuliers189
  - 7.3.1 Entité managée supprimée189
  - 7.3.2 Suite de modification d'une entité non managée190
  - 8. Synchronisation193
  - 8.1 De l'ORM vers la base de données193
  - 8.2 De la base de données vers l'entité194
  - Chapitre 5
  - Requêtes : les langages JPQL et HQL
  - 1. Introduction197
  - 2. Généralités198
  - 3. Types de requêtes198
  - 3.1 SELECT199
  - 3.2 UPDATE199
  - 3.3 DELETE200
  - 3.4 INSERT200
  - 4. La clause SELECT201
  - 5. La clause FROM202
  - 5.1 Variables d'identification202
  - 5.2 Référence à l'entité root202
  - 5.3 Les jointures203
  - 6. La clause WHERE205
  - 7. Les expressions206
  - 7.1 Alias206
  - 7.2 PATH206
  - 7.3 Paramètres206
  - 7.4 Littéral207
  - 7.4.1 Le littéral NULL207
  - 7.4.2 Le littéral booléen208
  - 7.4.3 Le littéral numérique208
  - 7.4.4 Le littéral string209
  - 7.4.5 Le littéral date209
  - 7.4.6 Le littéral énum209
  - 7.4.7 Le littéral d'entité209
  - 7.5 Type d'entité210
  - 7.6 Arithmétique210
  - 7.7 Fonctions d'agrégations211
  - 7.8 Fonctions scalaires211
  - 7.8.1 CONCAT212
  - 7.8.2 SUBSTRING212
  - 7.8.3 UPPER212
  - 7.8.4 LOWER212
  - 7.8.5 TRIM213
  - 7.8.6 LENGTH213
  - 7.8.7 LOCATE213
  - 7.8.8 ABS214
  - 7.8.9 MOD214
  - 7.8.10 SQRT214
  - 7.8.11 CURRENT_DATE214
  - 7.8.12 CURRENT_TIME215
  - 7.8.13 CURRENT_TIMESTAMP215
  - 7.9 Collections215
  - 7.9.1 Vérifier qu'une liste est vide215
  - 7.9.2 Taille d'une collection216
  - 7.9.3 Contrôler la présence d'un élément216
  - 8. Les clauses Group By et Having217
  - 9. La clause Order By218
  - 10. L'Update219
  - 10.1 Mise à jour de toutes les données220
  - 10.2 Mise à jour restrictive220
  - 11. Le Delete221
  - 11.1 Supprimer toutes les données221
  - 11.2 Suppressions restrictives222
  - 12. L'Insert222
  - Chapitre 6
  - L'API Criteria
  - 1. Introduction223
  - 2. L'API Metamodel225
  - 2.1 Le métamodèle dynamique226
  - 2.2 Le métamodèle statique226
  - 2.2.1 Attribut simple227
  - 2.2.2 Attribut basé sur une collection227
  - 2.2.3 Conclusion229
  - 3. Généralités229
  - 3.1 Utilisation du métamodèle230
  - 4. Le type d'opération232
  - 4.1 CriteriaQuery233
  - 4.1.1 Le type de retour233
  - 4.1.2 Paramétrage du périmètre234
  - 4.1.3 Paramétrage de la restriction234
  - 4.1.4 Paramétrage du regroupement235
  - 4.1.5 Paramétrage du retour235
  - 4.1.6 Paramétrage du tri236
  - 4.1.7 Préparation de la requête237
  - 4.1.8 Exécution de la requête238
  - 4.2 CriteriaUpdate239
  - 4.2.1 Type d'entité modifié239
  - 4.2.2 Paramétrage du périmètre240
  - 4.2.3 Initialisation des valeurs à modifier241
  - 4.2.4 Paramétrage de la restriction241
  - 4.2.5 Exécution de la requête242
  - 4.3 CriteriaDelete242
  - 4.3.1 Type d'entité modifié243
  - 4.3.2 Paramétrage du périmètre243
  - 4.3.3 Paramétrage de la restriction243
  - 4.3.4 Exécution de la requête244
  - 5. Le périmètre (FROM)244
  - 5.1 Root245
  - 5.2 Multiple Root245
  - 5.3 Jointures247
  - 5.3.1 Type de jointure247
  - 5.3.2 Modifier la condition de jointure248
  - 5.3.3 Multiple jointure249
  - 5.3.4 Fetch250
  - 6. Les restrictions (WHERE)251
  - 6.1 Avec Expression <Boolean>252
  - 6.2 Avec un Predicate252
  - 6.3 Avec plusieurs Predicate253
  - 6.4 Avec Predicate[]254
  - 6.5 Sans paramètre256
  - 7. Le regroupement (GROUP BY et HAVING)256
  - 7.1 GROUP BY258
  - 7.2 HAVING259
  - 8. Le tri (ORDER BY)261
  - 8.1 L'objet Order262
  - 8.2 ORDER BY263
  - 9. Les expressions265
  - 9.1 PATH265
  - 9.2 Paramètres266
  - 9.3 Tests et comparaisons (Predicate)267
  - 9.3.1 La nullité267
  - 9.3.2 Le booléen268
  - 9.3.3 La négation269
  - 9.3.4 L'égalité269
  - 9.3.5 L'infériorité et la supériorité270
  - 9.3.6 Le LIKE271
  - 9.3.7 Le BETWEEN271
  - 9.3.8 AND et OR271
  - 9.4 Opérations arithmétiques273
  - 9.5 Fonctions d'agrégation274
  - 9.6 Fonctions scalaires276
  - 9.6.1 Literal276
  - 9.6.2 CONCAT277
  - 9.6.3 SUBSTRING277
  - 9.6.4 UPPER277
  - 9.6.5 LOWER278
  - 9.6.6 TRIM278
  - 9.6.7 LENGTH279
  - 9.6.8 LOCATE279
  - 9.6.9 CASE279
  - 9.6.10 CURRENT_DATE281
  - 9.6.11 CURRENT_TIME281
  - 9.6.12 CURRENT_TIMESTAMP281
  - 9.7 Collections282
  - 9.7.1 Vérifier qu'une liste est vide282
  - 9.7.2 Taille d'une collection282
  - 9.7.3 Contrôler la présence d'un élément283
  - 10. Exemples285
  - 10.1 Écriture minimum285
  - 10.2 Écriture successive des méthodes285
  - 10.3 Requête dynamique286
  - Chapitre 7
  - Pour aller plus loin
  - 1. Maven289
  - 1.1 NetBeans289
  - 1.1.1 Configuration289
  - 1.1.2 Création d'un projet292
  - 1.2 Hibernate295
  - 1.3 MySQL295
  - 1.4 Exemple de fichier POM295
  - 2. Génération automatique296
  - 2.1 Génération des entités296
  - 2.2 Génération des tables303
  - 2.2.1 Configuration de l'action303
  - 2.2.2 Suppression et création304
  - 2.2.3 Chargement des données305
  - 2.2.4 Résumé306
  - 2.3 Génération du métamodèle307
  - 2.3.1 Avec l'annotation processor de NetBeans307
  - 2.3.2 Avec Maven312
  - 3. Gestion des caches315
  - 3.1 Généralités315
  - 3.2 Outils de gestion de cache de second niveau320
  - 3.2.1 Installation d'Ehcache320
  - 3.2.2 Configuration d'Ehcache321
  - 3.2.3 Paramétrage d'Hibernate322
  - 3.2.4 Entité et relation de type entité322
  - 3.2.5 Entité et relation de type liste326
  - 3.3 Conclusion329
  - 4. Les contrôles entre JPA et la base de données329
  - 4.1 Les EntityListener329
  - 4.2 Les convertisseurs332
  - 5. Pool de connexions334
  - 5.1 Installation335
  - 5.2 Configuration335
  - 6. Divers337
  - 6.1 Affichage des requêtes337
  - 6.2 Multithreading339
  - 6.3 Récupérer une session de l'implémentation340
  - 6.4 MVC341
  - Chapitre 8
  - Réalisation d'un projet
  - 1. Introduction347
  - 1.1 Import du projet348
  - 2. Définition du projet350
  - 2.1 L'application dans le système d'information350
  - 2.1.1 Java SE ou Java EE350
  - 2.1.2 Modification de données351
  - 2.1.3 Nombre d'exécutions de l'application351
  - 2.2 Fonctionnement de l'application351
  - 2.2.1 Gestion de la connexion351
  - 2.2.2 Temps de veille de l'application352
  - 2.2.3 Nombre de requêtes simultanées352
  - 2.2.4 Données de référence353
  - 2.2.5 Requêtes dynamiques353
  - 2.3 Création de l'application353
  - 2.3.1 Configuration initiale du projet354
  - 2.3.2 Création de JpaUtil356
  - 2.3.3 Vérification de la configuration357
  - 3. Mise en place du modèle357
  - 3.1 Création du modèle357
  - 3.2 Personnalisation du modèle357
  - 3.2.1 Vérifier les types358
  - 3.2.2 Vérifier les relations entre les entités358
  - 3.2.3 Modifier equals() et hashCode()359
  - 3.2.4 Ajouter des requêtes nommées359
  - 3.2.5 Mettre en place des générateurs spécifiques359
  - 3.2.6 Utiliser les listeners d'entités (@PrePersist...)359
  - 3.2.7 Cache de second niveau360
  - 3.3 Mise en place du métamodèle361
  - 4. Réalisation des contrôleurs363
  - 4.1 Création des contrôleurs363
  - 4.2 Personnalisation des contrôleurs364
  - 4.2.1 La construction du contrôleur364
  - 4.2.2 La gestion des opérations en cascade365
  - 4.2.3 Les données de référence366
  - 4.3 Contrôleur de plusieurs entités367
  - 5. L'utilisation368
  - 5.1 Création369
  - 5.2 Récupération de données371
  - 5.3 Modification373
  - 5.4 Suppression376
  - 6. La préparation de la livraison378
  - 6.1 Vérification des fichiers de configuration378
  - 6.1.1 Connexions à la base de données378
  - 6.1.2 Pool de connexions (c3p0)378
  - 6.1.3 L'implémentation379
  - 6.1.4 Cache de second niveau (ehcache)379
  - 6.1.5 Conclusion379
  - 6.2 Vérification des dépendances380
  - Index381
Origine de la notice:
- Electre