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.

Des éléments complémentaires sont en téléchargement sur le site www.editions-eni.fr.


Les chapitres du livre :
Avant-propos – Environnement de développement – Concept des ORM – Préparation d'un projet – Manipulation des données – Requêtes : les langages JPQL et HQL – L'API Criteria – Pour aller plus loin – Réalisation d'un projet

Téléchargements

• Des fichiers complémentaires (223 Ko)

Avant-propos

1. Introduction
2. Contenu de l'ouvrage

Environnement de développement

1. Installation du JDK
2. Installation de NetBeans
3. Installation d'Hibernate
4. Installation de MySQL
5. Premier lancement de NetBeans
   1. 1. Mise en place des libraires
   2. 2. Création du projet

Concept des ORM

1. Introduction
2. Le concept
   1. 1. La norme : JPA
   2. 2. L’implémentation : Hibernate
3. La structuration des données
   1. 1. Introduction au mapping
   2. 2. Importance du mapping
   3. 3. Différentes techniques de mapping
4. La connexion aux données
   1. 1. Introduction aux sessions
   2. 2. Les différents types de sessions
   3. 3. L’utilisation d’une session
      1. a. RESOURCE_LOCAL avec Java SE
      2. b. RESOURCE_LOCAL avec Java EE
      3. c. JTA avec Java EE
5. L'interrogation des données
   1. 1. Introduction aux requêtes
   2. 2. Les requêtes natives
   3. 3. Les requêtes objets
   4. 4. Les requêtes nommées
   5. 5. Les requêtes "implicites"
   6. 6. L’API Criteria
6. Le cycle de vie des données
   1. 1. Introduction au cache
   2. 2. Les différents niveaux de caches
   3. 3. Cache de niveau 1 (L1)
   4. 4. Cache de niveau 2 (L2)
   5. 5. À retenir

Préparation d'un projet

1. Présentation du projet du livre
   1. 1. Description
   2. 2. Schéma de la base de données
2. Les possibilités de mapping
   1. 1. Fichier de mapping
   2. 2. Annotation
3. Paramétrage de l'ORM
   1. 1. Création du fichier persistence.xml
   2. 2. L’unité de persistance
   3. 3. L’implémentation de JPA utilisée
   4. 4. Les entités à mapper
   5. 5. Les propriétés du fichier de persistance
      1. a. Le driver de connexion à la base de données
      2. b. L’URL de la base de données
      3. c. Le login
      4. d. Le mot de passe
   6. 6. Le chargement du contexte de persistance
4. Les types persistables
   1. 1. Classes définies par l’utilisateur
      1. a. Classe d’entité
      2. b. Superclasse mappée
      3. c. Classe intégrable
   2. 2. Données Java simples
   3. 3. Valeur multiple
   4. 4. Divers
5. Les différents champs
   1. 1. Les champs temporaires
   2. 2. Les champs persistables
      1. a. L’annotation @Basic
      2. b. L’annotation @Column
      3. c. L’annotation @Temporal
6. Les clés primaires
   1. 1. Clé primaire simple
   2. 2. Clé primaire composée
7. Les valeurs générées
   1. 1. Valeur fixe
   2. 2. Valeur incrémentielle
      1. a. GenerationType.AUTO
      2. b. GenerationType.IDENTITY
      3. c. GenerationType.TABLE
      4. d. GenerationType.SEQUENCE
8. Les relations
   1. 1. Les relations 1-1 (OneToOne)
   2. 2. Les relations n-1 (ManyToOne)
   3. 3. Les relations 1-n (OneToMany)
   4. 4. Les relations n-n (ManyToMany)
   5. 5. Les relations n-n avec données sur la jointure
9. Type de chargement des données
   1. 1. Lazy
   2. 2. Eager
   3. 3. Mise en place
10. Particularités sur les entités
    1. 1. Sérialisation
    2. 2. Equals et HashCode
       1. a. Implémentation par défaut
       2. b. Implémentation basée sur la clé primaire
       3. c. Implémentation basée sur une clé métier
       4. d. Conclusion

Manipulation des données

1. Préparation
2. Établissement de la connexion
   1. 1. EntityManagerFactory
      1. a. Avec conteneur JEE, en RESOURCE_LOCAL
      2. b. Sans conteneur JEE, en RESOURCE_LOCAL
   2. 2. EntityManager
      1. a. Avec conteneur JEE, en JTA
      2. b. Avec conteneur JEE, en RESOURCE_LOCAL
      3. c. Sans conteneur JEE, en RESOURCE_LOCAL
   3. 3. État d’une entité
3. Les transactions
   1. 1. Exécution d’une transaction
   2. 2. Méthodes diverses sur les transactions
      1. a. Vérifier que la transaction est active
      2. b. Empêcher la modification via la transaction
