Java Persistence API

José Paumard


Table des matières

Introduction
1. Objet du mapping objet / relationnel
2. Un peu d'histoire
Un premier exemple
1. Introduction
2. Création de l'environnement technique
2.1. Introduction
2.2. Création de la base Derby
2.3. Création du projet NetBeans et d'une première entité
2.4. Structure d'un projet persistant
2.5. Une première classe persistante
2.6. Un premier fichier persistence.xml
3. Utilisation de ce premier exemple
3.1. Écriture du code d'utilisation
3.2. Exécution de notre premier exemple
3.3. Modification de la class Marin
3.4. Opérations CRUD
Mettre un jeu de classes en base
1. Introduction
2. Définition d'une entité JPA
2.1. Écriture de l'entité
2.2. Annotation de l'entité
2.3. Annotations des champs
2.4. Exemple d'utilisation
3. Opérations sur les entités
3.1. Introduction
3.2. Opération PERSIST
3.3. Opération REMOVE
3.4. Opération REFRESH
3.5. Opération DETACH
3.6. Opération MERGE
4. Mise en relation d'entités
4.1. Introduction
4.2. Relations unidirectionnelles et bidirectionnelles
4.3. Relation 1:1
4.4. Relation 1:p
4.5. Relation p:1
4.6. Relation n:p
4.7. Comportement cascade
4.8. Effacement des entités orphelines
5. Charger des entités et leurs relations
6. Objets inclus
6.1. Introduction
6.2. Déclaration d'un objet inclus
6.3. Utilisation d'objets inclus
6.4. Cas où l'objet inclus est nul
6.5. Renommer les colonnes incluses
6.6. Collections d'objets inclus
L'API Collection en base
1. Introduction
2. Enregistrer une collection d'entités
2.1. Enregistrement d'une collection simple
2.2. Enregistrement d'un Set
2.3. Enregistrement d'une List
3. Enregistrer une collection de types de base
4. Enregistrement d'une Map
4.1. Table de hachage de type (type de base, entité)
4.2. Cas où la clé est un champ de la valeur
4.3. Cas d'une table (entité, entité)
Héritage
1. Introduction
2. Enregistrement d'une hiérarchie de classes
2.1. Entité et super-classe non enregistrée
2.2. Position du problème
2.3. Trois façons de faire
3. Stratégie SINGLE_TABLE
3.1. Fonctionnement
3.2. Mise en place
3.3. Limitations
4. Stratégie JOINED
4.1. Fonctionnement
4.2. Mise en place
4.3. Limitations
5. Stratégie TABLE_PER_CLASS
5.1. Fonctionnement
5.2. Mise en place
5.3. Limitations
Requêtes
1. Introduction
2. Un premier exemple
2.1. Écriture d'une première requête
2.2. Exécution d'une première requête
2.3. Exécution d'une première requête d'agrégation
3. Définition de requêtes
3.1. Requêtes dynamiques
3.2. Requêtes paramétrées
3.3. Requêtes nommées
3.4. Requêtes natives
4. Exécution, analyse du résultat
4.1. Exécution d'une requête dynamique
4.2. Exécution d'une requête nommée
4.3. Analyse du résultat
4.4. Cas des résultats de grande taille
4.5. Remarques
5. Clause From
5.1. Définition des entités
5.2. Jointures dans la clause From
5.3. Remarque finale sur les jointures en JPQL
6. Clause Where
6.1. Variables et chemins dans une clause where
6.2. Expressions conditionnelles et opérateurs
6.3. Requêtes imbriquées
6.4. Opérateurs any, all et some
6.5. Expressions fonctionnelles
7. Clauses Group By et Having
8. Opérations Update et Delete
EJB
1. Introduction
2. Un premier exemple
2.1. Introduction
2.2. Installation dans Glassfish à l'aide de Netbeans
2.3. Création d'un premier EJB
2.4. Déploiement de notre premier EJB
2.5. Création d'un client
3. Mise en oeuvre du pattern session facade
3.1. Introduction
3.2. Modèle objet
3.3. Définition de l'unité de persistance
3.4. Assemblage de notre application
3.5. Assemblage et déploiement
3.6. Utilisation du client
4. Opération de persistance en façade
4.1. Introduction
4.2. Enrichissement du service
4.3. Création de la méthode findMarinById(long)
4.4. Ajout de la méthode findAllMarins()
4.5. Utilisation dans un code client
5. Types d'EJB
5.1. Introduction
5.2. Qu'est-ce qu'un EJB ?
5.3. Écriture d'un EJB session
5.4. Qu'est-ce qu'une méthode métier ?
5.5. EJB avec ou sans état
5.6. Gestion des transactions
5.7. Restrictions
6. Cycle de vie d'un EJB
6.1. Cas des EJB sans état
6.2. Cas des EJB avec état
6.3. Injection de dépendances
7. Transaction gérée par l'EJB
7.1. Introduction
7.2. Déclaration du mode transactionnel
7.3. Gestion de la transaction
7.4. Fonctionnement de la transaction
7.5. Cas des EJB avec état
8. Transaction gérée par le serveur
8.1. Introduction
8.2. Déclaration du mode transactionnel
8.3. Gestion de la transaction
8.4. Fonctionnement de la transaction
8.5. Remarques
9. Intercepteurs
9.1. Introduction
9.2. Aperçu général
9.3. Cycle de vie d'un intercepteur
9.4. Object InvocationContext
9.5. Interception d'un EJB ou d'une méthode métier
9.6. Exemple de mise en œuvre d'un intercepteur

