Nadhem Bel Hadj Java EE

TP3 : L’API JPA

Introduction
Depuis les débuts de J2EE, le modèle de persistance ne cesse d’évoluer et de
s’engluer de version en version. Les entity beans 1.0 ont été complètement ré-
architecturés pour laisser place aux entity beans 2.1. Bien que cette évolution ait
apporté beaucoup d’améliorations, ce modèle de composants persistants continuait
à faire des détracteurs parmi la communauté.

Ce mécontentement a donné naissance à une nouvelle spécification (JDO, Java

Data Object) ainsi qu’à différents outils de mapping objet/relationnel (ORM) payants
ou libres (TopLink, Hibernate...). Java EE 5, et son lot de nouveautés, nous apporte
un nouveau modèle de persistance : JPA (Java Persistence API). Fortement inspirés
par des outils Open Source tels que Hibernate ou par JDO, le mapping
objet/relationnel et le langage de requête sont totalement différents de l’ancêtre
entity bean 2.1. JPA, ou JSR-220, réconcilie ainsi les utilisateurs de la plate-forme
JEE avec les composants persistants. Java Persistent API s’appuie sur JDBC pour
communiquer avec la base de données.

En revanche, grâce à l’abstraction apportée par JPA, nous n’aurons nul besoin
d’utiliser directement JDBC dans le code Java.
Dans cet atelier nous allons présenter les grands principes de l’API JPA, les étapes
de mise en œuvre d’un projet JPA et illustrer cette présentation par un exemple
d'implémentation.

Qu'est-ce que la persistance des données ?

La durée de vie d'un objet peut dans certains cas correspondre au besoin de celui-ci
d'exister au-delà du temps d'exécution du programme qui l'a créé, l'adresse de l'objet
dans l'espace pouvant changer par rapport à son adresse de création.

La persistance est ainsi le fait d'exister dans le temps. Un objet qui reste en l'état
quand il est sauvegardé puis chargé par une autre application, ou à un moment
éloigné, possède la propriété de persistance. En conséquence, l'objet n'est plus
dépendant de l'application qui l'a créé.

Présentation du JPA
JPA est un standard pour la persistance des objets Java. L'API JPA n'a été
disponible qu'à partir du JDK 1.5. Cette API a emprunté un grand nombre de
concepts et de normes à d’autres Framework leaders dans la persistance comme
Toplink (Oracle) et Hibernate (de JBoss). Un des grands avantages de JPA est que
c'est une API indépendante et peut très bien s'intégrer avec J2EE, ainsi que les
applications J2SE. La couche JPA a sa place dans une architecture multicouche.
L'API de persistance est accessible en utilisant le paquetage Java javax.persistence.
1
Nadhem Bel Hadj Java EE

Mise en œuvre de JPA

1. Créer sous MySql une BD appelée BDJPA,
2. Lancer l'IDE Eclipse,
3. Créer une connexion à la BD BDJPA appelez la MySql_Conn, Aller à : Menu
File > New > Other… > Connection Profile > puis Next :

2
Nadhem Bel Hadj Java EE

4. Cliquez sur l’icône « New Driver Definition » comme suit :

3
Nadhem Bel Hadj Java EE

5. Cliquez sur l’onglet JAR List

6. Cliquez sur « Remove JAR/Zip » puis sur « Add JAR/Zip ». Sélectionnez le

fichier mysql-connector-java-5.1.5-bin.jar (fourni dans le dossier lib, ou à
télécharger)

4
Nadhem Bel Hadj Java EE

Choisissez le driver « MySql JDBC Driver ». Cliquez enfin sur « Finish ».

7. créer un projet JPA (appelé MonProjetJPA par exemple).

5
Nadhem Bel Hadj Java EE

Cliquez sur « Next » puis sur « Next »

Cliquez sur l’icône « Download library… » Comme suit :

Choisissez la plateforme EclipseLink 2.5.2, téléchargé en cliquant sur l’icône de disquette à

droite. Puis cliquez sur « Finish ».

6
Nadhem Bel Hadj Java EE

8. Créer un dossier (Folder) appelé lib sous votre projet,

9. Copier dans le dossier lib le Driver de votre SGBD, ici celui de MySql : mysql-
connector-java-5.1.5-bin.jar (vous pouvez le télécharger)
10. Ajouter le fichier jar du dossier lib aux librairies référencées de votre projet.
Sélectionnez le fichier mysql-connector-java-5.1.5-bin.jar, puis click-droit/ Build
Path/ Add to Build Path
11. Ouvrez votre fichier Persistence.xml et modifier le comme suit :

<?xml version="1.0" encoding="UTF-8"?>

<persistence version="2.1" 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_1.xsd">
<persistence-unit name="MonProjetJPA" transaction-type="RESOURCE_LOCAL">
<properties>
<property name="javax.persistence.jdbc.url"
value="jdbc:mysql://localhost:3306/BDJPA"/>
<property name="javax.persistence.jdbc.user" value="root"/>
<property name="javax.persistence.jdbc.driver"
value="com.mysql.jdbc.Driver"/>
<property name="eclipselink.logging.level" value="FINE"/>
<property name="eclipselink.ddl-generation" value="drop-and-
create-tables"/>
</properties>
</persistence-unit>
</persistence>

