6- Formation_JPA java jsp jakarta PowerPoint

Agenda
 Historique et problématique
 ORM : Object Relational Mapping
 JPA : Java Persistence Api
 Entity: Entités
 Autres annotations
 Contexte de persistance
 Opérations prises en charge par le gestionnaire d’entités
 Cycle de vie d’une instance d’entité
 Obtention d’une fabrique EntityManagerFactory
 Création du gestionnaire d’entité EntityManager
 Exemple d’insertion d’un livre
 Relations entre entités : relations avec cardinalités
 Relations entre entités : Héritage
2

Historique
Accès directement à la base de données grâce à l’API standard JDBC de Java
3

Problématique
 Problématiques de l’accès direct à la BD à l’aide de jdbc :
 Pour des raisons de performances, le coût d'ouverture / fermeture d'une
connexion n'est pas négligeable,
Connection con = DriverManager.getConnection(url, "login", "password");
//les ordres SQL
con.close();
 L’utilisation du langage SQL rend la couche DAO difficilement
maintenable,
String insertStatement = "Insert into Client(Nom, Prenom,Nature) values
(?, ?, ?)"
 Pour pallier à cette problématique et faciliter l’écriture de la couche DAO:
La communauté Java a donc fait naître des Frameworks ORM , tels que
Hibernate, Toplink, EclipseLink
4

ORM : Object Relational Mapping
5

6
ORM : Object Relational Mapping
Devant le succès des Frameworks ORM,
Sun a décidé de standardiser une couche ORM via une spécification appelée JPA
apparue en même temps que Java 5

JPA : Java Persistence Api
7
La spécification JPA est un ensemble d’interface du package javax.persistence /
jakarta.persistence
Exemple :
jakarta.persistence.Entity;
jakarta.persistence.EntityManagerFactory;
jakarta.persistence.EntityManager;
jakarta.persistence.EntityTransaction;

9
Les principaux avantages sont les suivants :
 JPA peut être utilisé par toutes les applications Java, Java SE ou Java EE.
 Mapping O/R (objet-relationnel) avec les tables de la BD, facilitée par les
Annotations.
 Un langage de requête objet standard JPQL pour la récupération des objets:
select p from Personne p order by p.nom asc
 La description du mapping entre le bean entity et la table peut être fait de
deux façons :
o Utiliser un fichier XML de mapping.
o Utiliser des annotations ;
 Dans ce cours, nous allons se focaliser sur L'API JPA avec les annotations
JPA : Java Persistence Api

10
ENTITY: les entités
@Entity
@Table(name = "BOOK")
public class Book {
@Id
@GeneratedValue
private Long id;
@Column(name = "TITLE",nullable = false)
private String title;
private Float price;
@Basic(fetch = FetchType.LAZY)
@Column(length = 2000)
private String description;
private String isbn;
private Integer nbOfPage;
private Boolean illustrations
//Les Getters et les Setters

JPA : Les entités
 Le bean Entity doit respecter les deux règles suivantes :
▪ il doit être annoté par @Entity ;
▪ il doit posséder au moins une propriété déclarer comme clé primaire avec
l'annotation @Id, cette propriété particulière est la clé primaire qui est
l’identifiant unique dans la base de données et aussi dans le POJO.
⮚ Le bean entity est composé de propriétés qui seront mappés sur les champs de
la table de la base de données avec l’annotation @Column ;
 Chaque propriété encapsule les données d'un champ d'une table. Ces
propriétés sont utilisables au travers des getter et des setter ;

Composants d'entreprise 11

Mapping entre une entité et une table
Annotation Rôle
@jakarta.persistence.Table Préciser le nom de la table concernée
par le mapping
@jakarta.persistence.Column Associé à un getter, il permet
d'associer un champ de la table à la
propriété de la classe
@jakarta.persistence.Id Associé à un getter, il permet
d'associer un champ de la table à la
propriété en tant que clé primaire
@jakarta.persistence.GeneratedValue Demander la génération automatique
de la clé primaire au besoin
@jakarta.persistence.Basic Représenter la forme de mapping la
plus simple. Cette annotation est
utilisée par défaut
@jakarta.persistence.Transient Demander de ne pas tenir compte du
champ lors du mapping

 L’entité @Table précise le nom de la table concernée par le mapping
au niveau de la base de données, elle est utilisée si le nom de la classe est
différent de celui de la table.
 Elle possède les attributs suivants :
Attribut Rôle
name Nom de la table
Catalog Catalogue de la table
schema Schéma de la table
uniqueConstraints Contraintes d'unicité sur
une ou plusieurs colonnes
Mapping entre une entité et une table : @Table

