3. Opérations sur les entités

3.1. Introduction

Toutes les opérations que l'on peut faire sur des entités JPA passent directement ou indirectement par l' entity manager . Cet objet est central dans cette API. Ainsi, toute entité JPA persistante possède une référence sur l' entity manager qui l'a créée ou qui a permis de la retrouver, et un entity manager connaît toutes les entités JPA qu'il gère. Ces opérations peuvent être invoquées directement par appel à la méthode correspondante sur l' entity manager . Elles peuvent aussi être invoquées automatiquement sur les entités en relation d'une entité père. Par exemple, il est possible de propager une opération PERSIST d'une entité père vers les entités qu'elle a en relation. Nous verrons ce mécanisme de propagation en détails dans le chapitre suivant. Il n'est pas possible de mettre en relation une entité gérée par un entity manager avec une autre entité appartenant à un autre entity manager . En revanche, on peut lier une entité à un autre entity manager que celui avec lequel elle a été créée ou lue par une opération MERGE. Toutes les opérations de création, effacement ou modification doivent nécessairement se faire dans une transaction. Une transaction démarre sur appel à la méthode begin() de la transaction dans laquelle on se trouve, et est validée sur appel à sa méthode commit(). On peut annuler une transaction par appel à sa méthode rollback(). Les spécifications JPA définissent cinq opérations sur une entité : PERSIST, REMOVE, REFRESH, DETACH et MERGE. Ces opérations correspondent à autant de méthodes sur l'objet EntityManager.

3.2. Opération PERSIST

Cette opération a pour effet de rendre une entité persistante. Si cette entité est déjà persistante, alors cette opération n'a aucun effet. Rendre une entité persistante consiste à l'écrire en base sur le prochain commit de la transaction dans laquelle on se trouve.

3.3. Opération REMOVE

L'opération REMOVE a pour effet de rendre une entité non persistante. Si cette entité est déjà non persistante, alors cette opération n'a aucun effet. Une entité rendue non persistante sera effacée de la base sur le prochain commit de la transaction dans laquelle on se trouve.

3.4. Opération REFRESH

L'opération REFRESH ne s'applique qu'aux entités persistantes. Si l'entité passée en paramètre n'est pas persistante, alors une exception de type IllegalArgumentException est générée. L'opération REFRESH a pour effet de synchroniser l'état d'une entité avec son état en base. Si les champs d'une entité ont été modifiés dans la transaction courante, ces modifications seront donc effacées par cette opération. Si l'entité a été modifiée en base, alors ces modifications seront prises en compte lors d'un REFRESH.

3.5. Opération DETACH

Une opération DETACH sur une entité persistante a pour effet de la détacher de l' entity manager qui la gère. Cette entité persistante ne sera donc pas prise en compte lors du prochain commit de la transaction dans laquelle on se trouve.

3.6. Opération MERGE

Une opération MERGE sur une entité persistante attache cette entité à l' entity manager courant. On utilise cette opération pour associer une entité à un autre entity manager que celui qui a été utilisé pour la créer ou la lire. Un opération MERGE sur une entité qui a été effacée (opération REMOVE) génère une exception de type IllegalArgumentException.
JPA & EJB
Retour au blog Java le soir
Cours & Tutoriaux
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