4. Création d'une entité
   1. 1. Création d’une entité simple
   2. 2. Création d’une arborescence d’entités
      1. a. Relation avec identifiant différent
      2. b. Relation avec identifiant partagé
      3. c. L’annotation @PrePersist
      4. d. Le générateur génériqued’Hibernate
   3. 3. Cascade avec une table de jointure
   4. 4. Création d’une entité avec clé primairecomposée
5. Récupération d'une entité
   1. 1. Entité avec une clé primaire simple
   2. 2. Entité avec une clé primaire composée
   3. 3. Depuis une entité déjà chargée
      1. a. FetchType.EAGER
      2. b. FetchType.LAZY
   4. 4. Depuis une requête spécifique
   5. 5. Référence d’une entité
      1. a. Chargement différé
6. Suppression d'une entité
   1. 1. Suppression simple
   2. 2. Suppression en cascade
   3. 3. Suppression d’une relation
7. Modification d'une entité
   1. 1. Modification des champs d’une entité
      1. a. Depuis une entité managée
      2. b. Depuis une entité non managée
   2. 2. Modification des relations d’une entité
      1. a. Cas général
      2. b. Cas particulier : @ManyToMany
   3. 3. Cas particuliers
      1. a. Entité managée supprimée
      2. b. Suite de modification d’une entité non managée
8. Synchronisation
   1. 1. De l’ORM vers la base de données
   2. 2. De la base de données vers l’entité

Requêtes : les langages JPQL et HQL

1. Introduction
2. Généralités
3. Types de requêtes
   1. 1. SELECT
   2. 2. UPDATE
   3. 3. DELETE
   4. 4. INSERT
4. La clause SELECT
5. La clause FROM
   1. 1. Variables d’identification
   2. 2. Référence à l’entité root
   3. 3. Les jointures
6. La clause WHERE
7. Les expressions
   1. 1. Alias
   2. 2. PATH
   3. 3. Paramètres
   4. 4. Littéral
      1. a. Le littéral NULL
      2. b. Le littéral booléen
      3. c. Le littéral numérique
      4. d. Le littéral string
      5. e. Le littéral date
      6. f. Le littéral énum
      7. g. Le littéral d’entité
   5. 5. Type d’entité
   6. 6. Arithmétique
   7. 7. Fonctions d’agrégations
   8. 8. Fonctions scalaires
      1. a. CONCAT
      2. b. SUBSTRING
      3. c. UPPER
      4. d. LOWER
      5. e. TRIM
      6. f. LENGTH
      7. g. LOCATE
      8. h. ABS
      9. i. MOD
      10. j. SQRT
      11. k. CURRENT_DATE
      12. l. CURRENT_TIME
      13. m. CURRENT_TIMESTAMP
   9. 9. Collections
      1. a. Vérifier qu’une liste est vide
      2. b. Taille d’une collection
      3. c. Contrôler la présence d’un élément
8. Les clauses GROUP BY et HAVING
9. La clause ORDER BY
10. L'UPDATE
    1. 1. Mise à jour de toutes les données
    2. 2. Mise à jour restrictive
11. Le DELETE
    1. 1. Supprimer toutes les données
    2. 2. Suppressions restrictives
12. L'INSERT

L'API Criteria

1. Introduction
2. L'API Metamodel
   1. 1. Le métamodèle dynamique
   2. 2. Le métamodèle statique
      1. a. Attribut simple
      2. b. Attribut basé sur une collection
      3. c. Conclusion
3. Généralités
   1. 1. Utilisation du métamodèle
4. Le type d'opération
   1. 1. CriteriaQuery
      1. a. Le type de retour
      2. b. Paramétrage du périmètre
      3. c. Paramétrage de la restriction
      4. d. Paramétrage du regroupement
      5. e. Paramétrage du retour
      6. f. Paramétrage du tri
      7. g. Préparation de la requête
      8. h. Exécution de la requête
   2. 2. CriteriaUpdate
      1. a. Type d’entité modifié
      2. b. Paramétrage du périmètre
      3. c. Initialisation des valeurs à modifier
      4. d. Paramétrage de la restriction
      5. e. Exécution de la requête
   3. 3. CriteriaDelete
      1. a. Type d’entité modifié
      2. b. Paramétrage du périmètre
      3. c. Paramétrage de la restriction
      4. d. Exécution de la requête
5. Le périmètre (FROM)
   1. 1. Root
   2. 2. Multiple Root
   3. 3. Jointures
      1. a. Type de jointure
      2. b. Modifier la condition de jointure
      3. c. Multiple jointure
      4. d. Fetch
