JPA avec EclipseLink

Achref El Mouelhi

Docteur de l’université d’Aix-Marseille

Chercheur en programmation par contrainte (IA)
Ingénieur en génie logiciel

[Link]@[Link]

H & H: Research and Training 1 / 94

 Plan

1 Introduction

2 Créer une connexion

3 Créer un JPA Project

4 Entity
Création d’une entité
Création de tables associées aux entités
Création des entités à partir d’une BD existante

H & H: Research and Training 2 / 94

 Plan

5 EntityManager
Insertion
Mise à jour
Suppression
Consultation

6 JPQL : Java Persistence Query Language

7 Relation entre entités

OneToOne
ManyToOne
OneToMany
ManyToMany
Inheritance

H & H: Research and Training 3 / 94

 Plan

8 Les classes incorporables

9 Les méthodes callback

10 Utilisation de l’API JPA dans un projet JEE

11 Utilisation de l’API JPA dans un projet Maven

H & H: Research and Training 4 / 94

 Introduction

Object-Relational Mapping (lien objet-relationnel)

Définition
est une couche d’abstraction à la base de données

I ©
est une classe qui permet à l’utilisateur d’utiliser les tables d’une
H
base de données comme des objets
U EL
O
consiste à associer :
f E LM
r e
une ou plusieurs classes à chaque table
chclasse à chaque colonne de la table
© A
un attribut de

a comme objectif de ne plus écrire de requête SQL

H & H: Research and Training 5 / 94

 Introduction

Object-Relational Mapping (lien objet-relationnel)

Définition
est une couche d’abstraction à la base de données

I ©
est une classe qui permet à l’utilisateur d’utiliser les tables d’une
H
base de données comme des objets
U EL
O
consiste à associer :
f E LM
r e
une ou plusieurs classes à chaque table
chclasse à chaque colonne de la table
© A
un attribut de

a comme objectif de ne plus écrire de requête SQL

Plusieurs ORM proposés pour chaque Langage de POO.

H & H: Research and Training 5 / 94

 Introduction

Object-Relational Mapping
Pour Java
EclipseLink
Hibernate

H I ©
Java Data Objects (JDO)
UEL
O
LM
...

r e f E
ch
©A

H & H: Research and Training 6 / 94

 Introduction

Object-Relational Mapping
Pour Java
EclipseLink
Hibernate

H I ©
Java Data Objects (JDO)
UEL
O
LM
...

Quel choix pour PHP ? ! r e f E

ch
Doctrine ©A
pdoMap
RedBean
...
H & H: Research and Training 6 / 94
 Introduction

JPA

EclipseLink ?
H I ©
EL
est un framework open source de mapping objet-relation
U
L MO(un framework d’ORM open
est dérivé du projet TopLink d’Oracle
e
source acheté par Oracle
r f Een 2002)
supporte l’APIA cdehpersistence de données JPA
©

H & H: Research and Training 7 / 94

 Introduction

JPA

JPA : Java Persistence API

I ©
est une interface standardisée par Sun, qui permet l’organisation
H
des données
UEL
O
f E LM
a été proposé par JSR (Java Specification Requests)

r e
s’appuie sur l’utilisation des annotations pour définir le lien entre
ch
©A
Entity (classe) et table (en base de données relationnelle) et sur
le gestionnaire EntityManager pour gérer les données
(insertion, modification...)

H & H: Research and Training 8 / 94

 Introduction

JPA

Étapes

Création d’une connexion

H I ©
Création d’un JPA Project
UEL
O
f E LM
Création des entités et bien utiliser les annotations

r e
Établissement de liens entre entités
ch
©A
Création des tables, à partir des entités, si elles n’existent pas
Manipulation des entités (ajout, suppression, modification,
consultation) avec EntityManager

H & H: Research and Training 9 / 94

 Créer une connexion

Créer une connexion

Avant de créer une connexion

créer une base de données appelée jpa

H I ©
UEL
O
f E LM
ch r e
©A

H & H: Research and Training 10 / 94

 Créer une connexion

Créer une connexion

Avant de créer une connexion

créer une base de données appelée jpa

Création d’une connexion à la base de données (jpa)

H I ©
U
Aller dans menu File ensuite New et enfin choisir OtherEL
O
Chercher Connection Profile

f E LM
r e
Sélectionner le SGBD (dans notre cas MySQL)
ch
©A
Attribuer un nom à cette connexion dans Name

Cliquer sur New Driver Definition devant la liste déroulante de Drivers

Définir le driver en choisissant le dernier MySQL JDBC DRIVER, en précisant son

emplacement dans la rubrique JAR List, en supprimant celui qui existait et en modifiant
les données dans la rubrique Properties

Vérifier ensuite l’URL, User name, Password et DataBase Name (jpa) et Valider

H & H: Research and Training 10 / 94

 Créer une connexion

Création d’une connexion

H I ©
EL
Tester la connexion
Aller dans l’onglet Data Source Explorer O U
f E LM
ch r e
Faire un clic droit et ensuite choisir Connect

©A

H & H: Research and Training 11 / 94

 Créer un JPA Project

JPA
Création d’un projet JPA

Aller dans menu File > New > JPA Project

Saisir FirstJpaProject comme nom du projet

H I ©
EL
Choisir jre1.8 dans Target runtime et cliquer deux fois sur Next
U
O
f E LM
Dans Platform, choisir la dernière version d’EclipseLink (2.5.2)

ch r e
Dans Type de JPA Implementation, choisir User Library

©A
Ensuite cocher la case EclipseLink et cliquer sur Download
Library... à droite (pour démarrer le téléchargement)

Dans Connection, choisir la connexion définie précédemment

Cocher la case Add driver library to build path et valider

H & H: Research and Training 12 / 94

 Créer un JPA Project

JPA

Le fichier [Link]
H I ©
EL
OU
est situé dans le répertoire META-INF de src
M
f E
contient les données sur le L entre nos entités/ et nos
mapping
e
chrde données
tables dans la base
© A

H & H: Research and Training 13 / 94

 Entity

Une entité (Entity)

Définition
H I ©
U
correspond à une table d’une base de donn L relationnelle
Eées
O informations
Mquelques
f L
est un objet (Javabean) contenant
E pour le mapping (faire le lien) avec la
r e
indispensables (annotations)
ch
base de donn
© A ées

H & H: Research and Training 14 / 94

 Entity Création d’une entité

Une entité
Pour une meilleure organisation

Créer un package [Link] sous src

Placer toutes les entités dans ce package

H I ©
U EL
O
f E LM
ch r e
©A

H & H: Research and Training 15 / 94

 Entity Création d’une entité

Une entité
Pour une meilleure organisation

Créer un package [Link] sous src

Placer toutes les entités dans ce package

H I ©
EL
Création
M OU
f E L
Faire un clic droit sur [Link], aller dans new et choisir JPA
Entity
c hr e
© A
Saisir un nom dans Class name:, ensuite cliquer sur Next

Avec le bouton Add..., ajouter les différents attributs ainsi que leur type

Cocher la case correspondant à la clé primaire puis cliquer sur Finish

Vérifier dans [Link] que la ligne

<class>[Link]</class> a bien été ajoutée.
H & H: Research and Training 15 / 94
 Entity Création d’une entité