 L’annotation @Colomn est associée à une propriété d’une entité liée à
un champ de la table au niveau de la base de données
Attribut Rôle
name Nom de la colonne
table Nom de la table dans le cas d'un mapping multi-table
unique Indique si la colonne est unique
nullable Indique si la colonne est nullable
insertable Indique si la colonne doit être prise en compte dans les requêtes
de type insert
updatable Indique si la colonne doit être prise en compte dans les requêtes
de type update
columnDefinition Précise le DDL de définition de la colonne
length Indique la taille d'une colonne de type chaîne de caractères
precision Indique la taille d'une colonne de type numérique
scale Indique la précision d'une colonne de type numérique
Mapping entre une entité et une table : @Column

 L’annotation @GeneratedValue demande la génération automatique de la clé
primaire au besoin
 Le type AUTO est le plus généralement utilisé : il laisse l'implémentation
générer la valeur de la clé primaire ;
 Le type IDENTITY utilise un type de colonne spécial de la base de données.
Attribut Rôle
strategy Précise le type de générateur à utiliser : AUTO, SEQUENCE,
IDENTITY ou TABLE. La valeur par défaut est AUTO
generator Nom du générateur à utiliser
Mapping entre une entité et une table : @GeneratedValue

Exemple :

 Le type SEQUENCE utilise un mécanisme nommé séquence proposé par
certaines bases de données notamment celles d'Oracle ;
 L'utilisation de cette stratégie nécessite l'utilisation de l'annotation
@jakarta.persistence.SequenceGenerator ;
 L'annotation @SequenceGenerator possède plusieurs attributs :
Attribut Rôle
name Nom identifiant le SequenceTableGenerator : il devra être
utilisé comme valeur dans l'attribut generator de l'annotation
@GeneratedValue
sequenceName Nom de la séquence dans la base de données
initialValue Valeur initiale de la séquence
allocationSize Valeur utilisée lors l'incrémentation de la valeur de la
séquence

 Le type TABLE utilise une table dédiée qui stocke les clés des tables générées.
L'utilisation de cette stratégie nécessite l'utilisation de l'annotation
@jakarta.persistence.TableGenerator ;
 L'annotation @TableGenerator possède plusieurs attributs :
Attribut Rôle
name Nom identifiant le TableGenerator : il devra être utilisé comme valeur
dans l'attribut generator de l'annotation @GeneratedValue
table Nom de la table utilisé
catalog Nom du catalogue utilisé
schema Nom du schéma utiliser
pkColumnName Nom de la colonne qui précise la clé primaire à générer
valueColumnName Nom de la colonne qui contient la valeur de la clé primaire générée
pkColumnValue
allocationSize Valeur utilisée lors de l'incrémentation de la valeur de la clé primaire
uniqueConstraints

Exemple
:

 Le modèle de base de données relationnelle permet la définition d'une clé
primaire composée de plusieurs colonnes. JPA propose deux façons de gérer
ce cas de figure :
o L'annotation @jakarta.persistence.IdClass
o L'annotation @jakarta.persistence.EmbeddedId
 L'annotation @IdClass s'utilise avec une classe qui va encapsuler les propriétés
qui composent la clé primaire. Cette classe doit obligatoirement :
o Être sérialisable ;
o Posséder un constructeur sans argument ;
o Fournir une implémentation dédiée des méthodes equals() et hashCode().

Exemple : La clé primaire est composée des champs nom et prenom (exemple
théorique qui présume que deux personnes ne peuvent avoir le même nom et
prénom)

⮚ Il est nécessaire de définir la classe de la clé primaire dans le fichier de
configuration persistence.xml :

 L'annotation @IdClass possède un seul attribut :
 Il faut utiliser l'annotation @IdClass sur la classe de l'entité ;
 Il est nécessaire de marquer chacune des propriétés de l'entité qui compose la
clé primaire avec l'annotation @Id ;
 Ces propriétés doivent avoir le même nom dans l'entité et dans la classe qui
encapsule la clé primaire ;
Attribut Rôle
Class Classe qui encapsule la clé primaire composée

Exemple

 Il n'est pas possible de demander la génération automatique d'une clé
primaire composée ;
 La classe de la clé primaire est utilisée notamment lors de la recherche ;

 L'annotation @EmbeddedId s'utilise avec l'annotation
@jakarta.persistence.Embeddable

 L'annotation @AttributeOverrides est une collection d'attributs
@AttributeOverride ;
 Ces annotations permettent de ne pas avoir à utiliser l'annotation @Column
dans la classe de la clé ou de modifier les attributs de cette annotation dans
l'entité qui la met en œuvre ;
 L'annotation @AttributeOverride possède plusieurs attributs :
Attribut Rôle
name Précise le nom de la propriété de la classe imbriquée
column Précise la colonne de la table à associer à la propriété

