2. N.Z.
Agenda
Introduction
Les mappings de base
Relations
JPA dans un architecture multi couche
Conclusion
JPA 2 Zaher Yamak
3. N.Z.
Definition
La Java Persistence API (abrégée en JPA), est
une interface de programmation Java
permettant aux développeurs d'organiser des
données relationnelles dans des applications
utilisant la plateforme Java.
JPA 3 Zaher Yamak
4. Caractéristiques principales N.Z.
Modèle de
persistance
POJO
Soutien basée
aux
Soutien le
fournisseur
domaine de
s de
modélisation
persistance
enfichable
JPA
Utilisable dans Langage
environnemen de requête
ts Java EE et élargi
Java SE
Objet
normalisé /
cartographie
relationnelle utilisation annotations et/ou
XML
JPA 4 Zaher Yamak
5. Architecture du JPA N.Z.
Java Application Java Persistence API
Hibernate TopLink Kodo (OpenJPA)
•Le plus répandu dans la communauté présentement.
•Toutefois, la responsabilité de compatibilité avec différents serveurs d’application
revient à la communauté.
Chaque personne peut utiliser sa préférable technologie persistance
JPA 5 Zaher Yamak
7. N.Z.
Agenda
Introduction
Les mappings de base
Relations
JPA dans un architecture multi couche
Conclusion
JPA 7 Zaher Yamak
8. N.Z.
Les entités JPA
Cette couche représente le modèle de données objet de
l'application.
Les éléments de cette couche sont tous des Value Objects ;
c'est-à-dire de simples Beans java (POJO) composés de
champs, de getters et de setters.
Ce sont les objets de cette couche qui sont persistés en base
de données par un moteur de persistance:
Chaque objet (ou presque) est la représentation objet d'un
élément ou d'un ensemble d'éléments relationnels (dans le
cas d'un SGBDR).
Dans notre cas, le moteur de persistance est Hibernate
mais il est masqué par JPA.
JPA 8 Zaher Yamak
9. N.Z.
Les annotations
@Enitity => classe est une entite.
Si nom entite != Nom tableau =>@Table
@Column => Nom de la column dans un tableau(Si != nom de l’attribut)
(par defaut, les deux noms sont similaires.)
@Id => cle primaire.
@Version =>version field in an entity.
JPA utilise la colonne version afin de detecter les modifications .
@GeneratedValue => startegie de donner automatiquement
une valeur unique pour les identites
Les types sont IDENTITY, SEQUENCE, TABLE, and AUTO(Par
defaut est auto)
JPA 9 Zaher Yamak
10. N.Z.
Agenda
Introduction
Les mappings de base
Relations
JPA dans un architecture multi couche
Conclusion
JPA 10 Zaher Yamak
11. N.Z.
Les Relations
•Une companie offre des produits.
•Le Client est libre de faire des ordres des produits en combinison ou un seul
produit.
•Un client peut avoir zéro ou plusieurs ordres, et chaque ordre peut être
associé avec un ou plusieurs produits.
•Pour chaque ordre, une facture est générée.
JPA 11 Zaher Yamak
12. N.Z.
Relations
4 types de relations à définir entre les entités de la
JPA:
Un-à-Un
un-à-plusieurs
plusieurs-à-Un
plusieurs-à-plusieurs
JPA Page 12 Zaher Yamak
13. N.Z.
Relations: Un-à-Un
@Entity ORDERS
@Entity(name = "ORDER_INVOICE")
public class Order {
@Id
public class Invoice { targetEntity @Column(name = "ORDER_ID", nullable =
false)
specifie le
@Id @GeneratedValue(strategy =
nom de la GenerationType.AUTO)
@OneToOne(optional=false) classe private long orderId;
@Column(name = "CUST_ID")
private long custId;
@Column(name = "TOTAL_PRICE", precision =
@JoinColumn(name=“ORDER_ID") 2)
private double totPrice;
@Column(name = "OREDER_DESC")
private String orderDesc;
Private Order order; @Column(name = "ORDER_DATE")
private Date orderDt;
// getters & setters @OneToOne(optional=false,ca
… cascade ajouté où on scade=CascadeType.ALL,
} effectue operations: mappedBy="order",targetEnti
insert, update, delete
sur l'entite Order et on ty=Invoice.class)
veut les propager pour private Invoice invoice;
l'objet facture,dans ce
@Version
cas,on utilise l'option @Column(name = "LAST_UPDATED_TIME")
cascade:PERSIST, private Date updatedTime;
L'entité Invoice REFRESH, REMOVE, ou
contient tous les
// getters & setters
MERGE
colonnes du tableau }
de INVOICE comme
attributs et a un
objet Order joigné
avec la cle
ORDER_ID .
JPA Page 13 Zaher Yamak
14. N.Z.
Relations: un-à-plusieurs
@Entity(name = "CUSTOMER")
public class Customer {
@Id //signifies the primary key
@Column(name = "CUST_ID", nullable =
false)
@GeneratedValue(strategy =
GenerationType.AUTO)
private long custId
@OneToMany introduit un
@Column(name = "FIRST_NAME", length nouveau attribut
= 50)
fetch,LAZY.FetchType est sa
private String firstName;
valeur par défaut
@Column(name = "LAST_NAME", nullable LAZY est une allusion pour
= false,length = 50) l'exécution JPA,Lazy loading se
private String lastName; fait d'une facon complètement
transparente; les données sont
chargées dans un objet
@Column(name = "STREET") silencement .
private String street; FetchType.EAGER. quand on
@OneToMany(mappedBy="cust recupère une entité par un query
omer",targetEntity=Order.class, ou par EntityManager, on
garantie le stockage des données
fetch=FetchType.EAGER) dans les champs..
private Collection orders;
JPA Page 14 Zaher Yamak
15. N.Z.
Relations: plusieurs-à-Un
@Entity(name = "ORDERS")
public class Order {
@Id //signifies the primary key
@Column(name = "ORDER_ID", nullable =
false)
La jointure des deux entités
@GeneratedValue(strategy =
Ordre et Client est faite à
GenerationType.AUTO)
l'aide de la colonne de la clé
private long orderId;
étrangère CUST_ID, et ici
@Column(name = "CUST_ID") aussi optional=false car
private long custId; chaque ordre est associé à
@OneToOne(optional=false,cascade=Casca un seul client.
deType.ALL, Alors l'entité Ordre a une
mappedBy="order",targetEntity=Invoi relation un-à- un avec la
ce.class) facture et plusieurs-à -un
private Invoice invoice avec le client.
@ManyToOne(optional=false)
@JoinColumn(name="CUST_ID",re
ferencedColumnName="CUST
_ID")
private Customer customer;
...............
The other attributes and getters and setters
goes here
}
JPA Page 15 Zaher Yamak
16. N.Z.
Relations: plusieurs-à-plusieurs
Entity(name = "ORDERS")
public class Order {
@Entity(name = "PRODUCT")
@Id
public class Product {
@Id @Column(name = "ORDER_ID", nullable = false)
@Column(name = "PROD_ID", nullable = false) @GeneratedValue(strategy = GenerationType.AUTO)
@GeneratedValue(strategy = GenerationType.AUTO) private long orderId
private long prodId; @Column(name = "CUST_ID")
private long custId;
@Column(name = "PROD_NAME", nullable = @Column(name = "TOTAL_PRICE", precision = 2)
false,length = 50) private double totPrice;
private String prodName; @OneToOne(optional=false,cascade=CascadeType.ALL,
mappedBy="order",
@Column(name = "PROD_DESC", length = 200) targetEntity=Invoice.class)
private String prodDescription;
private Invoice invoice;
@Column(name = "REGULAR_PRICE", precision = 2) ORDER_DET @ManyToOne(optional=false)
private String price; AIL tient @JoinColumn(
l'association name="CUST_ID",referencedColumnName="CUST_ID")
@Column(name = "LAST_UPDATED_TIME") entre private Customer customer;
private Date updatedTime; tableaux
@ManyToMany(mappedBy="productList",fetch Order et
@ManyToMany(fetch=FetchType.EAGER)
=FetchType.EAGER) Product.
@JoinTable @JoinTable(name="ORDER_DETAIL",
private List orderList;
............... specifie le joinColumns=
The other attributes and getters and setters goes here tableau qui @JoinColumn(name="ORDER_ID",
} associe referencedColumnName="ORDER_ID"),
order IDs inverseJoinColumns=
avec product @JoinColumn(name="PROD_ID", r
IDs. eferencedColumnName="PROD_ID")
)
private List productList;
...............
JPA Page 16 } Zaher Yamak
17. N.Z.
Agenda
Introduction
Les mappings de base
Relations
JPA dans un architecture multi couche
Conclusion
JPA 17 Zaher Yamak
18. N.Z.
JPA + Hibernate + Spring
L'utilisation de la couche JPA dans des
architectures multi-couches est présentée dans
le contextes suivant :
couches [métier] [dao] et [JPA] utilisant les services (injections,
transactions) du conteneur léger Spring 3.0
JPA 18 Zaher Yamak
19. N.Z.
JPA + Hibernate + Spring etape par etape
Telecharger les
Creer table de
Telecharger les librairies
base de
librairies Spring Hibernate et
donnees
JDBC
Implémenter Architecture
Implémenter
Spring Config Spring + JPA +
entité JPA
File DAO
Implémenter
Implémenter Implémenter
code coté
couche DAO couche Service
Client
JPA 19 Zaher Yamak
20. N.Z.
JPA + Hibernate + Spring etape par etape
Telecharger les
Creer table de
Telecharger les librairies
base de
librairies Spring Hibernate et
donnees
JDBC
Implémenter Architecture
Implémenter
Spring Config Spring + JPA +
entité JPA
File DAO
Implémenter
Implémenter Implémenter
code coté
couche DAO couche Service
Client
JPA 20 Zaher Yamak
21. N.Z.
JPA + Hibernate + Spring etape par etape
Telecharger les
Creer table de
Telecharger les librairies
base de
librairies Spring Hibernate et
donnees
JDBC
Implémenter Architecture
Implémenter
Spring Config Spring + JPA +
entité JPA
File DAO
Implémenter
Implémenter Implémenter
code coté
couche DAO couche Service
Client
JPA 21 Zaher Yamak
22. N.Z.
JPA + Hibernate + Spring etape par etape
Telecharger les
Creer table de
Telecharger les librairies
base de
librairies Spring Hibernate et
donnees
JDBC
Implémenter Architecture
Implémenter
Spring Config Spring + JPA +
entité JPA
File DAO
Implémenter
Implémenter Implémenter
code coté
couche DAO couche Service
Client
JPA 22 Zaher Yamak
24. N.Z.
JPA + Hibernate + Spring etape par etape
Telecharger les
Creer table de
Telecharger les librairies
base de
librairies Spring Hibernate et
donnees
JDBC
Implémenter Architecture
Implémenter
Spring Config Spring + JPA +
entité JPA
File DAO
Implémenter
Implémenter Implémenter
code coté
couche DAO couche Service
Client
JPA 24 Zaher Yamak
25. N.Z.
Le projet Eclipse / Spring / Hibernate
les jars nécessaires
à Spring. rassemble les fichiers de configuration
de Spring pour chacun des SGBD .
le projet Eclipse..
en (2) : les codes Java des couches présentés en paquetages :
(entités) : le paquetage des entités JPA
(dao) : la couche d'accès aux données - s'appuie sur la couche JPA
(service) : une couche de services plus que de métier. On y utilisera le service de
transactions des conteneurs.
(tests) : regroupe les programmes de tests.
JPA 25 Zaher Yamak
26. N.Z.
JPA + Hibernate + Spring etape par etape
Telecharger les
Creer table de
Telecharger les librairies
base de
librairies Spring Hibernate et
donnees
JDBC
Implémenter Architecture
Implémenter
Spring Config Spring + JPA +
entité JPA
File DAO
Implémenter
Implémenter Implémenter
code coté
couche DAO couche Service
Client
JPA 26 Zaher Yamak
27. N.Z.
Configuration des couches
La configuration des couches service, dao et JPA est assurée par
deux fichiers:
META-INF/persistence.xml
spring-config.xml.
JPA 27 Zaher Yamak
28. N.Z.
Persistence.xml
Le fichier déclare une unité de persistance appelée jpa qui utilise
des transactions "locales", c.a.d. non fournies par un conteneur
EJB3.
Ces transactions sont créées et gérées par Spring et font l'objet de
configurations dans le fichier spring-config.xml.
JPA 28 Zaher Yamak
29. N.Z.
Spring-config.xml
Il est complexe et bien des choses restent obscures.
Son adaptation à diverses situations se résume souvent à deux modifications :
celle de l'implémentation JPA : lignes 14-32. Peut être change en Toplink.
celle de la base de données cible : lignes 38-41. Nous donnerons un exemple
MySql.
JPA 29 Zaher Yamak
30. N.Z.
JPA + Hibernate + Spring etape par etape
Telecharger les
Creer table de
Telecharger les librairies
base de
librairies Spring Hibernate et
donnees
JDBC
Implémenter Architecture
Implémenter
Spring Config Spring + JPA +
entité JPA
File DAO
Implémenter
Implémenter Implémenter
code coté
couche DAO couche Service
Client
JPA 30 Zaher Yamak
32. N.Z.
JPA + Hibernate + Spring etape par etape
Telecharger les
Creer table de
Telecharger les librairies
base de
librairies Spring Hibernate et
donnees
JDBC
Implémenter Architecture
Implémenter
Spring Config Spring + JPA +
entité JPA
File DAO
Implémenter
Implémenter Implémenter
code coté
couche DAO couche Service
Client
JPA 32 Zaher Yamak
33. N.Z.
La couche (dao)
Cette couche est en charge de la gestion des relations avec les
sources de données, quelles qu'elles soient.
Elle offre des services d'accès, de recherche, de création, de
mise à jour, de suppression de données stockées dans un format
quelconque (SGBD, LDAP, XML, etc.).
La couche dao présente l'interface Idao et l’implementation Dao de
cette interface.
JPA 33 Zaher Yamak
36. N.Z.
DAO-Save,Update,Get Personne
Get
Save
Update
JPA 36 Zaher Yamak
37. N.Z.
JPA + Hibernate + Spring etape par etape
Telecharger les
Creer table de
Telecharger les librairies
base de
librairies Spring Hibernate et
donnees
JDBC
Implémenter Architecture
Implémenter
Spring Config Spring + JPA +
entité JPA
File DAO
Implémenter
Implémenter Implémenter
code coté
couche DAO couche Service
Client
JPA 37 Zaher Yamak
38. N.Z.
JPA + Hibernate + Spring etape par etape
Telecharger les
Creer table de
Telecharger les librairies
base de
librairies Spring Hibernate et
donnees
JDBC
Implémenter Architecture
Implémenter
Spring Config Spring + JPA +
entité JPA
File DAO
Implémenter
Implémenter Implémenter
code coté
couche DAO couche Service
Client
JPA 38 Zaher Yamak
39. N.Z.
La couche ( metier / service )
Cette couche implémente l'ensemble de la logique métier de
l'application
Elle s'appuie sur les couches DAO et model pour effectuer des
opérations CRUD (Create, Research, Update, Delete) sur des objets
persistés et leur appliquer ensuite des traitements métier.
Cette couche est responsable des aspects transverses :
– Sécurité
– transactions.
Elle déclare et gère l'ensemble des processus transactionnels vers la
couche DAO.
JPA 39 Zaher Yamak
41. N.Z.
Service – Delete Personnes
JPA 41 Zaher Yamak
42. N.Z.
Service - Get,Save,Update Personnes
Get
Save
Update
JPA 42 Zaher Yamak
43. N.Z.
Changer de SGBD
L'application cliente 3 ne voit que l'interface JPA
5.
Elle ne voit pas ni l'implémentation réelle de
celle-ci, ni le SGBD cible.
On doit changer ces deux éléments de la chaîne
sans changements dans le client 3.
JPA 43 Zaher Yamak
48. N.Z.
Agenda
Introduction
Les mappings de base
Relations
JPA dans un architecture multi couche
Conclusion
JPA 48 Zaher Yamak
49. N.Z.
CONCLUSION
Ce tutoriel a apporté des exemples pour la construction
d'architectures multi-couches où:
l'accès aux données est contrôlé par une couche JPA
les couches service et dao s'exécutent ausein d'un conteneur
Spring
Des points JPA n'ont pas été abordés :
cache des entités
traduction de la notion objet d'héritage dans un schéma de
SGBD.
JPA 49 Zaher Yamak