Une entité
public Personne() {
package [Link]; super();
import [Link]; }
import [Link];
import [Link].*; public int getNum() {
return [Link];
/**
* Entity implementation class for
}
H I ©
EL
public void setNum(int num) {
Entity: Personne [Link] = num;
*
O } U
LM
*/ public String getNom() {
@Entity
public class Personne implements
r e f E }
return [Link];

Serializable {
ch public void setNom(String nom) {

@Id ©A
@GeneratedValue (strategy=
}
[Link] = nom;

public String getPrenom() {

[Link]) return [Link];
private int num; }
private String nom; public void setPrenom(String
private String prenom; prenom) {
[Link] = prenom;
private static final long }
serialVersionUID = 1L; }
H & H: Research and Training 16 / 94
 Entity Création d’une entité

Une entité
Autres annotations
Annotation désignation
@Entity permet de qualifier la classe comme entité
@Id indique l’attribut qui correspond à la clé primaire de la table
@Table décrit la table désignée par l’entité
@Column définit les propriétés d’une colonne
H I ©
EL
@IdClass indique que l’entité annotée contient une clé composée

U
les champs constituant la clé seront annoté par @Id
O
LM
@GeneratedValue s’applique sur les attributs annotés par @Id
permet la génération automatique de la clé primaire

r e f E
ch
©A

H & H: Research and Training 17 / 94

 Entity Création d’une entité

Une entité
Autres annotations
Annotation désignation
@Entity permet de qualifier la classe comme entité
@Id indique l’attribut qui correspond à la clé primaire de la table
@Table décrit la table désignée par l’entité
@Column définit les propriétés d’une colonne
H I ©
EL
@IdClass indique que l’entité annotée contient une clé composée

U
les champs constituant la clé seront annoté par @Id
O
LM
@GeneratedValue s’applique sur les attributs annotés par @Id
permet la génération automatique de la clé primaire

r e f E
// la classe Personne
ch
©A
// la classe PersonnePK
@IdClass([Link]) public class PersonnePK {
@Entity @Id
public class Personne implements private String nom;
Serializable { @Id
@Id private String prenom;
private String nom; // ensuite getters, setters,
@Id constructeur sans parametres et
private String prenom; constructeur avec deux
// ensuite getters, setters et parametres nom et prenoms
constructeur
H & H: Research and Training 17 / 94
 Entity Création d’une entité

Une entité

Attributs de l’annotation @Column

Attribut désignation H I ©
name permet de définir le nom de la colonne
U EL
O
LM
s’il est différent de celui de l’attribut
length
unique
r e f E
permet de fixer la longueur d’une chaı̂ne de caractères
indique que la valeur d’un champ est unique
ch
©A
nullable précise si un champ est null (ou non)
... ...

H & H: Research and Training 18 / 94

 Entity Création d’une entité

Une entité

Attributs de l’annotation @Table

Attribut désignation
name permet de définir le nom de la table
I
s’il est différent de celui de l’entité
H ©
uniqueConstraints
un ensemble de colonnes U EL
permet de définir des contraintes d’unicité sur

O
f E LM
@Table(
ch r e
©A
name="personne",
uniqueConstraints={
@UniqueConstraint(name="nom_prenom", columnNames
={"nom", "prenom"})
}
)

H & H: Research and Training 19 / 94

 Entity Création d’une entité

Une entité

H I ©
L’annotation @Transient
U EL
O
LM
L’attribut annoté par @Transient n’aura pas de colonne associée

r e f E
dans la table correspondante à l’entité en base de données.

ch
©A

H & H: Research and Training 20 / 94

 Entity Création de tables associées aux entités

Création de tables associées aux entités

Étapes
H I ©
Un clic droit sur le projet U EL
O
Aller dans JPA Tools
f E LM
r e
ch Tables from Entities
A
Choisir Generate
©

H & H: Research and Training 21 / 94

 Entity Création des entités à partir d’une BD existante

Création des entités à partir d’une BD existante

Étapes
Un clic droit sur le projet
H I ©
Aller dans JPA Tools
U EL
M O
Choisir Generate Entities
f E L from Tables
c h re ensuite les tables à importer
Sélectionner la connexion
Choisir ©
A
le package dans lequel les entités seront importées
Valider

H & H: Research and Training 22 / 94

 Entity Création des entités à partir d’une BD existante

Création des entités à partir d’une BD existante

Si les entités ne contiennent pas les colonnes

Supprimer les entités générées

H I ©
U
Utiliser le Data Source Name pour se déconnecter et se EL
O
reconnecter
f E LM
ch r e
(vous pouvez même dans certains cas étendre l’arborescence de

©A
chaque table dans le Data Source Name)
Régénérer les entités

H & H: Research and Training 23 / 94

 EntityManager

EntityManager
Pour persister les données, il faut

ajouter les données concernant la connexion à la base de données dans

le fichier [Link]

I ©
instancier et utiliser un gestionnaire d’entités pour manipuler les
H
données
U EL
O
f E LM
ch r e
©A

H & H: Research and Training 24 / 94

 EntityManager

EntityManager
Pour persister les données, il faut

ajouter les données concernant la connexion à la base de données dans

le fichier [Link]

I ©
instancier et utiliser un gestionnaire d’entités pour manipuler les
H
données
U EL
M O
f L
E ?
Gestionnaire d’entités (EntityManager)

ch r e
© A
est une classe Java

assure l’interaction entre la base de données et les entités

permet via les entités, définies dans la section persistence-unit du

fichier [Link], de lire ou écrire des données dans la base
de données

H & H: Research and Training 24 / 94

 EntityManager

EntityManager

Comment obtenir une instance d’EntityManager

I ©
il faut utiliser une fabrique de type EntityManagerFactory
H
U EL
Cette dernière a une méthode createEntityManager() qui
M
permet d’obtenir un EntityManager O
E L
f de la fabrique, il faut utiliser la méthode
r e
Pour obtenir une instance
c h
© A qui prend comme paramètre le nom de l’unité de
statique createEntityManagerFactory() de la classe
Persistence
persistence à utiliser (défini dans le fichier [Link])

H & H: Research and Training 25 / 94

 EntityManager

EntityManager
Le fichier [Link]
<?xml version="1.0" encoding="UTF-8"?>
<persistence version="2.1"
xmlns="[Link]
xmlns:xsi="[Link]
H I ©
EL
xsi:schemaLocation="[Link]
U
persistence [Link]
O
LM
persistence_2_1.xsd">

r e f E
<persistence-unit name="FirstJpaProject">

ch
<class>[Link]</class>

©A
</persistence-unit>
</persistence>

Obtenir l’EntityManager
EntityManagerFactory emf = Persistence.
createEntityManagerFactory("FirstJpaProject");
EntityManager em = [Link]();

H & H: Research and Training 26 / 94

 EntityManager

EntityManager

Quelques méthodes de l’EntityManager

persist(obj) : pour stocker obj dans la base de données

H I ©
find(NomClasse, id) : pour chercherE unLélément de type
NomClasse ayant l’identifiant id OU
L M
e f E
flush() : pour sauvegarder
r les modifications dans la base de
données
A ch
© : pour supprimer obj de la base de données
remove(obj)
...

H & H: Research and Training 27 / 94

 EntityManager Insertion

EntityManager

Commençons par ajouter les informations sur la connexion dans [Link]

<?xml version="1.0" encoding="UTF-8"?>

<persistence version="2.1"
xmlns="[Link]
xmlns:xsi="[Link]
xsi:schemaLocation="[Link]
H I ©
EL
[Link]
<persistence-unit name="FirstJpaProject">
<class>[Link]</class>
O U
LM
<properties>
<property name="[Link]" value="[Link]" />

r e f E
<property name="[Link]" value="jdbc:mysql://localhost:3306/jpa" />
<property name="[Link]" value="root" />

ch
<property name="[Link]" value="" />

©A
<property name="[Link]-database" value="MySQL5" />
<property name="[Link]-generation" value="drop-and-create-tables" />
<property name="[Link]-mode" value="both" />
<property name="[Link]" value="FINE" />
</properties>
</persistence-unit>
</persistence>

ddl : data definition language (ou langage de définition de données (LDD)).

H & H: Research and Training 28 / 94

 EntityManager Insertion

EntityManager
Valeurs possibles pour ddl-generation
drop-and-create-tables : EclipseLink essayera de
supprimer toutes les tables, puis de les recréer toutes. (très utile

H I ©
pour la phase de développement pendant les tests ou lorsque les

EL
données existantes doivent être effacées.

O U
LM
create-or-extend-tables : EclipseLink essayera de créer

r e f E
des tables. Si la table existe, il ajoutera les colonnes manquantes.

A ch: EclipseLink essayera d’exécuter CREATE

create-tables
© chaque table. Si la table existe déjà, une exception
TABLE pour
est levée et la table n’est pas créée. la table existante sera utilisée.
EclipseLink poursuivra ensuite avec la prochaine instruction.
none : Aucun LDD généré (aucune CREATE TABLE). Aucun
schéma généré.

H & H: Research and Training 29 / 94

 EntityManager Insertion

EntityManager

Valeurs possibles pour [Link]-mode

both : Le LDD sera généré et écrit à la fois dans la base de

données et dans un fichier.
H I ©
database : (Valeur par défaut) Le LDD U ELgénéré et écrit
sera
uniquement dans la base de donn O
Mées.
f E L
sql-script : DDLre
c h sera généré et écrit uniquement dans un
fichier.
©A
Ce mode dépend évidemment de la configuration précédente (la
valeur choisie pour ddl-generation).

H & H: Research and Training 30 / 94

 EntityManager Insertion

L’insertion
EntityManagerFactory emf = Persistence.
createEntityManagerFactory("FirstJpaProject");
EntityManager em = [Link]();
// instanciation de l’entité
Personne p = new Personne();
H I ©
EL
[Link]("John");
[Link]("Wick");
O U
f E LM
EntityTransaction transaction = [Link]();

ch r e
[Link](); // début transaction
[Link](p); // persister dans la base de données
©A
[Link](); // valider transaction
// fermer l’EntityManager et la factorie
[Link]();
[Link]();

H & H: Research and Training 31 / 94

 EntityManager Insertion

L’insertion
EntityManagerFactory emf = Persistence.
createEntityManagerFactory("FirstJpaProject");
EntityManager em = [Link]();
// instanciation de l’entité
Personne p = new Personne();
H I ©
EL
[Link]("John");
[Link]("Wick");
O U
f E LM
EntityTransaction transaction = [Link]();

ch r e
[Link](); // début transaction
[Link](p); // persister dans la base de données
©A
[Link](); // valider transaction
// fermer l’EntityManager et la factorie
[Link]();
[Link]();

[Link]() pour annuler la transaction

H & H: Research and Training 31 / 94
 EntityManager Mise à jour

La mise à jour
EntityManagerFactory emf = Persistence.
createEntityManagerFactory("FirstJpaProject");
EntityManager em = [Link]();
// chercher l’élément a modifier
Personne p = [Link]([Link], 10); // on indique la
classe et la valeur de la clé primaire
H I ©
EL
EntityTransaction transaction = [Link]();
[Link]();
O U
LM
if (p == null) {

}
r e E
[Link]("Personne non trouvée");
f
ch
©A
else {
[Link]("Bob"); // faire une modification
[Link](); // enregistrer la modification
}
// valider la transaction
[Link]();
[Link]();
[Link]();

H & H: Research and Training 32 / 94

 EntityManager Suppression

La suppression
EntityManagerFactory emf = Persistence.
createEntityManagerFactory("FirstJpaProject");
EntityManager em = [Link]();
// chercher l’élément a supprimer
Personne p = [Link]([Link], 10);
EntityTransaction transaction = [Link]();
H I ©
[Link]();
U EL
if (p == null) {
O
f E LM
[Link]("Personne non trouvée");
}
else {
ch r e
©A
// supprimer l’élément
[Link](p);
}
// valider la transaction
[Link]();
[Link]();
[Link]();
H & H: Research and Training 33 / 94
 EntityManager Consultation

La recherche

Fonctions de recherche

I ©
find() : cherche et retourne un élément selon la valeur de la clé
H
primaire. Retourne null si la valeur n’existe pas
U EL
O
f E LM
getReference() : fonctionne comme find(). Mais elle
déclenche une exception si la valeur n’existe pas
ch r e
©A

H & H: Research and Training 34 / 94

 EntityManager Consultation

La recherche

Fonctions de recherche

I ©
find() : cherche et retourne un élément selon la valeur de la clé
H
primaire. Retourne null si la valeur n’existe pas
U EL
O
f E LM
getReference() : fonctionne comme find(). Mais elle
déclenche une exception si la valeur n’existe pas
ch r e
©A
On peut aussi définir nos fonctions de recherche en utilisant des
requêtes SQL

H & H: Research and Training 34 / 94

 EntityManager Consultation

La consultation
EntityManagerFactory emf = Persistence.
createEntityManagerFactory("FirstJpaProject");
EntityManager em = [Link]();
// definir la requete
String str = "select * from Personne";
H I ©
EL
// executer la requete et preciser l’entite concernee
Query query = [Link](str, [Link]
O U
LM
.[Link]);
// recuperer le resultat
r e f E
ch
List <Personne> personnes = (List <Personne> ) query.

©A
getResultList();
for (Personne p : personnes) {
[Link]("nom = "+ [Link]());
}
[Link]();
[Link]();

H & H: Research and Training 35 / 94

 EntityManager Consultation

La recherche
Création de requêtes
createNativeQuery() : permet d’exécuter une requête SQL
createNamedQuery() : permet d’exécuter une requête JPQL
définie par des annotations
H I ©
createQuery() : permet d’exécuter uneE
U L ête JPQL
requ

L MO
r e f E
A ch
©

H & H: Research and Training 36 / 94

 EntityManager Consultation

La recherche
Création de requêtes
createNativeQuery() : permet d’exécuter une requête SQL
createNamedQuery() : permet d’exécuter une requête JPQL
définie par des annotations
H I ©
createQuery() : permet d’exécuter uneE
U L ête JPQL
requ

L MO
Récupération du résultat
r e f E de récupérer le résultat sous forme
getResultList()
d’une liste A
ch : permet
©
getSingleResult() : permet de récupérer un seul élément de
la sélection
getFirstResult() : permet de récupérer le premier élément
de la sélection
H & H: Research and Training 36 / 94
 EntityManager Consultation

La consultation

Les requêtes natives : exemple avec getSingleResult() en

utilisant les requêtes paramétrées
EntityManagerFactory emf = Persistence.
createEntityManagerFactory("FirstJpaProject");
H I ©
EntityManager em = [Link]();
U EL
O
Query query = [Link]("select * from
E LM
Personne where num = ?", [Link].
f
[Link]);
ch r e
©A
[Link](1, 5);
Personne p = (Personne) [Link]();
[Link]("nom = "+ [Link]());
[Link]();
[Link]();

H & H: Research and Training 37 / 94

 EntityManager Consultation

La consultation

Les requêtes nommées : exemple (on commence tout d’abord par

définir la requête dans l’entité)
/**
* Entity implementation class for Entity: Personne
H I ©
*
U EL
*/
O
@Entity
f E LM
@NamedQuery(
name="findByNomPrenom", ch r e
©A
query="SELECT p FROM Personne p WHERE [Link] = :
nom and [Link] = :prenom"
)
public class Personne implements Serializable {
...

H & H: Research and Training 38 / 94

 EntityManager Consultation

La consultation
Les requêtes nommées : exemple (ensuite nous l’utiliserons)
EntityManagerFactory emf = Persistence.
createEntityManagerFactory("FirstJpaProject");
EntityManager em = [Link]();
Query query = [Link]("findByNomPrenom")
H I ©
;
U EL
O
LM
[Link]("nom", "Wick");
[Link]("prenom", "John");
r e f E
ch
List <Personne> personnes = (List <Personne> ) query
.getResultList();
©A
for (Personne p : personnes) {
[Link]("nom = "+ [Link]());
}
[Link]();
[Link]();

H & H: Research and Training 39 / 94

 EntityManager Consultation

La consultation
Et si on veut définir plusieurs requêtes nommées
@Entity
@NamedQueries({
@NamedQuery(
name="findByNomPrenom",
H I ©
query="SELECT p FROM Personne p WHERE [Link] = :
U EL
nom and [Link] = :prenom"
O
),
f E LM
@NamedQuery(
ch r e
©A
name="findByPrenom",
query="SELECT p FROM Personne p WHERE [Link] =
:prenom"
),
})
public class Personne implements Serializable {
...
H & H: Research and Training 40 / 94
 EntityManager Consultation

EntityManager

Les méthodes utilisées de l’EntityManager

persist(entity) : permet de persister une entité. Un commit
engendrera l’enregistrement de cette entité dans la base de
données.
H I ©
U
remove(entity) : permet de rendre une L é non persistante.
Eentit
MO de cette entité de la base
Un commit engendrera la suppression
L
de données.
r e f E
A chde persister les modifications. Un commit
flush() : permet
© l’enregistrement de ces modifications dans la base de
engendrera
données.

H & H: Research and Training 41 / 94

 EntityManager Consultation

EntityManager

Les méthodes utilisées de l’EntityManager

persist(entity) : permet de persister une entité. Un commit
engendrera l’enregistrement de cette entité dans la base de
données.
H I ©
U
remove(entity) : permet de rendre une L é non persistante.
Eentit
MO de cette entité de la base
Un commit engendrera la suppression
L
de données.
r e f E
A chde persister les modifications. Un commit
flush() : permet
© l’enregistrement de ces modifications dans la base de
engendrera
données.

Attention
La méthode flush() ne prend pas de paramètre
H & H: Research and Training 41 / 94
 EntityManager Consultation

EntityManager

Autres méthodes de l’EntityManager

refresh(entity) : permet de synchroniser l’état de l’entité
passée en paramètre (entity) avec son état en base de H I ©
données. U EL
detach(entity) : permet L M O
f E de détacher l’entité passée en
rede l’EntityManager qui la gère.
paramètre (entity)
c h
© A : permet d’attacher l’entité passée en paramètre
merge(entity)
(entity), gérée par un autre EntityManager, à
l’EntityManager courant.

H & H: Research and Training 42 / 94

 EntityManager Consultation

EntityManager
Exemple avec utilisation de refresh()
EntityManagerFactory emf = Persistence.
createEntityManagerFactory("FirstJpaProject");
EntityManager em = [Link]();
//on suppose que John Wick avec un num 10 existe
H I ©
dans la BD
U EL
Personne p = [Link]([Link], 10); O
[Link]("Travolta");
f E LM
[Link](p);
ch r e
©A
[Link]("le nom est " + [Link]());
// imprime Wick
[Link]();
[Link]();
// si on supprime [Link](p); Travolta sera
affiche

H & H: Research and Training 43 / 94

 EntityManager Consultation

EntityManager
Exemple avec utilisation de detach()
EntityManagerFactory emf = Persistence.
createEntityManagerFactory("FirstJpaProject");
EntityManager em = [Link]();
//on suppose que John Wick avec un num 10 existe
H I ©
dans la BD
U EL
Personne p = [Link]([Link], 10); O
[Link]("Travolta");
f E LM
r e
[Link](p); // p n’est plus gere par em
ch
©A
[Link]().begin();
[Link]();
[Link]().commit();
Personne p1 = [Link]([Link], 10);
[Link]("le nom est " + [Link]());
// affiche le nom est Wick

H & H: Research and Training 44 / 94

 JPQL : Java Persistence Query Language

JPQL

Définition
JPQL est un langage de requêtes adapté à la spécification JPA

H I
Inspiré du langage SQL (et HQL : Hibernate Query Language)©
mais adapté aux entités JPA
U EL
M O
f E Lés JPA et pas les tables d’une base
Permet de manipuler les entit
de données
c h re
©desArequêtes de type select, update et delete
Supporte

H & H: Research and Training 45 / 94

 JPQL : Java Persistence Query Language

JPQL

Définition
JPQL est un langage de requêtes adapté à la spécification JPA

H I
Inspiré du langage SQL (et HQL : Hibernate Query Language)©
mais adapté aux entités JPA
U EL
M O
f E Lés JPA et pas les tables d’une base
Permet de manipuler les entit
de données
c h re
©desArequêtes de type select, update et delete
Supporte

On manipule des entités et non pas des tables. Le nom des entités est
sensible à la casse.

H & H: Research and Training 45 / 94

 JPQL : Java Persistence Query Language

JPQL
Exemple :
String str= "Select p from Personne as p";
Query query = [Link](str);
List <Personne> personnes = (List <Personne> ) query
.getResultList();
H I ©
for (Personne p : personnes) {
UEL
O
LM
[Link]([Link]() + " " + p.
getPrenom());
r e f E
}
ch
©A
Explication

On sélectionne des objets p de type Personne

On peut aussi écrire "Select p from Personne p"

H & H: Research and Training 46 / 94

 JPQL : Java Persistence Query Language

JPQL

Remarques

H I ©
La requête JPQL précédente permet de sélectionner un objet

ELseulement quelques
Il est tout de même possible de sélectionner
U
attributs d’un objet
L MO
r e f Eest un tableau contenant les champs
Dans ce cas là, le résultat
A chés
attributs sélectionn
©
Et il est impossible de modifier (ou supprimer) les valeurs de ces
attributs sélectionnées

H & H: Research and Training 47 / 94

 JPQL : Java Persistence Query Language

JPQL

Comme avec SQL, on peut faire des jointures

"select p from Personne p
join [Link] s
where [Link]= ’football’"
H I ©
UEL
O
f E LM
ch r e
©A

H & H: Research and Training 48 / 94

 JPQL : Java Persistence Query Language

JPQL

Comme avec SQL, on peut faire des jointures

"select p from Personne p
join [Link] s
where [Link]= ’football’"
H I ©
Équivalent en SQL UEL
O
"select *
f E LM
r e
from Sport s, Personne Sport ps, Personne p
ch
©A
where [Link] = [Link] and [Link] = [Link]
and [Link] = ’football’"

H & H: Research and Training 48 / 94

 JPQL : Java Persistence Query Language

JPQL

Comme avec SQL, on peut faire des jointures

"select p from Personne p
join [Link] s
where [Link]= ’football’"
H I ©
Équivalent en SQL UEL
O
"select *
f E LM
r e
from Sport s, Personne Sport ps, Personne p
ch
©A
where [Link] = [Link] and [Link] = [Link]
and [Link] = ’football’"

Explication
La jointure se fait avec join [Link] s
Le reste, c’est du SQL classique

H & H: Research and Training 48 / 94

 JPQL : Java Persistence Query Language

JPQL

On peut également utiliser

group by
order by
H I ©
UEL
having
O
distinct
f E LM
r e
chégation count, avg...
A
les fonctions d’agr
©
les requêtes imbriquées
les mots-clés all, (not) in, like, between, (not) null,
(not) exists...

H & H: Research and Training 49 / 94

 JPQL : Java Persistence Query Language

JPQL

Attention aux collections

String str= "select p from Personne p
H I ©
where [Link]= ’football’";
UEL
Query query = [Link](str); O
f E LM
[Link] est c r e
h collection
une
© A
cette requête génère une erreur

H & H: Research and Training 50 / 94

 Relation entre entités

Relation entre entités

Quatre (ou trois) relations possibles

H I ©
OneToOne : chaque objet d’une première classe est en relation

EL
avec un seul objet de la deuxième classe

O U
OneToMany : chaque objet d’une première classe peut être en
E LM
relation avec plusieurs objets de la deuxième classe (la
f
ch
réciproque est ManyToOne)r e
©A
ManyToMany : chaque objet d’une première classe peut être en
relation avec plusieurs objets de la deuxième classe et
inversement

H & H: Research and Training 51 / 94

 Relation entre entités OneToOne

Création de l’entité Adresse

}
package [Link]; public void setRue(String rue) {
[Link] = rue;
/** }
* Entity implementation class for
Entity: Adresse public String getCodePostal() {
*
*/ }
H I ©
return [Link];

@Entity
public class Adresse implements
UEL
O public void setCodePostal(String

LM
Serializable { codePostal) {

@Id
r e f E }
[Link] = codePostal;

private String rue;

ch
©A
private String codePostal; public String getVille() {
private String ville; return [Link];
private static final long }
serialVersionUID = 1L;
public void setVille(String
public Adresse() { ville) {
super(); [Link] = ville;
} }
public String getRue() { }
return [Link];
H & H: Research and Training 52 / 94
 Relation entre entités OneToOne

Modifier l’entité Personne

@Entity
public class Personne implements Serializable {

@Id
private int num;
private String nom;
H I ©
private String prenom;

UEL
O
LM
@OneToOne(cascade={[Link], [Link]})
@JoinColumn(name="rue", referencedColumnName="rue", nullable=false)
private Adresse adresse;
r e f E
ch
©A
// les getters/setters de chaque attribut

H & H: Research and Training 53 / 94

 Relation entre entités OneToOne

Modifier l’entité Personne

@Entity
public class Personne implements Serializable {

@Id
private int num;
private String nom;
H I ©
private String prenom;

UEL
O
LM
@OneToOne(cascade={[Link], [Link]})
@JoinColumn(name="rue", referencedColumnName="rue", nullable=false)
private Adresse adresse;
r e f E
ch
©A
// les getters/setters de chaque attribut

Notation
Personne : entité propriétaire
Adresse : entité inverse

H & H: Research and Training 53 / 94

 Relation entre entités OneToOne

Relation entre entités

@OneToOne(cascade={[Link], CascadeType.
REMOVE})

H I ©
Explication
UEL
O
f E LM
cascade : ici on cascade les deux opérations PERSIST et

ch r e
REMOVE qu’on peut faire de l’entité propriétaire à l’entité inverse

©A
On peut cascader d’autres opérations telles que DETACH, MERGE,
et REFRESH...
on peut cascader toutes les opérations avec ALL

H & H: Research and Training 54 / 94

 Relation entre entités OneToOne

Relation entre entités

@JoinColumn(name="rue", referencedColumnName="rue",
nullable=false)
H I ©
EL
Explication
M OU
Pour désigner la colonne E
f L Adresse qui permet de faire la
dans
jointure
chr e
Pour dire
A
©que chaque personne doit avoir une adresse (donc on
ne peut avoir une personne sans adresse)

H & H: Research and Training 55 / 94

 Relation entre entités OneToOne

Testons l’ajout d’une personne

EntityManagerFactory emf = Persistence.
createEntityManagerFactory("FirstJpaProject");
EntityManager em = [Link]();
Adresse a = new Adresse();
[Link]("Lyon");
[Link]("13015");
H I ©
[Link]("Marseille");
UEL
Personne p = new Personne();
O
[Link](a);
[Link]("Ego");
f E LM
[Link]("Paul");
ch r e
©A
EntityTransaction t =[Link]();
[Link]();
[Link](p);
[Link]();
[Link]("insertion reussie ");
[Link]();
[Link]();

H & H: Research and Training 56 / 94

 Relation entre entités OneToOne

Testons l’ajout d’une personne

Sans la précision suivante

@OneToOne(cascade={[Link], CascadeType.
REMOVE})
H I ©
EL
OU
Il fallait persister l’objet adresse avant l’objet personne
M
f E L
EntityTransaction t =[Link]();
c h r
[Link](); e
© A
[Link](a);
[Link](p);
[Link]();

H & H: Research and Training 57 / 94

 Relation entre entités ManyToOne

ManyToOne
Exemple
Si on suppose que plusieurs personnes peuvent avoir la même
adresse

personne1
H I ©
U EL
O
personne2
f E LM
ch r e adresse
© A.. .

personneN

Many To One
H & H: Research and Training 58 / 94
 Relation entre entités ManyToOne

ManyToOne

Il faut juste changer

@ManyToOne(cascade={[Link], CascadeType
H I ©
.REMOVE})
U EL
@JoinColumn(name="rue", referencedColumnName="rue", O
nullable=false)
f E LM
ch r e
©A

H & H: Research and Training 59 / 94

 Relation entre entités ManyToOne

ManyToOne

Il faut juste changer

@ManyToOne(cascade={[Link], CascadeType
H I ©
.REMOVE})
U EL
@JoinColumn(name="rue", referencedColumnName="rue", O
nullable=false)
f E LM
ch r e
Le reste ©A
C’est pareil

H & H: Research and Training 59 / 94

 Relation entre entités OneToMany

OneToMany
Exemple
Si on suppose qu’une personne peut avoir plusieurs adresses

I ©
adresse1
H
U EL
O
f E LM adresse2
personne
c h r e .
©A .
.

adresseN

One To Many

H & H: Research and Training 60 / 94

 Relation entre entités OneToMany

OneToMany

Il faut changer
@OneToMany(cascade={[Link],
H I ©
EL
[Link]})
private List <Adresse> adresses = new ArrayList <
O U
Adresse> ();
f E LM
ch r e
©A
On peut aussi définir quand les objets de l’entité inverse (ici Adresse)
seront chargées dans l’entité propriétaire (ici Personne)

H & H: Research and Training 61 / 94

 Relation entre entités OneToMany

OneToMany

Il faut ajouter dans l’annotation l’attribut fetch

@OneToMany(cascade={[Link],
[Link]}, fetch = [Link])
private List <Adresse> adresses = new ArrayList <
H I ©
Adresse> ();
U EL
O
f E LM
ch r e
©A

H & H: Research and Training 62 / 94

 Relation entre entités OneToMany

OneToMany

Il faut ajouter dans l’annotation l’attribut fetch

@OneToMany(cascade={[Link],
[Link]}, fetch = [Link])
private List <Adresse> adresses = new ArrayList <
H I ©
Adresse> ();
U EL
O
f E LM
ch r e
Deux valeurs possibles pour CONSTANTE

©A
EAGER : les objets de l’entité Adresse en relation avec un objet
personne de l’entité Personne seront chargés au même temps.
LAZY (par défaut) : les objets de l’entité Adresse en relation avec
un objet personne de l’entité Personne seront chargés
seulement quand on fait [Link]’).

H & H: Research and Training 62 / 94

 Relation entre entités OneToMany

OneToMany
N’oublions pas de supprimer ce code de l’entité Personne
@OneToOne(cascade={[Link], [Link]})
@JoinColumn(name="rue", referencedColumnName="rue", nullable=
false)
private Adresse adresse;
// les getters/setters de chaque attribut
H I ©
U EL
O
f E LM
ch r e
©A

H & H: Research and Training 63 / 94

 Relation entre entités OneToMany

OneToMany
N’oublions pas de supprimer ce code de l’entité Personne
@OneToOne(cascade={[Link], [Link]})
@JoinColumn(name="rue", referencedColumnName="rue", nullable=
false)
private Adresse adresse;
// les getters/setters de chaque attribut
H I ©
U EL
O
Ensuite
f E LM
ch r e
il faut générer le getter et le setter d’adresses
©A
il faut aussi générer la méthode add et remove qui permettent d’ajouter ou de
supprimer une adresse pour un objet personne (Dans Source, choisir
Generate Delegate Methods).

Modifier le nom de la méthode add en addAdresse et remove en

removeAdresse

H & H: Research and Training 63 / 94

 Relation entre entités OneToMany

OneToMany
N’oublions pas de supprimer ce code de l’entité Personne
@OneToOne(cascade={[Link], [Link]})
@JoinColumn(name="rue", referencedColumnName="rue", nullable=
false)
private Adresse adresse;
// les getters/setters de chaque attribut
H I ©
U EL
O
Ensuite
f E LM
ch r e
il faut générer le getter et le setter d’adresses
©A
il faut aussi générer la méthode add et remove qui permettent d’ajouter ou de
supprimer une adresse pour un objet personne (Dans Source, choisir
Generate Delegate Methods).

Modifier le nom de la méthode add en addAdresse et remove en

removeAdresse

H & H: Research and Training 63 / 94

 Relation entre entités OneToMany

Testons l’ajout d’une personne

EntityManagerFactory emf = [Link]("
FirstJpaProject");
EntityManager em = [Link]();
Adresse a1 = new Adresse();
[Link]("Lyon");
[Link]("13015");
[Link]("Marseille");
Adresse a2 = new Adresse();
H I ©
[Link]("Paradis");
U EL
[Link]("13003");
O
LM
[Link]("Marseille");
Personne p1 = new Personne();
[Link]("Wick");
r e f E
[Link]("John");
ch
[Link](a1);
[Link](a2); ©A
EntityTransaction t =[Link]();
[Link]();
[Link](p1);
[Link]();
[Link]("insertion reussie ");
[Link]();
[Link]();

H & H: Research and Training 64 / 94

 Relation entre entités ManyToMany

ManyToMany
Exemple
Une personne peut pratiquer plusieurs sports
Un sport peut être pratiqué par plusieurs personnes

H I ©
personne1
U ELsport1

O
f E LM
personne2
ch r e sport2

© A.. .
.
. .

personneN sportM

Many To Many
H & H: Research and Training 65 / 94
 Relation entre entités ManyToMany

ManyToMany

H I ©
EL
Il faut juste changer

O U
On commence par créer une entité Sport
L M
f E
On définit la relation ManyToMany (exactement comme les deux
resoit dans Personne soit dans Sport
relations précédentes)
c h
©A

H & H: Research and Training 66 / 94

 Relation entre entités ManyToMany

Création de l’entité Sport

public class Sport implements Serializable {

@Id
private String nom;
private String type;
private static final long serialVersionUID = 1L;
public Sport() {
H I ©
}
super();
U EL
O
LM
public String getNom() {

}
return nom;

r e f E
ch
public void setNom(String nom) {

©A
[Link] = nom;
}
public String getType() {
return type;
}
public void setType(String type) {
[Link] = type;
}
}

H & H: Research and Training 67 / 94

 Relation entre entités ManyToMany

Ajoutons le ManyToMany dans la classe Personne

@Entity
public class Personne implements Serializable {
@Id
private int num;
private String nom;
private String prenom;
@ManyToMany(cascade={[Link], [Link]})
private List <Sport> sports = new ArrayList <Sport> ();
H I ©
// les getters/setters et constructeur
U EL
O
public List<Sport> getSports() {
return sports;
f E LM
}
ch r e
©A
public void setSports(List<Sport> sports) {
[Link] = sports;
}
public boolean addSport(Sport arg0) {
return [Link](arg0);
}
public boolean removeSport(Object arg0) {
return [Link](arg0);
}
}
H & H: Research and Training 68 / 94
 Relation entre entités ManyToMany

Testons tout ça

[Link]("individuel");
EntityManagerFactory emf = [Link]("collectif ou
Persistence. individuel");
createEntityManagerFactory(" [Link](s1);
FirstJpaProject"); [Link](s3);
EntityManager em = emf.
createEntityManager();
[Link](s1);
H I ©
EL
[Link](s2);
Personne p1 = new Personne();
Personne p2 = new Personne();
O U
[Link](s3);

LM
EntityTransaction t =em.
[Link]("Wick");
[Link]("John");
r e f E getTransaction();
[Link]();
[Link]("Bob");
ch [Link](p1);
[Link]("Joe");
©A
Sport s1 = new Sport();
[Link](p2);
[Link]();
Sport s2 = new Sport(); [Link]("insertion
Sport s3 = new Sport(); reussie ");
[Link]("football"); [Link]();
[Link]("tennis"); [Link]();
[Link]("box");
[Link]("collectif");
H & H: Research and Training 69 / 94
 Relation entre entités ManyToMany

Cas particulier

Si la table association est porteuse de données

Par exemple : la relation (ArticleCommande) entre Commande et
Article
H I ©
EL
Il faut préciser la quantité de chaque article dans une commande
U
O
f E LM
ch r e
©A

H & H: Research and Training 70 / 94

 Relation entre entités ManyToMany

Cas particulier

Si la table association est porteuse de données

Par exemple : la relation (ArticleCommande) entre Commande et
Article
H I ©
EL
Il faut préciser la quantité de chaque article dans une commande
U
O
Solution
f E LM
ch r e
Créer trois entités Article, Commande et ArticleCommande
©A
Définir la relation OneToMany entre Article et
ArticleCommande
Définir la relation ManyToOne entre ArticleCommande et
Commande

H & H: Research and Training 70 / 94

 Relation entre entités ManyToMany

Remarques

Remarques
Les relations, qu’on a étudiées, sont unidirectionnelles H I ©
U
C’est à dire on peut faire [Link](); EL
M O
f E L
Mais on ne peut faire [Link]();

chr e
© A

H & H: Research and Training 71 / 94

 Relation entre entités ManyToMany

Remarques

Remarques
Les relations, qu’on a étudiées, sont unidirectionnelles H I ©
U
C’est à dire on peut faire [Link](); EL
M O
f E L
Mais on ne peut faire [Link]();

chr e
Solution
© A
Rendre les relations bidirectionnelles

H & H: Research and Training 71 / 94

 Relation entre entités ManyToMany

Relations bidirectionnelles : exemple

Modifier l’entité inverse Sport
/**
* Entity implementation class for Entity: Sport
*
*/
@Entity
H I ©
EL
public class Sport implements Serializable {

@Id
O U
private String nom;
private String type;
f E LM
r e
private static final long serialVersionUID = 1L;
ch
©A
@ManyToMany(mappedBy="sports")
private List <Personne> personnes = new ArrayList <Personne> ();
// ajouter les getter, setter, add et remove
}

mappedBy
fait référence à l’attribut sports dans la classe Personne

H & H: Research and Training 72 / 94

 Relation entre entités ManyToMany

Relations bidirectionnelles : exemple

Modifier aussi l’entité propriétaire Personne

@Entity
public class Personne implements Serializable {
...
public void add(Sport s) {

H I ©
EL
// ajouter this a la liste des personnes de ce sport

[Link](this);
O U
}
[Link](s);

f E LM
ch r e
©A
public void remove(Sport s) {

// supprimer this de la liste des personnes de ce sport

[Link](this);
[Link](s);
}

La même chose à faire dans Sport pour la liste personnes. Attention aux boucles infinies.

H & H: Research and Training 73 / 94

 Relation entre entités ManyToMany

Relations bidirectionnelles : exemple

Ainsi, on peut faire :
[Link](s1);
[Link](s3);
[Link](s1);
[Link](s2); H I ©
[Link](s3);
U EL
O
LM
EntityTransaction t = [Link]();
[Link]();
r e f E
[Link](p1);
ch
[Link](p2);
©A
[Link]();
[Link]([Link]().get(0).getNom()
);

H & H: Research and Training 74 / 94

 Relation entre entités ManyToMany

Relations bidirectionnelles : exemple

Ainsi, on peut faire :
[Link](s1);
[Link](s3);
[Link](s1);
[Link](s2); H I ©
[Link](s3);
U EL
O
LM
EntityTransaction t = [Link]();
[Link]();
r e f E
[Link](p1);
ch
[Link](p2);
©A
[Link]();
[Link]([Link]().get(0).getNom()
);

affiche Wick
H & H: Research and Training 74 / 94
 Relation entre entités ManyToMany

Remarques

Pour définir une relation bidirectionnelle entre deux entités

si dans l’entité propriétaire la relation définie est OneToMany,
H I ©
alors dans l’entité inverse la relation sera ManyToOne, et
EL
inversement.
M OU
E laLrelation définie est OneToOne, alors
f
si dans l’entité propriétaire
e
chrla relation sera aussi OneToOne.
dans l’entité inverse
A
si dans ©
l’entité propriétaire la relation définie est ManyToMany,
alors dans l’entité inverse la relation sera aussi ManyToMany.

H & H: Research and Training 75 / 94

 Relation entre entités Inheritance

L’association d’héritage

Trois possibilités avec l’héritage

SINGLE TABLE
TABLE PER CLASS
H I ©
UEL
JOINED
O
f E LM
ch r e
©A

H & H: Research and Training 76 / 94

 Relation entre entités Inheritance

L’association d’héritage

Trois possibilités avec l’héritage

SINGLE TABLE
TABLE PER CLASS
H I ©
UEL
JOINED
O
f E LM
ch r e
Exemple ©A
Une classe mère Personne
Deux classes filles Etudiant et Enseignant

H & H: Research and Training 76 / 94

 Relation entre entités Inheritance

L’association d’héritage

H I ©
Pour indiquer comment transformer les classes mère et filles en tables
UEL
O
Il faut utiliser l’annotation @Inheritance
f E LM
ch r e
©A

H & H: Research and Training 77 / 94

 Relation entre entités Inheritance

L’association d’héritage

H I ©
Tout dans une seule table
EL
M
Dans la classe mère on ajoute OU
f E L
@Inheritance(strategy=[Link] TABLE)

ch r e
© A

H & H: Research and Training 78 / 94

 Relation entre entités Inheritance

L’association d’héritage
Exemple

Et pour distinguer un étudiant d’un enseignant, d’une personne

@DiscriminatorColumn(name="TYPE PERSONNE") dans la
classe mère,
H I ©
U ELdans la classe
@DiscriminatorValue(value="PERS")
Personne,
L MO
r e f E dans la classe
A
Etudiant et c h
@DiscriminatorValue(value="ETU")

©
@DiscriminatorValue(value="ENS") dans la classe
Enseignant.

Dans la table personne, on aura une colonne TYPE PERSONNE qui

aura comme valeur soit PERS, soit ETU soit ENS.
H & H: Research and Training 79 / 94
 Relation entre entités Inheritance

L’association d’héritage

H I ©
Exemple avec une table pour chaque entité
EL
M OU
@Inheritance(strategy=[Link] PER CLASS) :
E Lée en table.
Chaque entité sera transform
f
chr e
© A

H & H: Research and Training 80 / 94

 Les classes incorporables

Les classes incorporables : pas de table correspondante en BD

Et si on déplace les attributs nom et prénom dans une nouvelle classe NomComplet
@Embeddable
public class NomComplet {
private String nom;
private String prenom;
public String getNom() {
return nom;
H I ©
}
public void setNom(String nom) {
UEL
O
LM
[Link] = nom;
}
public String getPrenom() {
r e f E
return prenom;
ch
©A
}
public void setPrenom(String prenom) {
[Link] = prenom;
}
@Override
public String toString() {
return "NomComplet [nom=" + nom + ", prenom=" + prenom + "]";
}
}

H & H: Research and Training 81 / 94

 Les classes incorporables

Les classes incorporables : pas de table correspondante en BD

L’entité Personne devient ainsi :
@Entity
public class Personne {

@Id
@GeneratedValue (strategy=[Link])
private int num;
H I ©
private NomComplet nomComplet;
UEL
O
public int getNum() {
f E LM
}
return num;

ch r e
©A
public void setNum(int num) {
[Link] = num;
}
public NomComplet getNomComplet() {
return nomComplet;
}
public void setNomComplet(NomComplet nomComplet) {
[Link] = nomComplet;
}

H & H: Research and Training 82 / 94

 Les classes incorporables

Les classes incorporables : pas de table correspondante en BD

Pour persister une personne

Personne personne = new Personne();
NomComplet nomComplet = new NomComplet();
[Link]("travolta");
H I ©
[Link]("john");
UEL
[Link](nomComplet); O
E
EntityTransaction t =[Link]();
f LM
[Link]();
ch r e
©A
[Link](personne);
[Link]();

H & H: Research and Training 83 / 94

 Les classes incorporables

Les classes incorporables : pas de table correspondante en BD

Pour persister une personne

Personne personne = new Personne();
NomComplet nomComplet = new NomComplet();
[Link]("travolta");
H I ©
[Link]("john");
UEL
[Link](nomComplet); O
E
EntityTransaction t =[Link]();
f LM
[Link]();
ch r e
©A
[Link](personne);
[Link]();

Il n’y aura pas de table NomComplet, les attributs nom et prénom

seront transformés en colonne dans la table Personne

H & H: Research and Training 83 / 94

 Les méthodes callback

Les évènements

Cycle de vie d’une entité

H I ©
Le cycle de vie de chaque objet d’une entité JPA passe par trois
événements principaux
UEL
création (avec persist()) L M
O
r e f E
chflush())
mise à jour (avec
A
© (avec remove())
suppression

H & H: Research and Training 84 / 94

 Les méthodes callback

Les évènements

Une méthode callback

H I ©
Une méthode callback est une méthode qui sera appelée avant
ou après un évènement survenu sur une entité
UEL
O
f E LM
On utilise les annotations pour spécifier quand la méthode
callback sera appelée
ch r e
©A

H & H: Research and Training 85 / 94

 Les méthodes callback

Les évènements

Une méthode callback

H I ©
Une méthode callback est une méthode qui sera appelée avant
ou après un évènement survenu sur une entité
UEL
O
f E LM
On utilise les annotations pour spécifier quand la méthode
callback sera appelée
ch r e
©A
C’est comme les triggers en SQL

H & H: Research and Training 85 / 94

 Les méthodes callback

Les annotations
@PrePersist : avant qu’une nouvelle entité soit persistée.
@PostPersist : après l’enregistrement de l’entité dans la base
de données.

I ©
@PostLoad : après le chargement d’une entité de la base de
H
données.
UEL
O
f E
enregistrée en base de données. LM
@PreUpdate : avant que la modification d’une entité soit

c: h r e
@PostUpdate A après que la modification d’une entité est
©ée en base de données.
enregistr
@PreRemove : avant qu’une entité soit supprimée de la base de
donnée.
@PostRemove : après qu’une entité est supprimée de la base de
donnée.
H & H: Research and Training 86 / 94
 Les méthodes callback

Les méthodes callback

Exemple : l’entité Personne
public class Personne implements Serializable {

@Id
private int num;
private String nom;
H I ©
private String prenom;
UEL
O
private int nbrMAJ=0; // pour calculer le nombre de
modification
public int getNbrMAJ() {
f E LM
return nbrMAJ;
ch r e
©A
}
public void setNbrMAJ(int nbrMAJ) {
[Link] = nbrMAJ;
}
@PostUpdate
public void updateNbrMAJ() {
[Link]++;
}
// les autres getters, setters et constructeur
H & H: Research and Training 87 / 94
 Les méthodes callback

Les méthodes callback

Personne p1 = new Personne();

[Link]("Wick");
[Link]("John");
[Link]().begin();
[Link](p1);
[Link]().commit();
H I ©
[Link]("nbrMAJ = " + [Link]());
UEL
// affiche nbrMAJ = 0
O
[Link]("Travolta");
f E LM
[Link]().begin();
[Link]();
ch r e
©A
[Link]().commit();
[Link]("Abruzzi");
[Link]().begin();
[Link]();
[Link]().commit();
[Link]("nbrMAJ = " + [Link]());
// affiche nbrMAJ = 2

H & H: Research and Training 88 / 94

 Utilisation de l’API JPA dans un projet JEE

JEE & JPA

Étapes

Créer un nouveau projet JEE (en Allant dans File, ensuite New
et chercher Dynamic Web Project)
H I ©
Saisir le nom du projet (dans Project name:)
U EL
M O
Dans l’onglet Configuration,
f E L cliquer sur Modify...

ch
Cocher la case JPA r e
et choisir la dernière version de JPA
Cliquer ©
A
sur Next et configurer les options de JPA
Générer le [Link] du projet JEE
Valider

H & H: Research and Training 89 / 94

 Utilisation de l’API JPA dans un projet JEE

JEE & JPA

Remarques
H I ©
UEL
Ainsi, on a créé un projet JEE dans lequel on peut créer, utiliser et
O
manipuler des entités JPA
f E LM
ch r e
Sans cette configuration, nous ne pourrons pas utiliser l’API JPA
©A

H & H: Research and Training 90 / 94

 Utilisation de l’API JPA dans un projet Maven

Maven & JPA

Étapes

Créer un nouveau projet Maven

Ajouter les liens et les répertoires qui manquent à ce projet

H I ©
EL
Ajouter JPA

O U
f E LM
ch r e
©A

H & H: Research and Training 91 / 94

 Utilisation de l’API JPA dans un projet Maven

Maven & JPA

Étapes

Créer un nouveau projet Maven

Ajouter les liens et les répertoires qui manquent à ce projet

H I ©
EL
Ajouter JPA

O U
Création d’un projet Maven
f E LM
ch r e
Aller dans File > New et chercher Maven Project
©A
Choisir un projet maven-archetype-webapp
Remplir le champs Group Id par [Link]
Remplir le champs Artifact Id par JeeJpaMavenProject
Valider
H & H: Research and Training 91 / 94
 Utilisation de l’API JPA dans un projet Maven

JEE & JPA

Si [Link] est signalé en rouge

Faire clic droit sur le nom du projet H I ©
UEL
Choisir Properties O
f E LM
ch r e
Chercher puis sélectionner Targeted Runtimes

©A
Cocher la case Apache Tomcat vX.X puis cliquer sur Apply
and Close

H & H: Research and Training 92 / 94

 Utilisation de l’API JPA dans un projet Maven

JEE & JPA

S’il n’y a pas de src/main/java dans Java Resources

Faire clic droit sur le nom du projet
H I ©
Aller dans Build Path > Configure E
U L Path...
Build

L
Cliquer sur Order and Export MO
r e f E
A h
Cocher les troisccase Maven Dependencies, Apache Tomcat
vX.X et© JRE System Library
Cliquer sur Apply and Close

H & H: Research and Training 93 / 94

 Utilisation de l’API JPA dans un projet Maven

JEE & JPA

Ajouter JPA
Faire un clic droit sur le nom du projet et aller dans Properties
H I ©
Chercher Project Facets
UEL
O
Cocher la case JPA
f E LM
ch r e
Cliquer sur le lien qui apparaı̂t (Further configuration

©A
available...) pour ajouter les données sur EclipseLink et la
connexion
Cliquer sur Apply and Close

H & H: Research and Training 94 / 94