 Par défaut, toutes les propriétés sont mappées sur la colonne correspondante
dans la table.
 L'annotation @jakarta.persistence.Transient permet d'indiquer au
gestionnaire de persistance d'ignorer cette propriété.
Mapping entre une entité et une table : @Transient

 L'annotation @jakarta.persistence.Basic représente la forme de mapping la
plus simple.
 @Basic est optionnelle et est celle utilisée par défault ;
 Ce mapping concerne :
o les types primitifs ;
o les wrappers de types primitifs ;
o les tableaux de ces types ;
o les types java.math.BigInteger ;
o java.math.BigDecimal ;
o java.util.Date ;
o java.util.Calendar ;
o java.sql.Date ;
o java.sql.Time et java.sql.Timestamp.
Mapping entre une entité et une table : @Basic

⮚ Exemple :

⮚ L'annotation @Basic possède plusieurs attributs :
Attribut Rôle
fetch Permet de préciser comment la propriété est chargée selon
deux modes :
▪ LAZY : la valeur est chargée uniquement lors de son
utilisation ;
▪ EAGER : la valeur est toujours chargée (valeur par
défaut).
Cette fonctionnalité permet de limiter la quantité de données
obtenues par une requête.
optionnal Indique que la colonne est nullable.

 L'annotation @jakarta.persistence.Temporal permet de fournir des
informations complémentaires sur la façon dont les propriétés encapsulant des
données temporelles (Date et Calendar) ;
 La valeur par défaut est timestamp ;
 Exemple :
Mapping entre une entité et une table : @Temporal

 JPA permet de mapper les champs de types Blob et Clob ;
 L'annotation @jakarta.persistence.Lob permet mapper une propriété sur une
colonne de type Blob ou Clob selon le type de la propriété :
o Blob pour les tableaux de byte ou Byte ou les objets sérializables ;
o Clob pour les chaînes de caractères et les tableaux de caractères char ou
Char.
Mapping entre une entité et une table : @Lob

 L'annotation @jakarta.persistence.Enumerated permet d'associer une
propriété de type énumération à une colonne de la table sous la forme d'un
numérique ou d'une chaîne de caractères ;
 Cette forme est précisée en paramètre de l'annotation grâce à l'énumération
EnumType qui peut avoir comme valeur EnumType.ORDINAL (valeur par
défaut) ou EnumType.STRING.
⮚ exemple :
Mapping entre une entité et une table : @Enumerated

 L'annotation @jakarta.persistence.SecondaryTable permet de préciser qu'une
autre table sera utilisée dans le mapping ;
 Pour utiliser cette fonctionnalité, la seconde table doit posséder une jointure
entre sa clé primaire et une ou plusieurs colonnes de la première table.
 L'annotation @SecondaryTable possède plusieurs attributs :
Attribut Rôle
Name Nom de la table
Catalogue Nom du catalogue
Schema Nom du schéma
pkJoinsColumns Collection des clés primaire de la jointure sous la forme
d'annotations de type @PrimaryKeyJoinColumn
uniqueConstraints
Mapping entre une entité sur plusieurs tables

 L'annotation @PrimaryKeyJoinColumn permet de préciser une colonne qui
compose la clé primaire de la seconde table et entre dans la jointure avec la
première table. Elle possède plusieurs attributs :
 Il est nécessaire pour chaque propriété de l'entité qui est mappée sur la
seconde table de renseigner le nom de la table dans l'attribut table de
l'annotation @Column ;
Attribut Rôle
name Nom de la colonne
referencedColumnNa
me
Nom de la colonne dans la première table (obligatoire si
les noms de colonnes sont différents entre les deux
tables)
columnDefinition
Mapping entre une entité sur plusieurs tables:@SecondaryTable

⮚ Exemple :

