La solution de persistance en Java:                JPA          Sadok Ben Yahia
Motivation      L’Objet est devenu le style fondamental de la programmationUML                Conception                  ...
Solution ?ORM : Object / Relational Mapping        encapsulation          attribut                                        ...
ORM c’est quoi?                  Le mapping objet relationnel crée une illusion                  d’une BDOO à partir d’une...
Un peu d’histoire …• Entity Beans EJB 1.0 -> 2.1  – Complexité     • EJB2.x "entity" et les EJB2.x "session » :         – ...
Un peu d’histoire …•   Les équipes IT se sont de plus en plus tournés vers d’autres produits sur le    marché:•   Hibernat...
Les besoins• Clairement, 2 grands besoins se dégagèrent,  répondant à l’industrie et aux développeurs:1. Avoir une API sim...
Motivations•La couche [1], (User Interface) est la couche qui dialogue aveclutilisateur, via une interface graphique Swing...
MotivationsLa couche [2], est la couche qui applique les règles ditesmétier, i.e., la logique spécifique de lapplication, ...
Motivations• La couche [3], (Data Access Object) est la couche qui fournit àla couche [2] des données pré-enregistrées (fi...
Avec Hibernate• La couche [Hibernate] vient se placer entre la couche [dao] écrite par le  développeur et la couche [Jdbc]...
Cependant…• Hibernate est populaire mais complexe à maîtriser:   – Dès quon a une base de données avec des tables ayant de...
Finalement JPA•  Sun standardise une couche ORM via une spécification appelée JPA  (apparue avec Java 5).• La couche [dao]...
Présentation de JPA• JPA est un standard pour la persistance des objets Java    – LAPI JPA est récente. Elle na été dispon...
Outils JPA• Open source  – Eclipse 3.2.x w  – NetBeans 5.5• Commerciaux  – Oracle Jdeveloper  – BEA Workshop Studio (Eclip...
personne                                         matiere                          + cin_pers    : int                     ...
matiere                                                                                   + code_mat : int                ...
Comparaison Hibernate vs JPA• Points Communs   – Offrir des services de persistance   – Mapping Objet/Relationnel déclarat...
Mapping Objet RelationnelLa communication entre les mondes objet et relationnel supposeune transformation pour adapter la ...
Fichier de configuration :                 persistence.xml• Un seul fichier de configuration XML   – Il est nécessaire d’i...
Fichier de configuration                           21
Les Entités• Les classes dont les instances peuvent être persistantes  sont appelées des entités dans la spécification de ...
Cycle de vie d’une entité                            23
Classes entités : Entity Class• Une classe entité doit posséder un attribut qui représente  la clé primaire dans la BD (@I...
Les annotationsAnnotation                          Rôle@javax.persistence.Table            Préciser le nom de la table con...
Lannotation              @javax.persistence.Table• Permet de lier lentité à une table de la base  de données. Par défaut, ...
Lannotation              @javax.persistence.Column•   Permet dassocier un membre de lentité à une colonne de la table. Par...
Lannotation @Id• Il faut obligatoirement définir une des propriétés de la  classe avec lannotation @Id pour la déclarer co...
EXEMPLEimport java.io.Serializable; import javax.persistence.Entity; import    javax.persistence.GeneratedValue; import ja...
Cas d’une Clé primaire composée• Le modèle de base de données relationnelle  permet la définition dune clé primaire  compo...
Lannotation @javax.persistence.IdClass• Lannotation @IdClass sutilise avec une classe  qui va encapsuler les propriétés qu...
Exemple: PersonnePK (1/3)public class PersonnePK implements java.io.Serializable {private static final long serialVersionU...
Exemple: (2/3)• Il est nécessaire de définir la classe de la clé primaire dans le fichier de  configuration persistence.xm...
•                             Exemple (3/3)    Il faut utiliser lannotation@IdClass sur la classe de lentité.•   Il est né...
Classes entités : Embedded Class• Il existe des classes incorporées (embedded)  dont les données n’ont pas d’identité dans...
EntityManager• Classe javax.persistence.EntityManager   – Le gestionnaire d’entités est l’interlocuteur principal pour le ...
Cycle de vie d’un EntityManager• La méthode createEntityManager() de la  classe EntityManagerFactory créé un Entity  Manag...
Fabrique de l’EntityManager• La classe Persistence permet d’obtenir une  fabrique de gestionnaire d’entités par la méthode...
Méthodes de EntityManager• void flush()     • Toutes les modifications effectuées sur les entités du       contexte de per...
Méthodes de EntityManager• void lock(Object entité, LockModeType lockMode)   – Le fournisseur de persistance gère les accè...
Utilisation de EntityManager pour la       création dune occurrence• Pour insérer une nouvelle entité dans la base  de don...
EXEMPLEimport javax.persistence.EntityManager;import javax.persistence.EntityManagerFactory;import javax.persistence.Entit...
Utilisation de EntityManager pour      rechercher des occurrences• Pour effectuer des recherches de données,  lEntityManag...
Avec Find()import javax.persistence.EntityManager;import javax.persistence.EntityManagerFactory;import javax.persistence.P...
Avec getReference()import javax.persistence.EntityManager;import javax.persistence.EntityManagerFactory;import javax.persi...
Queries• Il est possible de rechercher des données sur des  critères plus complexes que la simple identité.  Les étapes so...
Interface Query• Représente une requête  – Une instance de Query (d’une classe    implémentant Query) est obtenue des méth...
Lobjet Queryimport javax.persistence.EntityManager;import javax.persistence.EntityManagerFactory;import javax.persistence....
Query+la méthode getResultList()import java.util.List;import javax.persistence.EntityManager;import javax.persistence.Enti...
Les paramètres nommés+import java.util.List;                       setParameter()import javax.persistence.EntityManager;im...
modifier une occurrence avec le            EntityManager• Pour modifier une entité existante dans la  base de données, il ...
Exempleimport javax.persistence.EntityManager;import javax.persistence.EntityManagerFactory;import javax.persistence.Entit...
supprimer une occurrence avec           EntityManager• Pour supprimer une entité existante dans la  base de données:  – Ob...
Exempleimport javax.persistence.EntityManager;import javax.persistence.EntityManagerFactory;import javax.persistence.Entit...
Rafraîchir les données dune                     occurrenceimport javax.persistence.EntityManager;import javax.persistence....
Queries: NamedQueries• Peut être mise dans n’importe quelle entité,  mais on choisira le plus souvent l’entité qui  corres...
@Entity@NamedQuery(name="myQuery", query="Select o from MyPojo   o")public class MyPojo { … }public class MyService {publi...
Queries: NativeQueries• Une façon de faire des requête en SQL natif.   – Sert principalement à avoir plus de contrôle sur ...
Relations• Dans le modèle des bases de données relationnelles,  les tables peuvent être liées entre elles grâce à des  rel...
Relationships: One to One                            60
Relationship: Many to One                            61
Relationship: One to Many                            62
Relationships: Many to Many                              63
Prochain SlideShare
Chargement dans…5
×

Jpa(1)

1 244 vues

Publié le

jpa

0 commentaire
1 j’aime
Statistiques
Remarques
  • Soyez le premier à commenter

Aucun téléchargement
Vues
Nombre de vues
1 244
Sur SlideShare
0
Issues des intégrations
0
Intégrations
6
Actions
Partages
0
Téléchargements
85
Commentaires
0
J’aime
1
Intégrations 0
Aucune incorporation

Aucune remarque pour cette diapositive

Jpa(1)

  1. 1. La solution de persistance en Java: JPA Sadok Ben Yahia
  2. 2. Motivation L’Objet est devenu le style fondamental de la programmationUML Conception O2, EyeBD Comment faire correspondance entre O/R Base de données OO Développement ???Langage orientéobjet: java c# c++... 4
  3. 3. Solution ?ORM : Object / Relational Mapping encapsulation attribut SQL ligne 5
  4. 4. ORM c’est quoi? Le mapping objet relationnel crée une illusion d’une BDOO à partir d’une BDR Donc on peut bénéficier de l’orienté objet et gérer une BD relationnelle d’une façon transparente. public class Obj { private int id; private String name; Id name public Obj(){ } .. .. public Obj(String name) { … .. this.name = name; … .. } public void setId(int i) { id = i; } …. }Il existe plusieurs Framework de mappingobjet/relationnel : Java Persistance API, TopLink, JavaData Object, Hibernate, Object Relational Bridge… 7
  5. 5. Un peu d’histoire …• Entity Beans EJB 1.0 -> 2.1 – Complexité • EJB2.x "entity" et les EJB2.x "session » : – un EJB2.x "entity" est limage dune ligne de table de BD – EJB2.x "session" un objet utilisé pour implémenter les couches [metier], [dao] dune architecture multi-couches • La courbe d’apprentissage trop prononcée • Modèle de programmation non-intuitif (ne sont utilisables quau sein de conteneurs EJB) – Performance • Le coût pour effectuer certaines requêtes était hors de proportions, 5
  6. 6. Un peu d’histoire …• Les équipes IT se sont de plus en plus tournés vers d’autres produits sur le marché:• Hibernate – Le plus répandu dans la communauté présentement. Toutefois, la responsabilité de compatibilité avec différents serveurs d’application revient à la communauté.• JDO – Bien que JDO soit un standard, appuyé par la JSR 243 (JDO 2.0), cette technologie a reçu bien peu d’appui.• Produits commerciaux (ex. TopLink) – API propriétaires, onéreux, non-standard …• Ces trois solutions fonctionnent globalement suivant les mêmes principes : – Des fichiers de mapping pour faire correspondre les tables aux classes java – Des beans Java simples correspondant aux objets métiers : ceux sont ces beans que manipule le développeur – Une API de persistance qui permet de rendre persistant dans la BD les beans métiers. On retrouve généralement les mêmes verbes (insert, update, delete, get) – Un langage de requêtes proche du SQL mais manipulant les propriétés des beans. 6
  7. 7. Les besoins• Clairement, 2 grands besoins se dégagèrent, répondant à l’industrie et aux développeurs:1. Avoir une API simple d’utilisation, attrayante pour les développeurs, appliquant les techniques apprises des cadres d’applications de la communauté open source.2. Avoir un standard respecté par les fournisseurs de serveurs d’applications. 7
  8. 8. Motivations•La couche [1], (User Interface) est la couche qui dialogue aveclutilisateur, via une interface graphique Swing, une interface consoleou une interface web. Elle a pour rôle de fournir des donnéesprovenant de lutilisateur à la couche [2] ou bien de présenter àlutilisateur des données fournies par la couche [2]. 8
  9. 9. MotivationsLa couche [2], est la couche qui applique les règles ditesmétier, i.e., la logique spécifique de lapplication, sans sepréoccuper de savoir doù viennent les données quon luidonne, ni où vont les résultats quelle produit. 9
  10. 10. Motivations• La couche [3], (Data Access Object) est la couche qui fournit àla couche [2] des données pré-enregistrées (fichiers, bases dedonnées, ...) et qui enregistre certains des résultats fournis par lacouche [2].• la couche *JDBC+ est la couche standard utilisée en Java pouraccéder à des bases de données. Cest ce quon appellehabituellement le pilote Jdbc du SGBD 10
  11. 11. Avec Hibernate• La couche [Hibernate] vient se placer entre la couche [dao] écrite par le développeur et la couche [Jdbc]. Hibernate est un ORM (Object Relational Mapping), un outil qui fait le pont entre le monde relationnel des bases de données et celui des objets manipulés par Java. Le développeur de la couche [dao] ne voit plus la couche [Jdbc] ni les tables de la base de données dont il veut exploiter le contenu. Il ne voit que limage objet de la base de données, image objet fournie par la couche [Hibernate].• Le pont entre les tables de la base de données et les objets manipulés par la couche [dao] est faite principalement de deux façons : – par des fichiers de configuration de type XML – par des annotations Java dans le code, technique disponible seulement depuis le JDK 1.5 11
  12. 12. Cependant…• Hibernate est populaire mais complexe à maîtriser: – Dès quon a une base de données avec des tables ayant des relations un-à-plusieurs ou plusieurs-à-plusieurs, la configuration du pont relationnel / objets nest pas évidente. – Des erreurs de configuration peuvent alors conduire à des applications peu performantes.• La solution TopLink (commerciale) 12
  13. 13. Finalement JPA• Sun standardise une couche ORM via une spécification appelée JPA (apparue avec Java 5).• La couche [dao] dialogue maintenant avec la spécification JPA, un ensemble dinterfaces. Le développeur y a gagné en standardisation, i.e., Avant, sil changeait sa couche ORM, il devait également changer sa couche [dao] qui avait été écrite pour dialoguer avec un ORM spécifique. Maintenant, il va écrire une couche [dao] qui va dialoguer avec une couche JPA. Quelque soit le produit qui implémente celle-ci, linterface de la couche JPA présentée à la couche [dao] reste la même. 13
  14. 14. Présentation de JPA• JPA est un standard pour la persistance des objets Java – LAPI JPA est récente. Elle na été disponible quà partir du JDK 1.6. – LAPI de persistance est accessible en utilisant le paquetage Java javax.persistence. – La spécification JPA a été implémentée par les deux produits : Toplink et Hibernate.• LAPI Java Persistence repose sur : – des entités qui sont de simples POJOs (Plain Old Java Object). annotés, et – un gestionnaire de ces entités (EntityManager) qui propose des fonctionnalités pour les manipuler (ajout, modification suppression, recherche). Ce gestionnaire est responsable de la gestion de létat des entités et de leur persistance dans la base de données. 14
  15. 15. Outils JPA• Open source – Eclipse 3.2.x w – NetBeans 5.5• Commerciaux – Oracle Jdeveloper – BEA Workshop Studio (Eclipse++) – JBoss IDE (Eclipse++) gratuit 15
  16. 16. personne matiere + cin_pers : int + code_mat : int + nom_pers : java.lang.String + nom_mat : java.lang.String + prenom_pers : java.lang.String 0..* 0..* filiere prof Etudiant 0..* + code_fil : int + grade : java.lang.String + moy_et : float + nom_fil : java.lang.String 1..1 matiere code_mat int <pk> personne nom_mat varchar(254) cin_pers int <pk> nom_pers varchar(254) FK_filMatPOJO: prenom_pers varchar(254) fil_mat- Personne code_fil int <pk,fk1> code_mat int <pk,fk2>- Prof FK_Heritage_1 FK_Heritage_2- Etudiant FK_filMat- Filiere prof Etudiant- Matiere Fichiers XML cin_pers int <pk,fk> cin_pers int <pk,fk2> FK_etFil filiere grade varchar(254) code_fil int <fk1> code_fil int <pk> moy_et float nom_fil varchar(254) 11
  17. 17. matiere + code_mat : int + nom_mat : java.lang.Stringpackage persistClass; <?xml version="1.0"?> <!DOCTYPE hibernate-mapping PUBLICpublic class Matiere { "-//Hibernate/Hibernate Mapping DTDprivate String nom; 3.0//EN"private Integer codeMat; "http://hibernate.sourceforge.net/hibernat e-mapping-3.0.dtd"> packagepublic Matiere(){}public Matiere(Integer code,String nom) <hibernate-mapping>{ <class name="persistClass.Matiere" this.nom = nom; table="matiere"> POJO this.codeMat=code;} <id name="codeMat" type="int" column="code_mat"></id>public String getNom() { Clé primaire return nom;} <property name="nom" type="string"public void setNom(String nom) { this.nom = nom; attribut length="50" column="nom_mat"/>}public Integer getCodeMat() { </class> return codeMat; </hibernate-mapping>}public void setCodeMat(Integer code) { - Ce fichier xml sera sauvegardé sous le nom Matiere.hbm.xml this.codeMat = code; et dans le même répertoire que son POJO correspondant.}} - On peut aussi mapper tous les POJO dans un seul fichier. 12
  18. 18. Comparaison Hibernate vs JPA• Points Communs – Offrir des services de persistance – Mapping Objet/Relationnel déclaratif – Adopter un langage de requêtes• Points de divergence – JPA est une brique de base du standard Java EE 5 – Hibernate est un Framework alors que JPA est une spécification (API) – Hibernate peut être utilisé comme fournisseur de persistance – JPA utilise les annotations Java 5 pour assurer le mapping – JPA est plus simple à mettre en œuvre que Hibernate (Entity Manager, pas de fichiers de mapping, …) 18
  19. 19. Mapping Objet RelationnelLa communication entre les mondes objet et relationnel supposeune transformation pour adapter la structure des donnéesrelationnelles au modèle objet. 19
  20. 20. Fichier de configuration : persistence.xml• Un seul fichier de configuration XML – Il est nécessaire d’indiquer au fournisseur de persistance comment il peut se connecter à la base de données – Ce fichier peut aussi comporter d’autres informations• Le fichier persistence.xml doit être stocké dans le répertoire META−INF• La racine du document XML du fichier persistence.xml est le tag <persistence>.• Il contient un ou plusieurs tags <persistence−unit> qui va contenir les paramètres dun persistence unit. Ce tag possède deux attributs – : name (obligatoire) qui précise le nom de lunité et qui servira à y faire référence et – transaction−type (optionnel) qui précise le type de transaction utilisée (ceci dépend de lenvironnement dexécution : Java SE ou Java EE). 20
  21. 21. Fichier de configuration 21
  22. 22. Les Entités• Les classes dont les instances peuvent être persistantes sont appelées des entités dans la spécification de JPA – Le développeur indique qu’une classe est une entité en lui associant l’annotation @Entity – Il faut importer javax.persistence.Entity dans les classes entités.• Les entités dans les spécifications de lAPI Java Persistence permettent dencapsuler les données dune occurrence dune ou plusieurs tables.• Ce sont de simples POJO – Un POJO est une classe Java qui nimplémente aucune interface particulière ni nhérite daucune classe mère spécifique. 22
  23. 23. Cycle de vie d’une entité 23
  24. 24. Classes entités : Entity Class• Une classe entité doit posséder un attribut qui représente la clé primaire dans la BD (@Id) – Elle doit avoir un constructeur sans paramètre protected ou public sans argument et la classe du bean doit obligatoirement être marquée avec lannotation @javax.persistence.Entity. Cette annotation possède un attribut optionnel nommé name qui permet de préciser le nom de lentité dans les requêtes. Par défaut, ce nom est celui de la classe de lentité. – Elle ne doit pas être final – Aucune méthode ou champ persistant ne doit être final – Une entité peut être une classe abstraite mais elle ne peut pas être une interface 24
  25. 25. Les annotationsAnnotation Rôle@javax.persistence.Table Préciser le nom de la table concernée par le mapping@javax.persistence.Column Associé à un getter, il permet dassocier un champ de la table à la propriété@javax.persistence.Id Associé à un getter, il permet dassocier un champ de la table à la propriété en tant que clé primaire@javax.persistence.GeneratedValue Demander la génération automatique de la clé primaire au besoin@javax.persistence.Basic Représenter la forme de mapping la plus simple. Cette annotation est utilisée par défaut@javax.persistence.Transient Demander de ne pas tenir compte du champ lors du mapping 25
  26. 26. Lannotation @javax.persistence.Table• Permet de lier lentité à une table de la base de données. Par défaut, lentité est liée à la table de la base de données correspondant au nom de la classe de lentité. Si ce nom est différent alors lutilisation de lannotation @Table est obligatoire. Attributs Rôle name Nom de la table catalog Catalogue de la table … … 26
  27. 27. Lannotation @javax.persistence.Column• Permet dassocier un membre de lentité à une colonne de la table. Par défaut, les champs de lentité sont liés aux champs de la table dont les noms correspondent. Si ces noms sont différents alors lutilisation de lannotation @Column est obligatoire. Attributs Rôle name Nom de la colonne table Nom de la table dans le cas dun 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 27
  28. 28. Lannotation @Id• Il faut obligatoirement définir une des propriétés de la classe avec lannotation @Id pour la déclarer comme étant la clé primaire de la table.• Cette annotation peut marquer soit le champ de la classe concernée soit le getter de la propriété.• Lutilisation de lun ou lautre précise au gestionnaire s’il doit se baser sur les champs ou les getter pour déterminer les associations entre lentité et les champs de la table. La clé primaire peut être constituée dune seule propriété ou composées de plusieurs propriétés qui peuvent être de type primitif ou chaîne de caractères 28
  29. 29. EXEMPLEimport java.io.Serializable; import javax.persistence.Entity; import javax.persistence.GeneratedValue; import javax.persistence.Id;@Entitypublic class Personne implements Serializable {@Id@GeneratedValueprivate int id;private String prenom; private String nom;private static final long serialVersionUID = 1L;public Personne() { super(); }public int getId() { return this.id; }public void setId(int id) {this.id = id; }public String getPrenom() { return this.prenom; }public void setPrenom(String prenom) {this.prenom = prenom;}public String getNom() {return this.nom; }public void setNom(String nom) { this.nom = nom;}} 29
  30. 30. Cas d’une Clé primaire composée• Le modèle de base de données relationnelle permet la définition dune clé primaire composée de plusieurs colonnes.• LAPI Java Persistence propose deux façons de gérer ce cas de figure : – Lannotation @javax.persistence.IdClass – Lannotation @javax.persistence.EmbeddedId 30
  31. 31. Lannotation @javax.persistence.IdClass• Lannotation @IdClass sutilise avec une classe qui va encapsuler les propriétés qui composent la clé primaire. Cette classe doit obligatoirement : – Être sérialisable – Posséder un constructeur sans arguments – Fournir une implémentation dédiée des méthodes equals() et hashCode() 31
  32. 32. Exemple: PersonnePK (1/3)public class PersonnePK implements java.io.Serializable {private static final long serialVersionUID = 1L;private String nom; private String prenom;public PersonnePK() { }public PersonnePK(String nom, String prenom) {this.nom = nom; this.prenom = prenom; }public String getNom() { return this.nom;}public void setNom(String nom) { this.nom = nom; }public String getPrenom() {return prenom;}public void setPrenom(String prenom) {this.nom = prenom;}public boolean equals(Object obj) { boolean resultat = false;if (obj == this) {resultat = true;} else { if (!(obj instanceof PersonnePK)) { resultat = false;}else { PersonnePK autre = (PersonnePK) obj;if (!nom.equals(autre.nom)) {resultat = false;} else {if (prenom != autre.prenom) {resultat = false;} else { resultat = true; }} }}return resultat;}public int hashCode() {return (nom + prenom).hashCode();}} 32
  33. 33. Exemple: (2/3)• Il est nécessaire de définir la classe de la clé primaire dans le fichier de configuration persistence.xml<?xml version="1.0" encoding="UTF−8"?><persistence xmlns="http://java.sun.com/xml/ns/persistence"xmlns:xsi="http://www.w3.org/2001/XMLSchema−instance"version="1.0" xsi:schemaLocation="http://java.sun.com/xml/ns/persistencehttp://java.sun.com/xml/ns/persistence/persistence_1_0.xsd"><persistence−unit name="MaBaseDeTestPU"><provider>oracle.toplink.essentials.PersistenceProvider</provider><class>com.jmd.test.jpa.Personne</class><class>com.jmd.test.jpa.PersonnePK</class></persistence−unit></persistence> 33
  34. 34. • Exemple (3/3) Il faut utiliser lannotation@IdClass sur la classe de lentité.• Il est nécessaire de marquer chacune des propriétés de lentité qui compose la clé primaire avec lannotation @Id. Ces propriétés doivent avoir le même nom dans lentité et dans la classe qui encapsule la clé primaire.import java.io.Serializable; import javax.persistence.Entity;import javax.persistence.Id; import javax.persistence.IdClass;@Entity@IdClass(PersonnePK.class)public class Personne implements Serializable {private String prenom; private String nom; private int taille;private static final long serialVersionUID = 1L;public Personne() { super();}@Idpublic String getPrenom() {return this.prenom;}public void setPrenom(String prenom) {this.prenom = prenom;}@Idpublic String getNom() {return this.nom;}public void setNom(String nom) {this.nom = nom;}public int getTaille() {return this.taille;}public void setTaille(int taille) {this.taille = taille;}} 34
  35. 35. Classes entités : Embedded Class• Il existe des classes incorporées (embedded) dont les données n’ont pas d’identité dans la BD mais sont insérées dans une des tables associées à une entité persistante – Par exemple, une classe Adresse dont les valeurs sont insérées dans la table Employe 35
  36. 36. EntityManager• Classe javax.persistence.EntityManager – Le gestionnaire d’entités est l’interlocuteur principal pour le développeur.• Les interactions entre la base de données et les beans entité sont assurées par un objet de type javax.persistence.EntityManager : il permet de lire et rechercher des données mais aussi de les mettre à jour (ajout, modification, suppression). LEntityManager est donc au coeur de toutes les actions de persistance. – Il fournit les méthodes pour gérer les entités : • les rendre persistantes, • les supprimer de la base de données, • retrouver leurs valeurs dans la base, • etc. 36
  37. 37. Cycle de vie d’un EntityManager• La méthode createEntityManager() de la classe EntityManagerFactory créé un Entity Manager – L’Entity Manager est supprimé avec la méthode close() de la classe EntityManager, il ne sera plus possible de l’utiliser ensuite. 37
  38. 38. Fabrique de l’EntityManager• La classe Persistence permet d’obtenir une fabrique de gestionnaire d’entités par la méthode createEntityManagerFactory• 2 variantes surchargées de cette méthode : – 1 seul paramètre qui donne le nom de l’unité de persistance (définie dans le fichier persistence.xml) – Un 2ème paramètre de type Map qui contient des valeurs qui vont écraser les propriétés par défaut contenues dans persistence.xml 38
  39. 39. Méthodes de EntityManager• void flush() • Toutes les modifications effectuées sur les entités du contexte de persistance gérées par l’EntityManager sont enregistrées dans la BD – void persist(Object entité) • Une entité nouvelle devient une entité gérée, l’état de l’entité sera sauvegardé dans la BD au prochain flush ou commit. – void remove(Object entité) • Une entité gérée devient supprimée, les données correspondantes seront supprimées de la BD 39
  40. 40. Méthodes de EntityManager• void lock(Object entité, LockModeType lockMode) – Le fournisseur de persistance gère les accès concurrents aux données de la BD représentées par les entités avec une stratégie optimiste, lock permet de modifier la manière de gérer les accès concurrents à une entité• void refresh(Object entité) • L’EntityManager peut synchroniser avec la BD une entité qu’il gère en rafraichissant son état en mémoire avec les données actuellement dans la BD. • Utiliser cette méthode pour s’assurer que l’entité a les mêmes données que la BD.• <T> T find(Class<T> classeEntité,Object cléPrimaire) • La recherche est polymorphe : lentité récupérée peut être de la classe passée en paramètre ou dune sous-classe (renvoie null si aucune entité n’a l’identificateur passé en paramètre) 40
  41. 41. Utilisation de EntityManager pour la création dune occurrence• Pour insérer une nouvelle entité dans la base de données, il faut : – Instancier une occurrence de la classe de lentité – Initialiser les propriétés de lentité – Définir les relations de lentité avec dautres entités, et au besoin – Utiliser la méthode persist() de lEntityManager en passant en paramètre lentité 41
  42. 42. EXEMPLEimport javax.persistence.EntityManager;import javax.persistence.EntityManagerFactory;import javax.persistence.EntityTransaction;import javax.persistence.Persistence;public class TestJPA {public static void main(String[]argv) {EntityManagerFactory emf = Persistence.createEntityManagerFactory("MaBaseDeTestPU");EntityManager em = emf.createEntityManager();EntityTransaction transac = em.getTransaction();transac.begin(); Personne nouvellePersonne = new Personne(); nouvellePersonne.setId(4); nouvellePersonne.setNom("nom4"); nouvellePersonne.setPrenom("prenom4"); em.persist(nouvellePersonne);transac.commit();em.close(); 42emf.close();}}
  43. 43. Utilisation de EntityManager pour rechercher des occurrences• Pour effectuer des recherches de données, lEntityManager propose deux mécanismes : – La recherche à partir de la clé primaire – La recherche à partir dune requête utilisant une syntaxe dédiée• Pour la recherche par clé primaire, la classe EntityManager possède les méthodes find() et getReference() qui attendent toutes les deux en paramètres un objet de type Class représentant la classe de lentité et un objet qui contient la valeur de la clé primaire. 43
  44. 44. Avec Find()import javax.persistence.EntityManager;import javax.persistence.EntityManagerFactory;import javax.persistence.Persistence;public class TestJPA5 {public static void main(String[] argv) {EntityManagerFactory emf = Persistence.createEntityManagerFactory("MaBaseDeTestPU");EntityManager em = emf.createEntityManager();Personne personne = em.find(Personne.class, 4);if (personne != null) {System.out.println("Personne.nom=" + personne.getNom());}em.close();emf.close();}} 44
  45. 45. Avec getReference()import javax.persistence.EntityManager;import javax.persistence.EntityManagerFactory;import javax.persistence.EntityNotFoundException;import javax.persistence.Persistence;public class TestJPA6 {public static void main(String[] argv) {EntityManagerFactory emf = Persistence.createEntityManagerFactory("MaBaseDeTestPU");EntityManager em = emf.createEntityManager();try {Personne personne = em.getReference(Personne.class, 5);System.out.println("Personne.nom=" + personne.getNom());} catch (EntityNotFoundException e) { System.out.println("personne non trouvée"); }em.close();emf.close(); } } 45
  46. 46. Queries• Il est possible de rechercher des données sur des critères plus complexes que la simple identité. Les étapes sont alors les suivantes : 1. Décrire ce qui est recherché (langage JPQL) 2. Créer une instance de type Query 3. Initialiser la requête (paramètres, pagination) 4. Lancer l’exécution de la requête• JPA introduit le JPQL (Java Persistence Query Language), qui est, tout comme le EJBQL ou encore le HQL, un langage de requête du modèle objet, basé sur SQL. 46
  47. 47. Interface Query• Représente une requête – Une instance de Query (d’une classe implémentant Query) est obtenue des méthodes dédiées de la classe EntityManager : • createQuery (), • createNativeQuery () ou • createNamedQuery () 47
  48. 48. Lobjet Queryimport javax.persistence.EntityManager;import javax.persistence.EntityManagerFactory;import javax.persistence.Persistence;import javax.persistence.Query;public class TestJPA7 {public static void main(String[] argv) {EntityManagerFactory emf = Persistence.createEntityManagerFactory("MaBaseDeTestPU");EntityManager em = emf.createEntityManager();Query query = em.createQuery("select p from Personne p where p.nom=nom2");Personne personne = (Personne) query.getSingleResult();if (personne == null) {System.out.println("Personne non trouvée");} else { System.out.println("Personne.nom=" + personne.getNom());}em.close(); emf.close();}} 48
  49. 49. Query+la méthode getResultList()import java.util.List;import javax.persistence.EntityManager;import javax.persistence.EntityManagerFactory;import javax.persistence.Persistence;import javax.persistence.Query;public class TestJPA8 {public static void main(String[] argv) {EntityManagerFactory emf = Persistence.createEntityManagerFactory("MaBaseDeTestPU");EntityManager em = emf.createEntityManager();Query query = em.createQuery("select p.nom from Personne p where p.id > 2");List noms = query.getResultList();for (Object nom : noms) { System.out.println("nom = "+nom); }em.close();emf.close();} 49}
  50. 50. Les paramètres nommés+import java.util.List; setParameter()import javax.persistence.EntityManager;import javax.persistence.EntityManagerFactory;import javax.persistence.Persistence;import javax.persistence.Query;public class TestJPA9 {public static void main(String[] argv) {EntityManagerFactory emf = Persistence.createEntityManagerFactory("MaBaseDeTestPU");EntityManager em = emf.createEntityManager();Query query = em.createQuery("select p.nom from Personne p where p.id > :id");query.setParameter("id", 1);List noms = query.getResultList();for (Object nom : noms) { System.out.println("nom = "+nom); }em.close();emf.close(); 50}}
  51. 51. modifier une occurrence avec le EntityManager• Pour modifier une entité existante dans la base de données, il faut : – Obtenir une instance de lentité à modifier (par recherche sur la clé primaire ou lexécution dune requête) – Modifier les propriétés de lentité – Selon le mode de synchronisation des données de lEntityManager, il peut être nécessaire dappeler la méthode flush() explicitement 51
  52. 52. Exempleimport javax.persistence.EntityManager;import javax.persistence.EntityManagerFactory;import javax.persistence.EntityTransaction;import javax.persistence.Persistence;import javax.persistence.Query;public class TestJPA10 { public static void main(String[] argv) {EntityManagerFactory emf = Persistence.createEntityManagerFactory("MaBaseDeTestPU");EntityManager em = emf.createEntityManager();EntityTransaction transac = em.getTransaction();transac.begin();Query query = em.createQuery("select p from Personne p where p.nom=nom2");Personne personne = (Personne) query.getSingleResult();if (personne == null) { System.out.println("Personne non trouvée");} else { System.out.println("Personne.prenom=" + personne.getPrenom());personne.setPrenom("prenom2 modifié");em.flush();personne = (Personne) query.getSingleResult();System.out.println("Personne.prenom=" + personne.getPrenom());} transac.commit(); 52
  53. 53. supprimer une occurrence avec EntityManager• Pour supprimer une entité existante dans la base de données: – Obtenir une instance de lentité à supprimer (par recherche sur la clé primaire ou lexécution dune requête) – Appeler la méthode remove() de lEntityManager en lui passant en paramètre linstance de lentité 53
  54. 54. Exempleimport javax.persistence.EntityManager;import javax.persistence.EntityManagerFactory;import javax.persistence.EntityTransaction;import javax.persistence.Persistence;public class TestJPA12 { public static void main(String[] argv) {EntityManagerFactory emf = Persistence.createEntityManagerFactory("MaBaseDeTestPU");EntityManager em = emf.createEntityManager();EntityTransaction transac = em.getTransaction();transac.begin();Personne personne = em.find(Personne.class, 4);if (personne == null) { System.out.println("Personne non trouvée");} else { em.remove(personne);}transac.commit(); em.close(); emf.close(); } } 54
  55. 55. Rafraîchir les données dune occurrenceimport javax.persistence.EntityManager;import javax.persistence.EntityManagerFactory;import javax.persistence.EntityTransaction;import javax.persistence.Persistence;public class TestJPA13 { public static void main(String[] argv) {EntityManagerFactory emf = Persistence.createEntityManagerFactory("MaBaseDeTestPU");EntityManager em = emf.createEntityManager();EntityTransaction transac = em.getTransaction();transac.begin();Personne personne = em.find(Personne.class, 4);if (personne == null) { System.out.println("Personne non trouvée");} else { em.refresh(personne);}transac.commit(); em.close(); emf.close();}} 55
  56. 56. Queries: NamedQueries• Peut être mise dans n’importe quelle entité, mais on choisira le plus souvent l’entité qui correspond à ce qui est renvoyé par la requête• On peut sauvegarder des gabarits de requête dans nos entités. Ceci permet : – La réutilisation de la requête – D’externaliser les requête du code. 56
  57. 57. @Entity@NamedQuery(name="myQuery", query="Select o from MyPojo o")public class MyPojo { … }public class MyService {public void myMethod() {…List results =em.createNamedQuery("myQuery").getResultList();… 57
  58. 58. Queries: NativeQueries• Une façon de faire des requête en SQL natif. – Sert principalement à avoir plus de contrôle sur les requêtes à la base de donnéepublic class MyService {public void myMethod() {…List results= em.createNativeQuery(“SELECT * FROM MyPojo“, MyPojo.class).getResultList();…}} 58
  59. 59. Relations• Dans le modèle des bases de données relationnelles, les tables peuvent être liées entre elles grâce à des relations.• Ces relations sont transposées dans les liaisons que peuvent les différentes entités correspondantes.• 4 types de relations à définir entre les entités de la JPA: – 1−1 (One to One) – 1−n (Many to One) – 1−n (One to Many) – n−n (Many to Many) 59
  60. 60. Relationships: One to One 60
  61. 61. Relationship: Many to One 61
  62. 62. Relationship: One to Many 62
  63. 63. Relationships: Many to Many 63

×