Département Génie Informatique

Java Entreprise Edition

Pr. Aimad QAZDAR
a.qazdar@uiz.ac.ma

14 novembre 2022
JPA-Hibernate
Introduction
● La quasi-totalité des applications (développées en approche orienté objet) utilisent des
système de gestion de base de données relationnel pour gérer et stocker leur données.
● La correspondance des données entre le modèle relationnel et le modèle objet doit faire
face à plusieurs problèmes :
− le modèle objet propose plus de fonctionnalités : héritage, polymorphisme, ...
− les relations entre les entités des deux modèles sont différentes.
− les objets ne possèdent pas d’identifiant en standard (hormis son adresse mémoire qui varie
d’une exécution à l’autre).
− Dans le modèle relationnel, chaque occurrence devrait posséder un identifiant unique

146
Introduction
● La première approche pour faire une correspondance entre ces deux modèles a été
d’utiliser l’API JDBC fournie en standard avec le JDK.
● Cependant, cette approche possède plusieurs inconvénients majeurs:
− nécessite l’écriture de nombreuses lignes de codes, souvent répétitives.
− le mapping entre les tables et les objets est un travail de bas niveau.
● Tous ces facteurs réduisent la productivité mais aussi les possibilités d’évolutions et de
maintenance.
● De plus, une grande partie de ce travail peut être automatisé.

147
Persistance des données & ORM
● La persistance des données est la notion qui traite de la sauvegarde de données
contenue dans des objets sur un support informatique.
● Le mapping Objet/Relationnel (Object-Relational Mapping : ORM) consiste à réaliser la
correspondance entre une application, modélisé en conception orientée objet, et une base
de données relationnelle.
● L’ORM a pour but d’établir la correspondance entre : une table de la base de données et
une classe du modèle objet

Programmation Base de données

Classe Table
Attributs Champs dans une table
Reference entre Relation entre tables
classe
Un objet Un enregistrement dans une
table

148
Fonctionnalités ORM
● Un outil de ORM doit proposer un certain nombre de fonctionnalités parmi lesquelles :
− Assurer le mapping des tables avec les classes, des champs avec les attributs, des relations
et des cardinalités.
− Proposer une interface qui permette de facilement mettre en œuvre des actions de type
CRUD.
− Éventuellement permettre l’héritage des mappings.
− Proposer un langage de requêtes indépendant de la base de données cible et assurer une
traduction en SQL natif selon la base utilisée.
− Supporter différentes formes d’identifiants générés automatiquement par les bases de
données (identity, sequence, ...).

149
Fonctionnalités ORM
● Autres fonctionnalités proposées :
− Support des transactions.
− Gestion des accès concurrents (verrou, dead lock, etc.).
− Fonctionnalités pour améliorer les performances (cache, lazy loading, etc)
● Les solutions de mapping sont riches en fonctionnalités ce qui peut rendre leur mise en
œuvre plus ou moins complexe.
● Les solutions de ORM permettent de réduire la quantité de code à produire mais
impliquent une partie configuration (généralement sous la forme d’un ou plusieurs fichiers
XML ou d’annotations).

150
Java Persistence API (JPA)
● Il s’agit d’un standard faisant partie intégrante de la plate-forme Java EE (JSR 220).
● Une spécification qui définit un ensemble de règles permettant la gestion de la
correspondance entre des objets Java et une base de données, ou autrement formulé la
gestion de la persistance.
● Les interfaces de JPA décrivent comment respecter le standard, mais il faut utiliser une
solution/Framework qui fait l’implémentation de JPA.
● JPA repose sur des entités qui sont de simples POJOs annotés et sur un gestionnaire de
ces entités (EntityManager) qui propose des fonctionnalités pour les manipuler (CRUD).
● Ce gestionnaire (EntityManager) est responsable de la gestion de l'état des entités et de
leur persistance dans la base de données.
● JPA est définie dans le package javax.persistence

151
Les Frameworks ORM
● Différentes solutions sont apparues :
− TopLink est un framework d’ORM pour le développement Java. TopLink Essentials est la
version open source du produit d'Oracle. Au mois de mars 2008, Sun Microsystems fait
succéder EclipseLink à TopLink comme implémentation de référence de la JPA 2.0.
− EclipseLink est un framework open source de ORM pour les développeurs Java. Il fournit une
plateforme puissante et flexible permettant de stocker des objets Java dans une base de
données relationnelle et/ou de les convertir en documents XML. Il est développé par
l’organisation Fondation Eclipse
− Hibernate est un framework open source gérant la persistance des objets en base de
données relationnelle, développé par l’entreprise JBoss.
− Apache OpenJPA est une implémentation open source de la JPA. Il s'agit d'une solution
d’ORM pour le langage Java simplifiant le stockage des objets dans une base de données
relationnelle. Il est distribué sous licence Apache.
● la plupart de ces solutions sortent du cadre défini par JPA, et proposent des
fonctionnalités annexes qui leur sont propres.

152
ORM-JPA
● Modèles d’architecturaux:
− JDBC sans DAO
− JDBC avec DAO
− ORM avec DAO

154
Hibernate - JPA
● Hibernate est une solution open source , écrit en java, de type qui permet de faciliter le
développement de la couche persistance d'une application.
● Hibernate facilite la persistance et la recherche de données dans une base de données
en réalisant lui-même la création des objets et les traitements de remplissage de ceux-ci
en accédant à la base de données.
● Hibernate a été écrit sous la responsabilité de Gavin King qui fait partie de l’équipe JBoss.