12. Créer un nouveau package com.iset.entities, puis créer une classe Client dans ce
package :
package com.iset.entities;

import java.io.Serializable;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class Client implements Serializable{
private static final long serialVersionUID = 1L;

@Id
@GeneratedValue (strategy=GenerationType.IDENTITY)
//pour autoincrement
private int code;
private String nom;
private String ville;
public int getCode() {
return code;
}
public void setCode(int code) {

7
Nadhem Bel Hadj Java EE

this.code = code;
}
public String getNom() {
return nom;
}
public void setNom(String nom) {
this.nom = nom;
}
public String getVille() {
return ville;
}
public void setVille(String ville) {
this.ville = ville;
}
}

13. Pour que l’entité Client soit persister dans la BD, cliquez avec le bouton droit sur le
fichier Persistence.xml puis cliquez sur « Synchronise Class list », remarquez
qu’une ligne sera ajoutée au fichier « Persistence.xml » :
<class>com.iset.entities.Client</class>
Maintenant on va tester notre travail en générant la table « CLIENT » à partir de l’entité
Client (on peut faire l’opération inverse). Cliquez avec le bouton droit sur le
projet/JPA/ Create tables from entities :

8
Nadhem Bel Hadj Java EE

14. Vérifier que JPA a créé la table client dans la BD BDJPA :

9
Nadhem Bel Hadj Java EE

15. Créez le package com.iset.util, puis créez dans ce package la classe JpaUtil :

package com.iset.util;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;

public class JPAutil {

private static EntityManagerFactory factory;
private static EntityManager entityManager;

public static EntityManager getEntityManager(String persistUnit)

{

if (entityManager==null)
{
factory =
Persistence.createEntityManagerFactory(persistUnit);

entityManager = factory.createEntityManager();
}
return entityManager;
}
}

Cette classe permet de faciliter le travail, à chaque fois ou on a besoin d’un entityManager
on appelle la méthode getEntityManager en lui passant le « persistence unit » déclarée
dans le fichier persistence.xml :
<persistence-unit name="MonProjetJPA">

16. Créez le package com.iset.dao contenant la classe ClientDao , cette classe contient
les opérations CRUD (Create, Retrieve, Update, Delete) sur l’entité Client :

package com.iset.dao;

import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.EntityTransaction;
import com.iset.entities.Client;
import com.iset.util.JPAutil;
//classe contenant les méthodes génériques ajouter, supprimer,
consulter par clé primaire (Id)
public class ClientDao {
private EntityManager
entityManager=JPAutil.getEntityManager("MonProjetJPA");

//méthode ajouter d'une entité à la bd

public void ajouter(Clientc)
{

10
Nadhem Bel Hadj Java EE

EntityTransaction tx = entityManager.getTransaction();
tx.begin();
entityManager.persist(c);
tx.commit();

//méthode modifier d'une entité à partir de la bd

public void modifier(Client c)
{
EntityTransaction tx =
entityManager.getTransaction();
tx.begin();
entityManager.merge(c);
tx.commit();

//méthode Supprimer d'une entité à partir de la bd

public void supprimer(Client c)
{
EntityTransaction tx = entityManager.getTransaction();
tx.begin();
c=entityManager.merge(c); // important
entityManager.remove(c);
tx.commit();
}

//méthode Consulter d'une entité à partir de la bd

public Client consulter(Client c,Object id)
{
return entityManager.find(c.getClass(), id);
}

//méthode pour lister tous les objets à partir de la bd

public List<Client> listerTous() {
List<Client> clients =
entityManager.createQuery(
"select c from Client c").getResultList();
return clients;
}
//méthode pour lister tous les client dont le nom contient
un //texte donné en paramètre (pnom)
public List<Client> listerParNom(String nom) {List<Client>
clients =entityManager.createQuery( "select c from Client c where
c.nom like :pnom")
.setParameter("pnom","%"+nom+"%").getResultList();

return clients; }}

11
Nadhem Bel Hadj Java EE

17. Créez le package com.iset.test contenant la classe exécutable ClientTest (contenant

une méthode main()) :

package com.iset.test;

import com.iset.dao.ClientDao;
import com.iset.entities.Client;

public class ClientTest {

public static void main(String[] args) {

//créer un objet client
Client c = new Client();
c.setNom("Bel Hadj Nadhem");
c.setVille("Nabeul");
//ajouter l'objet client à la BD
ClientDao cltDao = new ClientDao();
cltDao.ajouter(c);

System.out.println("Appel de la méthode listerTous");

for (Client cl : cltDao.listerTous())
System.out.println(cl.getCode()+" "+cl.getNom()+"
"+cl.getVille());

System.out.println("Appel de la méthode listerParNom");

for (Client cl : cltDao.listerParNom("nadh"))
System.out.println(cl.getCode()+" "+cl.getNom()+"
"+cl.getVille());

//tester les autres méthodes de la classe ClientDao

}
}

Avant de tester les autres méthodes de la classe ClientDao, Changez dans le fichier
Persistence.xml la valeur de la propriété "toplink.ddl-generation" de la valeur "drop-and-
create-tables" en "none". Et ce pour ne par supprimer les tables et les recréer.

12