6. Les restrictions (WHERE)
   1. 1. Avec Expression<boolean></boolean>
   2. 2. Avec un Predicate
   3. 3. Avec plusieurs Predicate
   4. 4. Avec Predicate[]
   5. 5. Sans paramètre
7. Le regroupement (GROUP BY et HAVING)
   1. 1. GROUP BY
   2. 2. HAVING
8. Le tri (ORDER BY)
   1. 1. L’objet Order
   2. 2. ORDER BY
9. Les expressions
   1. 1. PATH
   2. 2. Paramètres
   3. 3. Tests et comparaisons (Predicate)
      1. a. La nullité
      2. b. Le booléen
      3. c. La négation
      4. d. L’égalité
      5. e. L’infériorité et la supériorité
      6. f. Le LIKE
      7. g. Le BETWEEN
      8. h. AND et OR
   4. 4. Opérations arithmétiques
   5. 5. Fonctions d’agrégation
   6. 6. Fonctions scalaires
      1. a. Literal
      2. b. CONCAT
      3. c. SUBSTRING
      4. d. UPPER
      5. e. LOWER
      6. f. TRIM
      7. g. LENGTH
      8. h. LOCATE
      9. i. CASE
      10. j. CURRENT_DATE
      11. k. CURRENT_TIME
      12. l. CURRENT_TIMESTAMP
   7. 7. Collections
      1. a. Vérifier qu’une liste est vide
      2. b. Taille d’une collection
      3. c. Contrôler la présence d’un élément
10. Exemples
    1. 1. Écriture minimum
    2. 2. Écriture successive des méthodes
    3. 3. Requête dynamique

Pour aller plus loin

1. Maven
   1. 1. NetBeans
      1. a. Configuration
      2. b. Création d’un projet
   2. 2. Hibernate
   3. 3. MySQL
   4. 4. Exemple de fichier POM
2. Génération automatique
   1. 1. Génération des entités
   2. 2. Génération des tables
      1. a. Configuration de l’action
      2. b. Suppression et création
      3. c. Chargement des données
      4. d. Résumé
   3. 3. Génération du métamodèle
      1. a. Avec l’annotation processor de NetBeans
      2. b. Avec Maven
3. Gestion des caches
   1. 1. Généralités
   2. 2. Outils de gestion de cache de second niveau
      1. a. Installation d’Ehcache
      2. b. Configuration d’Ehcache
      3. c. Paramétrage d’Hibernate
      4. d. Entité et relation de type entité
      5. e. Entité et relation de type liste
   3. 3. Conclusion
4. Les contrôles entre JPA et la base de données
   1. 1. Les EntityListener
   2. 2. Les convertisseurs
5. Pool de connexions
   1. 1. Installation
   2. 2. Configuration
6. Divers
   1. 1. Affichage des requêtes
   2. 2. Multithreading
   3. 3. Récupérer une session de l’implémentation
   4. 4. MVC

Réalisation d'un projet

1. Introduction
   1. 1. Import du projet
2. Définition du projet
   1. 1. L’application dans le système d’information
      1. a. Java SE ou Java EE
      2. b. Modification de données
      3. c. Nombre d’exécutions de l’application
   2. 2. Fonctionnement de l’application
      1. a. Gestion de la connexion
      2. b. Temps de veille de l’application
      3. c. Nombre de requêtes simultanées
      4. d. Données de référence
      5. e. Requêtes dynamiques
   3. 3. Création de l’application
      1. a. Configuration initiale du projet
      2. b. Création de JpaUtil
      3. c. Vérification de la configuration
3. Mise en place du modèle
   1. 1. Création du modèle
   2. 2. Personnalisation du modèle
      1. a. Vérifier les types
      2. b. Vérifier les relations entre les entités
      3. c. Modifier equals() et hashCode()
      4. d. Ajouter des requêtes nommées
      5. e. Mettre en place des générateursspécifiques
      6. f. Utiliser les listeners d’entités (@PrePersist…)
      7. g. Cache de second niveau
   3. 3. Mise en place du métamodèle
4. Réalisation des contrôleurs
   1. 1. Création des contrôleurs
   2. 2. Personnalisation des contrôleurs
      1. a. La construction du contrôleur
      2. b. La gestion des opérations en cascade
      3. c. Les données de référence
   3. 3. Contrôleur de plusieurs entités
5. L'utilisation
   1. 1. Création
   2. 2. Récupération de données
   3. 3. Modification
   4. 4. Suppression
6. La préparation de la livraison
   1. 1. Vérification des fichiers de configuration
      1. a. Connexions à la base de données
      2. b. Pool de connexions (c3p0)
      3. c. L’implémentation
      4. d. Cache de second niveau (ehcache)
      5. e. Conclusion
   2. 2. Vérification des dépendances