155
Hibernate - JPA
● Hibernate propose son propre langage d’interrogation HQL et
a largement inspiré les concepteurs de l’API JPA.
● Hibernate est très populaire notamment à cause de ses
bonnes performances et de son ouverture à de nombreuses
bases de données.
● Les bases de données supportées sont les principales du
marché : HSQL Database Engine, DB2/NT, MySQL,
PostgreSQL, FrontBase, Oracle, Microsoft SQL Server
Database, Sybase SQL Server, Informix Dynamic Server, etc.

156
Hibernate - JPA
● Pratiquement :
− Les correspondances se font via des annotations JPA dans les classes,
− L’implémentation fournit une API pour manipuler les données,
− JPA s’appuie sur JDBC pour communiquer avec une base de données.
● Exemple :
− Enitity Book
− Persitence.xml
− EntityManager

157
Entity Book
● Création d’une classe encapsulant les données
Classe Java : Livre Table SQL : Book

public class Book {

private long book_id;
private String title;
private String author;
private float price;
}

● Remarque :
Une classe pour laquelle il existe une correspondance en base de donnée est appelée
une entité.

158
Entity Book

import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Table;

@Entity @Table(name ="book")

public class Book {
@Id
private long book_id;
private String title;
private String author;
private float price;

162
Quelques annotation JPA de Mapping des Entités
● @Entity dit que la classe Book est soumisse à persistance : c'est une entité persistante.
● @Table permet de spécifier le nom de la table (en base de données)
● @Id indique que l'attribut book_id de votre classe est « mappé » à la colonne de clé
primaire en base de données
● @Column utilisé dans le cas ou l’attribut et la colonne n’ont pas exactement le même
nom.
@Column( name="UnitaryPrice" )
private float price;
● @GeneratedValue indique que le moteur de base de données généré les nouvelles
valeurs pour la clé primaire (Auto-incrémente).
● Etc…

163
Moteur de persistence : persistence.xml
● Pour que votre moteur JPA puisse correctement fonctionner, il est nécessaire de le
configurer
● Cela se fait via le fichier META-INF/persistence.xml.
● Ce fichier doit être accessible à partir du CLASSPATH : sous Eclipse,
● Le dossier META-INF doit être localisé dans votre dossier src,

164
persistence.xml
<?xml version="1.0" encoding="UTF-8"?>
<persistence version="2.2"
xmlns="http://xmlns.jcp.org/xml/ns/persistence"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/persistence
http://xmlns.jcp.org/xml/ns/persistence/persistence_2_2.xsd">
<persistence-unit name="Bookstore">
<provider>org.hibernate.jpa.HibernatePersistenceProvider</provider>
<class>entity.Book</class>
<properties>
<property name="javax.persistence.jdbc.driver"
value="com.mysql.jdbc.Driver" />
<property name="javax.persistence.jdbc.url"
value="jdbc:mysql://localhost:3306/bookstore" />
<property name="javax.persistence.jdbc.user" value="root" />
<property name="javax.persistence.jdbc.password" value="" />
</properties>
</persistence-unit>
</persistence>

165
persistence.xml
● La ligne correspondant au « provider » spécifie l'implémentation JPA adoptée (Hibernate
dans notre cas).
● Voici les chaînes de définitions associées aux principales implémentations :

Nom de l'implémentation JPA Configuration du provider

Hibernate (RedHat) org.hibernate.jpa.HibernatePersistenceProvider
Eclipse Link org.eclipse.persistence.jpa.PersistenceProvider
Open JPA org.apache.openjpa.persistence.PersistenceProviderImpl

166
EntityManager
● Un EntityManager permet de réaliser les opérations CRUD sur une base de données via
une unité de persistance particulière.
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import java.util.ArrayList;
import java.util.List;
import javax.persistence.Query;

public class MainClass {

public static void main(String[] args) throws Exception{

// TODO Auto-generated method stub

EntityManagerFactory emf ;
emf = Persistence.createEntityManagerFactory("Bookstore");
persistence.xml
EntityManager em; …
em = emf.createEntityManager(); <persistence-unit name="Bookstore">
…
167
Méthodes de la classe EntityManager
● crateQuery()

System.out.println("display all");

Query q = em.createQuery( "from Book", Book.class );

List<Book> books = new ArrayList<>() ;
books = q.getResultList();
for (Book b : books) {
System.out.println( b.getBook_id()+" "+b.getTitle()+" "+b.getAuthor()+" "+b.getPrice());
}

● persist()
System.out.println("Add new");

em.getTransaction().begin();
Book php = new Book(3,"PHP","Mohammed",230);
em.persist(php);
em.getTransaction().commit();

168
Méthodes de la classe EntityManager
● find()
System.out.println("Find");

long id =3;
Book b = em.find(Book.class, id);
System.out.println(b.getBook_id()+" "+b.getTitle()+" "+b.getAuthor()+" "+b.getPrice());

● createQuery()
System.out.println("Create query");

Query q;
String reqJPQL = "SELECT b FROM Book b WHERE b.price>=:p";
q = entityManager.createQuery(reqJPQL);
float p=300;
q.setParameter("p", p);

List<Book> books = new ArrayList<>() ;

books = q.getResultList();
for (Book b : books) {
System.out.println(b.getBook_id()+" "+b.getTitle()+" "+b.getAuthor()+" "+b.getPrice());
}
169
Méthodes de la classe EntityManager

● merge()
System.out.println("Update");

em.getTransaction().begin();
b.setPrice(260);
em.merge(b);
em.getTransaction().commit();

● remove()
System.out.println("Delete");

em.getTransaction().begin();
em.remove(b);
em.getTransaction().commit();

170