jpa spring hibernate
TRANSCRIPT
N.Z.
Zaher Yamak
JPA Java Persistence API
N.Z.
Agenda
Zaher Yamak2
Introduction
Les mappings de base
Relations
JPA dans un architecture multi couche
Conclusion
JPA
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.
Zaher Yamak3JPA
N.Z.
JPA
Modèle de persistance
POJO basée
Soutien le domaine de modélisation
Langage de requête
élargi
Objet normalisé / cartographie relationnelle
Utilisable dans environnements Java EE et
Java SE
Soutien aux
fournisseurs de
persistance enfichable
Caractéristiques principales
utilisation annotations et/ouXML
4 Zaher YamakJPA
N.Z.Architecture du JPA
Java Application Java Persistence API
Hibernate TopLink Kodo (OpenJPA)
5 Zaher Yamak
•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
N.Z.
JPA Composants principaux
AnnotationsGestionnaire
d'entités
JPA Composants principaux
6 Zaher YamakJPA
N.Z.
Agenda
Zaher Yamak7
Introduction
Les mappings de base
Relations
JPA dans un architecture multi couche
Conclusion
JPA
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 Hibernatemais il est masqué par JPA.
8 Zaher YamakJPA
N.Z.
@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)
Les annotations
9 Zaher YamakJPA
N.Z.
Agenda
Zaher Yamak10
Introduction
Les mappings de base
Relations
JPA dans un architecture multi couche
Conclusion
JPA
N.Z.
Les Relations
Zaher Yamak11
•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
N.Z.
Page 12
Relations
4 types de relations à définir entre les entités de la JPA:
Un-à-Un
un-à-plusieurs
plusieurs-à-Un
plusieurs-à-plusieurs
Zaher YamakJPA
N.Z.
Page 13
Relations: Un-à-Un
public class Invoice {
@OneToOne(optional=false)
@JoinColumn(name=“ORDER_ID")
Private Order order;
// getters & setters
…
}
@Entity(name = "ORDER_INVOICE")
@Id
public class Order {
@Column(name = "ORDER_ID", nullable =
false)
@GeneratedValue(strategy =
GenerationType.AUTO)
private long orderId;
@Column(name = "CUST_ID")
private long custId;
@Column(name = "TOTAL_PRICE", precision =
2)
private double totPrice;
@Column(name = "OREDER_DESC")
private String orderDesc;
@Column(name = "ORDER_DATE")
private Date orderDt;
@OneToOne(optional=false,ca
scade=CascadeType.ALL,
mappedBy="order",targetEnti
ty=Invoice.class)
private Invoice invoice;
@Version
@Column(name = "LAST_UPDATED_TIME")private Date updatedTime;
// getters & setters
}
@Entity ORDERS
@Id
targetEntityspecifie le nom de la
classe
cascade ajouté où on effectue operations:insert, update, deletesur l'entite Order et on veut les propager pour l'objet facture,dans ce cas,on utilise l'option
cascade:PERSIST, REFRESH, REMOVE, ou
MERGE
L'entité Invoicecontient tous les
colonnes du tableau de INVOICE comme
attributs et a un objet Order joigné
avec la cleORDER_ID .
Zaher YamakJPA
N.Z.
Page 14
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
@Column(name = "FIRST_NAME", length = 50)
private String firstName;
@Column(name = "LAST_NAME", nullable= false,length = 50)
private String lastName;
@Column(name = "STREET")
private String street; @OneToMany(mappedBy="customer",targetEntity=Order.class,
fetch=FetchType.EAGER)
private Collection orders;
@OneToMany introduit un nouveau attribut
fetch,LAZY.FetchType est sa valeur par défaut
LAZY est une allusion pour l'exécution JPA,Lazy loading se fait d'une facon complètement transparente; les données sont
chargées dans un objet silencement .
FetchType.EAGER. quand on recupère une entité par un query
ou par EntityManager, on garantie le stockage des données
dans les champs..
Zaher YamakJPA
N.Z.
Page 15
Relations: plusieurs-à-Un
@Entity(name = "ORDERS")
public class Order {
@Id //signifies the primary key
@Column(name = "ORDER_ID", nullable = false)
@GeneratedValue(strategy = GenerationType.AUTO)
private long orderId;
@Column(name = "CUST_ID")
private long custId;
@OneToOne(optional=false,cascade=CascadeType.ALL, mappedBy="order",targetEntity=Invoice.class)
private Invoice invoice
@ManyToOne(optional=false)
@JoinColumn(name="CUST_ID",referencedColumnName="CUST_ID")
private Customer customer;
...............
The other attributes and getters and setters goes here
}
La jointure des deux entités Ordre et Client est faite à
l'aide de la colonne de la clé étrangère CUST_ID, et ici aussi optional=false car
chaque ordre est associé à un seul client.
Alors l'entité Ordre a une relation un-à- un avec la facture et plusieurs-à -un
avec le client.
Zaher YamakJPA
N.Z.
Page 16
Relations: plusieurs-à-plusieurs
@Entity(name = "PRODUCT")
public class Product {
@Id
@Column(name = "PROD_ID", nullable = false)
@GeneratedValue(strategy = GenerationType.AUTO)
private long prodId;
@Column(name = "PROD_NAME", nullable =
false,length = 50)
private String prodName;
@Column(name = "PROD_DESC", length = 200)
private String prodDescription;
@Column(name = "REGULAR_PRICE", precision = 2)
private String price;
@Column(name = "LAST_UPDATED_TIME")
private Date updatedTime;
@ManyToMany(mappedBy="productList",fetch
=FetchType.EAGER)
private List orderList; ...............
The other attributes and getters and setters goes here
}
ORDER_DETAIL tient
l'association entre
tableaux Order et Product.
@JoinTablespecifie le tableau qui
associe order IDs
avec productIDs.
Entity(name = "ORDERS")
public class Order {
@Id
@Column(name = "ORDER_ID", nullable = false)
@GeneratedValue(strategy = GenerationType.AUTO)
private long orderId
@Column(name = "CUST_ID")
private long custId;
@Column(name = "TOTAL_PRICE", precision = 2)
private double totPrice;
@OneToOne(optional=false,cascade=CascadeType.ALL,
mappedBy="order",
targetEntity=Invoice.class)
private Invoice invoice;
@ManyToOne(optional=false)
@JoinColumn(
name="CUST_ID",referencedColumnName="CUST_ID")
private Customer customer;
@ManyToMany(fetch=FetchType.EAGER)
@JoinTable(name="ORDER_DETAIL",
joinColumns=
@JoinColumn(name="ORDER_ID", referencedColumnName="ORDER_ID"),
inverseJoinColumns=
@JoinColumn(name="PROD_ID", r
eferencedColumnName="PROD_ID")
)
private List productList;
...............
} Zaher YamakJPA
N.Z.
Agenda
Zaher Yamak17
Introduction
Les mappings de base
Relations
JPA dans un architecture multi couche
Conclusion
JPA
N.Z.
JPA + Hibernate + Spring
L'utilisation de la couche JPA dans des architectures multi-couches est présentée dansle contextes suivant :
couches [métier] [dao] et [JPA] utilisant les services (injections, transactions) du conteneur léger Spring 3.0
Zaher Yamak18JPA
N.Z.JPA + Hibernate + Spring etape par etape
Zaher Yamak19
Telecharger les librairies Spring
Telecharger les librairies
Hibernate et JDBC
Creer table de base de donnees
Architecture
Spring + JPA + DAO
Implémenter Spring Config
File
Implémenter entité JPA
Implémenter couche DAO
Implémenter couche Service
Implémenter code coté
Client
JPA
N.Z.JPA + Hibernate + Spring etape par etape
Zaher Yamak20
Telecharger les librairies Spring
Telecharger les librairies
Hibernate et JDBC
Creer table de base de donnees
Architecture
Spring + JPA + DAO
Implémenter Spring Config
File
Implémenter entité JPA
Implémenter couche DAO
Implémenter couche Service
Implémenter code coté
Client
JPA
N.Z.JPA + Hibernate + Spring etape par etape
Zaher Yamak21
Telecharger les librairies Spring
Telecharger les librairies
Hibernate et JDBC
Creer table de base de donnees
Architecture
Spring + JPA + DAO
Implémenter Spring Config
File
Implémenter entité JPA
Implémenter couche DAO
Implémenter couche Service
Implémenter code coté
Client
JPA
N.Z.JPA + Hibernate + Spring etape par etape
Zaher Yamak22
Telecharger les librairies Spring
Telecharger les librairies
Hibernate et JDBC
Creer table de base de donnees
Architecture
Spring + JPA + DAO
Implémenter Spring Config
File
Implémenter entité JPA
Implémenter couche DAO
Implémenter couche Service
Implémenter code coté
Client
JPA
N.Z.
La table [personne]
Zaher Yamak23JPA
N.Z.JPA + Hibernate + Spring etape par etape
Zaher Yamak24
Telecharger les librairies Spring
Telecharger les librairies
Hibernate et JDBC
Creer table de base de donnees
Architecture
Spring + JPA + DAO
Implémenter Spring Config
File
Implémenter entité JPA
Implémenter couche DAO
Implémenter couche Service
Implémenter code coté
Client
JPA
N.Z.Le projet Eclipse / Spring / Hibernate
25 Zaher Yamak
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.
rassemble les fichiers de configuration de Spring pour chacun des SGBD .
les jars nécessaires à Spring.
le projet Eclipse..
JPA
N.Z.JPA + Hibernate + Spring etape par etape
Zaher Yamak26
Telecharger les librairies Spring
Telecharger les librairies
Hibernate et JDBC
Creer table de base de donnees
Architecture
Spring + JPA + DAO
Implémenter Spring Config
File
Implémenter entité JPA
Implémenter couche DAO
Implémenter couche Service
Implémenter code coté
Client
JPA
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.
27 Zaher YamakJPA
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.
28 Zaher YamakJPA
N.Z.
Spring-config.xml
celle de la base de données cible : lignes 38-41. Nous donnerons un exemple MySql.
29 Zaher Yamak
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.
JPA
N.Z.JPA + Hibernate + Spring etape par etape
Zaher Yamak30
Telecharger les librairies Spring
Telecharger les librairies
Hibernate et JDBC
Creer table de base de donnees
Architecture
Spring + JPA + DAO
Implémenter Spring Config
File
Implémenter entité JPA
Implémenter couche DAO
Implémenter couche Service
Implémenter code coté
Client
JPA
N.Z.
Les entités JPA
Zaher Yamak31JPA
N.Z.JPA + Hibernate + Spring etape par etape
Zaher Yamak32
Telecharger les librairies Spring
Telecharger les librairies
Hibernate et JDBC
Creer table de base de donnees
Architecture
Spring + JPA + DAO
Implémenter Spring Config
File
Implémenter entité JPA
Implémenter couche DAO
Implémenter couche Service
Implémenter code coté
Client
JPA
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.
33 Zaher YamakJPA
N.Z.
Interface-DAO
Zaher Yamak34JPA
N.Z.
DAO-Delete Personne
Zaher Yamak35JPA
N.Z.
DAO-Save,Update,Get Personne
Zaher Yamak36
Save
Update
Get
JPA
N.Z.JPA + Hibernate + Spring etape par etape
Zaher Yamak37
Telecharger les librairies Spring
Telecharger les librairies
Hibernate et JDBC
Creer table de base de donnees
Architecture
Spring + JPA + DAO
Implémenter Spring Config
File
Implémenter entité JPA
Implémenter couche DAO
Implémenter couche Service
Implémenter code coté
Client
JPA
N.Z.JPA + Hibernate + Spring etape par etape
Zaher Yamak38
Telecharger les librairies Spring
Telecharger les librairies
Hibernate et JDBC
Creer table de base de donnees
Architecture
Spring + JPA + DAO
Implémenter Spring Config
File
Implémenter entité JPA
Implémenter couche DAO
Implémenter couche Service
Implémenter code coté
Client
JPA
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.
39 Zaher YamakJPA
N.Z.
Interface-Service
Zaher Yamak40JPA
N.Z.
Service – Delete Personnes
Zaher Yamak41JPA
N.Z.Service - Get,Save,Update Personnes
Zaher Yamak42
Get
Save
Update
JPA
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.
43 Zaher YamakJPA
N.Z.
Oracle 10g Express
44 Zaher YamakJPA
N.Z.
PostgreSQL 8.2
45 Zaher YamakJPA
N.Z.
SQL Server Express 2005
46 Zaher YamakJPA
N.Z.
HSQLDB
47 Zaher YamakJPA
N.Z.
Agenda
Zaher Yamak48
Introduction
Les mappings de base
Relations
JPA dans un architecture multi couche
Conclusion
JPA
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.
49 Zaher YamakJPA
N.Z.
Merci