 Si le mapping d’une entité utilise plusieurs tables, il faut utiliser l’annotation
@jakarta.persistence.SecondaryTables qui est une collection d’annotation
@SecondaryTables ;
 Exemple :

40
Contexte de persistance
 Ensemble des instances d’entités gérées a un instant donné,
 gérées par qui ? Le gestionnaire d’entités : EntityManager
 Ce contexte peut donc être considéré comme un cache de premier niveau :
c’est un espace réduit ou le gestionnaire stocke les entités avant d’écrire son
contenu dans la base de données,

41
EntityManager: Opérations prises en charge par le
gestionnaire d’entités
NB : Un flush() est automatiquement effectué au moins à chaque commit
de la transaction en cours,

42
Cycle de vie d’une instance d’entité

43
EntityManagerFactory
L’ interface EntityManagerFactory permet d’obtenir une instance de l’objet
EntityManager, EntityManagerFactory emf = Persistence.createEntityManagerFactory("jpa");
« jpa » est le nom de l’unité de persistance, définie dans le fichier de configuration
de la couche JPA METAINF/persistence.xml.

46
Création du gestionnaire d’entité EntityManager
EntityManagerFactory emf = Persistence.createEntityManagerFactory("jpa");
EntityManager em = emf.createEntityManager() ;

47
Exemple d’insertion d’un livre

48
Fonctionnement de JPA
 La Persistence Unit : organise les meta-
données qui définissent le mapping entre
les entités et la base de données dans le
fichier de configuration
METAINF/persistence.xml
 La Persistence Manager Factory récupère
ces metas données de la Persistence Unit et
les interprètent pour créer des Persistence
Manager (EntityManager)
 Le Persistence Mangager (EntiyManager)
gère les échanges entre le code et la base
de données, c’est à dire le cycle de vie des
entités
 Enfin, les opérations du EntityManager est
englobé dans une Transaction.

49
Relations entre entités: Relation un-à-un
@Entity
@Table(name = "jpa03_hb_personne")
public class Personne {
...
@OneToOne(cascade = CascadeType.ALL, fetch=FetchType.LAZY)
/*@OneToOne(cascade = {CascadeType.MERGE, CascadeType.PERSIST,
CascadeType.REFRESH, CascadeType.REMOVE}, fetch=FetchType.LAZY) */
@JoinColumn(name = "adresse_id", unique = true, nullable = false)
private Adresse adresse;
...
}
@Entity
@Table(name = "jpa03_hb_adresse")
public class Adresse{ ...
/*n’est pas obligatoire*/
@OneToOne(mappedBy = "adresse", fetch=FetchType.EAGER)
private Personne personne;
... }

50
Relations entre entités: Relation objets embarqués
L'annotation
@Embeddable est
utilisée dans le contexte
de JPA (Java
Persistence API) pour
indiquer qu'une classe
peut être "intégrée" dans
une autre entité.
L'annotation
@Embedded est utilisée
pour personnaliser le
mappage d'un ou
plusieurs attributs d'une
classe intégrable
annotée avec
@Embeddable

51
Relations entre entités: Relation un-à-plusieurs et plusieurs-à-un
@Entity
@Table(name="jpa05_hb_article")
public class Article {
...
// relation principale Article (many) -> Category (one) implémentée par une
clé // étrangère (categorie_id) dans Article
// 1 Article a nécessairement 1 Categorie (nullable=false)
@ManyToOne(fetch=FetchType.LAZY)
@JoinColumn(name = "categorie_id", nullable = false)
private Categorie categorie; ... }
@Entity
@Table(name="jpa05_hb_categorie")
public class Categorie{
...
// relation inverse Categorie (one) -> Article (many) de la relation Article (many)– > Categorie (one)
@OneToMany(mappedBy = "categorie", cascade = { CascadeType.ALL })
private Set<Article> articles = new HashSet<Article>();
...
}

52
@Entity
@Table(name="jpa06_hb_categorie")
public class Categorie{
...
// relation OneToMany non inverse (absence de mappedby) Categorie (one) -> Article (many)
// implémentée par une table de jointure Categorie_Article pour qu'à partir d'une catégorie
// on puisse atteindre plusieurs articles
@OneToMany(cascade = CascadeType.ALL, fetch = FetchType.LAZY)
private Set<Article> articles = new HashSet<Article>();
...
}
Relations entre entités: Relation un-à-plusieurs et plusieurs-à-un

53
Relations entre entités: Relation plusieurs à plusieurs
@Entity @Table(name = "jpa07_hb_personne") public class
Personne { ...
// relation Personne (many) -> Activite (many) via une table de
jointure personne_activite
@ManyToMany(cascade={CascadeType.PERSIST})
@JoinTable(name="jpa07_hb_personne_activite", joinColumns =
@JoinColumn(name = "PERSONNE_ID"), inverseJoinColumns =
@JoinColumn(name = "ACTIVITE_ID"))
private Set<Activite> activites = new HashSet<Activite>();
...
}
@Entity
@Table(name = "jpa07_hb_activite")
public class Activite{
...
// relation inverse Activite -> Personne
@ManyToMany(mappedBy = "activites")
private Set<Personne> personnes = new HashSet<Personne>();
...
}

54
Relations entre entités
Mapper une relation d’héritage avec la stratégie SINGLE_TABLE

55
Mapper une relation d’héritage avec la stratégie TABLE_PER_CLASS

56
Mapper une relation d’héritage avec la stratégie stratégie JOINED

6- Formation_JPA java jsp jakarta PowerPoint

Contenu connexe

Similaire à 6- Formation_JPA java jsp jakarta PowerPoint

Dernier

6- Formation_JPA java jsp jakarta PowerPoint