Jpa Spring Hibernate

Zaher Yamak

JPA Java Persistence API

Agenda

Zaher Yamak2

Introduction

Les mappings de base

Relations

JPA dans un architecture multi couche

Conclusion

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

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 Composants principaux

AnnotationsGestionnaire

d'entités

JPA Composants principaux

6 Zaher YamakJPA

Agenda

Zaher Yamak7

Introduction

Relations

Conclusion

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

@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

Agenda

Zaher Yamak10

Introduction

Relations

Conclusion

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.

Relations

4 types de relations à définir entre les entités de la JPA:

Un-à-Un

un-à-plusieurs

plusieurs-à-Un

plusieurs-à-plusieurs

Zaher YamakJPA

Relations: Un-à-Un

public class Invoice {

@OneToOne(optional=false)

@JoinColumn(name=“ORDER_ID")

Private Order order;

// getters & setters

@Entity(name = "ORDER_INVOICE")

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 =

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

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

L'entité Invoicecontient tous les

colonnes du tableau de INVOICE comme

attributs et a un objet Order joigné

avec la cleORDER_ID .

Zaher YamakJPA

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

Relations: plusieurs-à-Un

@Entity(name = "ORDERS")

@Id //signifies the primary key

@Column(name = "ORDER_ID", nullable = false)

private long orderId;

@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

Relations: plusieurs-à-plusieurs

@Entity(name = "PRODUCT")

public class Product {

@Column(name = "PROD_ID", nullable = false)

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")

@Column(name = "ORDER_ID", nullable = false)

private long orderId

@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

Agenda

Zaher Yamak17

Introduction

Relations

Conclusion

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

Implémenter entité JPA

Implémenter couche DAO

Implémenter couche Service

Implémenter code coté

Client

Zaher Yamak20

Hibernate et JDBC

Architecture

Spring + JPA + DAO

Client

Zaher Yamak21

Hibernate et JDBC

Architecture

Spring + JPA + DAO

Client

Zaher Yamak22

Hibernate et JDBC

Architecture

Spring + JPA + DAO

Client

La table [personne]

Zaher Yamak23JPA

Zaher Yamak24

Hibernate et JDBC

Architecture

Spring + JPA + DAO

Client

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..

Zaher Yamak26

Hibernate et JDBC

Architecture

Spring + JPA + DAO

Client

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

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

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.

Zaher Yamak30

Hibernate et JDBC

Architecture

Spring + JPA + DAO

Client

Les entités JPA

Zaher Yamak31JPA

Zaher Yamak32

Hibernate et JDBC

Architecture

Spring + JPA + DAO

Client

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

Interface-DAO

Zaher Yamak34JPA

DAO-Delete Personne

Zaher Yamak35JPA

DAO-Save,Update,Get Personne

Zaher Yamak36

Update

Zaher Yamak37

Hibernate et JDBC

Architecture

Spring + JPA + DAO

Client

Zaher Yamak38

Hibernate et JDBC

Architecture

Spring + JPA + DAO

Client

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

Interface-Service

Zaher Yamak40JPA

Service – Delete Personnes

Zaher Yamak41JPA

N.Z.Service - Get,Save,Update Personnes

Zaher Yamak42

Update

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

Oracle 10g Express

44 Zaher YamakJPA

PostgreSQL 8.2

45 Zaher YamakJPA

SQL Server Express 2005

46 Zaher YamakJPA

HSQLDB

47 Zaher YamakJPA

Agenda

Zaher Yamak48

Introduction

Relations

Conclusion

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

Jpa Spring Hibernate

Technology

Transcript of Jpa Spring Hibernate

JPA est middleware

Application Spring MVC/IOC & Hibernate

Classes persistantes et session Hibernate… · 2013. 12. 26. · Hibernate 3.0 24 Dans une telle conﬁguration de base, Hibernate est simple à installer et ne nécessite d’autre

FILIERE CONCEPTEUR / DEVELOPPEUR EN ENVIRONNEMENT OBJET · PERSISTANCE JPA avec Hibernate 4 J Initiation Web avec HTML5, CSS, JAVASCRIPT, BOOTSTRAP 4 J WEB Java EE et les API Servlet

Java persistence et hibernate []

Presentation JPA

Site JEE de ECommerce Basé sur Spring IOC MVC Security JPA Hibernate

4 Hibernate

Hibernate et JSF

Tutoriel Tapestry5 Spring Hibernate

Hibernate Reference2.1.8

Jpa catalogue été 2016

JPA et Java Hibernate JPA - fnac-static.com...Hibernate. Ce livre sur JPA (en version 2.1 au moment de l’écriture) et Java Hibernate s’adresse aux développeurs et étudiants

PAIE - JPA Consultants

XML : Généralités & XPathkn/teaching/lcd/cours/pdf/03.pdf3 Rappels JDBC/Impedance Mismatch/JPA & Hibernate 4 XML : Généralités, langage XPath 4.1 Introduction 4.2 XML 4.3 Validation

10...JPA est implémentée par deux produits de référence : TopLink, un produit commercial (Oracle) devenu libre, et Hibernate. L’architecture de JPA et son intégration dans l’architecture

POUR VOS MÉTIERS PÉNURIQUES · 2018-03-05 · JavaScript, mais aussi avec des Frameworks comme ANGULAR et JQUERY. ... JPA avec HIBERNATE PRÉREQUIS PUBLIC ... Développer des applications

Hibernate 3

Hibernate vs le_cloud_computing

Votre partenaire à l’écoute de vos · PDF fileTP2: implémentation du design pattern Generic-DAO. ... TP: créer une application AVEC: Spring MVC, hibernate, jpa, spring security.