Liste des illustrations

1. Création de la base Derby
2. Connexion à la base Derby
3. Création d'une première entité JPA
4. Création de l'entité Marin
5. Choix de la base et de l'implémentation
6. Structure du projet NetBeans
7. État de la base de données après une première exécution
8. État de la base de données après modification de la classe Marin
9. Schéma pour une relation 1:1 unidirectionnelle
10. Schéma pour une relation 1:p unidirectionnelle
11. Schéma pour une relation 1:p bidirectionnelle
12. Schéma pour une relation p:1 unidirectionnelle
13. Schéma pour une relation n:p unidirectionnelle
14. Schéma pour un objet inclus - 1
15. Schéma pour un objet inclus - 2
16. Schéma pour deux objets inclus
17. Schéma pour une relation multivaluée avec table de jointure ordonnée par une colonne technique
18. Schéma pour une relation multivaluée ordonnée par une colonne technique sans table de jointure
19. Schéma pour une liste ordonnée de types de base
20. Schéma pour une table de hachage (type de base, entité)
21. Schéma pour une table où la clé est un champ de la valeur
22. Schéma pour une table de hachage (entité, entité)
23. Schéma pour une hiérarchie SINGLE_TABLE
24. Schéma pour une hiérarchie JOINED
25. Schéma pour une hiérarchie TABLE_PER_CLASS
26. Création d'une application d'entreprise
27. Nommage du projet JEE
28. Choix du serveur d'application et de la version de JEE
29. Structure du projet final
30. Création d'un module d'interfaces
31. Structure du projet interfaces
32. Ajout du projet interface en dépendance du projet EJB
33. Structure du projet EJB avec implémentation
34. Ajout du projet interface en dépendance de l'EAR
35. Packaging du projet EAR
36. Structure du projet ejb-client
37. Structure du projet modèle
38. Structure du projet de persistance
39. Création d'une source de données via Netbeans
40. Sélection d'une ressource JDBC
41. Création de la source de données
42. Définition d'une réserve de connexions
43. Structure des cinq modules
44. Assemblage final de l'EAR

Liste des exemples

1. Une première classe persistante
2. Un premier persistence.xml
3. Un premier code utilisant une classe persistante
4. Utilisation de la méthode entityManager.find(...)
5. Annotations @Entity et @Table
6. Entité JPA avec colonnes annotées
7. Relation 1:1 unidirectionnelle
8. Relation 1:1 bidirectionnelle
9. Relation 1:p unidirectionnelle
10. Relation 1:p bidirectionnelle
11. Relation p:1 unidirectionnelle
12. Relation n:p unidirectionnelle
13. Relation n:p bidirectionnelle
14. Comportement cascade sur une relation @OneToOne
15. Effacement des orphelins sur une relation @OneToOne
16. Utilisation de fecth sur une relation
17. Déclaration d'objets inclus
18. Utilisation d'objets inclus
19. Champ inclus nul
20. Renommage des colonnes des objets inclus
21. Ordonner les éléments d'une liste par un de leurs champs
22. Ordonner les éléments d'une liste à l'aide du colonne technique
23. Collection de types de base, ordonnée
24. Table de hachage (type de base, entité)
25. Table où la clé est un champ de la valeur
26. Table de hachage (entité, entité)
27. Hiérarchie simple
28. Stratégie SINGLE_TABLE
29. Une première requête JPQL
30. Exécution d'une première requête
31. Une première requête d'agrégation
32. Une (mauvaise) requête dynamique paramétrée
33. Paramètrage d'une requête, première méthode
34. Paramètrage d'une requête, deuxième méthode
35. Paramètrage d'une requête, cas des dates
36. Déclaration de requêtes nommées
37. Exécution d'une requête nommée
38. Écriture d'une requête ne retournant pas des entités
39. Analyse d'une requête ne retournant pas des entités
40. Objet résultat : NameBean
41. Requête retournant un objet résultat
42. Analyse d'une requête retournant un objet résultat
43. Une première jointure JPQL implicite
44. Une première jointure JPQL explicite
45. Une jointure externe JPQL
46. SQL généré par une jointure externe JPQL
47. SQL généré sans jointure externe JPQL
48. Jointure fetch
49. SQL généré pour une jointure fetch
50. Requête jointe sans clause where
51. Utilisation de l'opérateur In
52. Requête imbriquée
53. Opérateur some
54. Fonction TYPE
55. Agrégation JPQL
56. Une première interface d'EJB
57. Une première implémentation d'un EJB
58. Fichier jndi.properties dans le cas de Glassfish
59. Une première connexion à un EJB
60. Classe Marin du modèle
61. Fichier persistence.xml
62. Injection de l'entity manager dans un EJB
63. Ajout de la méthode findMarinById(long)
64. Création d'une requête nommée sur la classe Marin
65. Utilisation d'une requête nommée dans un EJB
66. Code de l'application cliente
67. Éléments injectés dans un EJB
68. Annotation sur un EJB en mode bean managed transaction
69. Injection d'une transaction dans un EJB
70. Injection de sources de données et entity manager
71. Annotation sur un EJB en mode container managed transaction
72. Exemple d'intercepteur
73. Écriture d'un intercepteur
74. Déclaration d'intercepteurs sur un EJB
75. Annotation @StringNotNull
76. Utilisation de l'annotation @StringNotNull
77. Intercepteur associé à @StringNotNull
78. Interception finale de l'EJB MarinServiceImpl
JPA & EJB
Retour au blog Java le soir
Cours & Tutoriaux