Java Persistence Api

[e-mail]
Page 1
Java Persistence Api
Cet article décrit une application qui illustre comment la sauvegarde d’un graphe d’objets peut être
réalisé en Java Standard Edition via Java Persistence Api.
1. Introduction
Java Standard Edition intègre à présent une API de persistance : Java Persistence Api (JPA). JPA
permet de réaliser un Mapping Objet Relationnel en assurant la synchronisation d’un graphe d’objets
avec des tables dans une base de données. Le but étant de masquer le plus possible la base de
données sous-jacente. Il est par exemple possible de générer automatiquement les tables de la base
à partir du code Java. De plus, le code, bien qu’à la norme Java Standard Edition, est compatible avec
la norme Enterprise Java Bean (EJB 3.0).
Technologies utilisées :
- Eclipse
- Hibernate 3
- Spring 3
2. Un premier exemple
Commençons par étudier un exemple d’utilisation de JPA :
EntityManagerFactory emf = …
EntityManager em = emf.createEntityManager(); // 4
EntityTransaction tx = em.getTransaction(); // 3
tx.begin();
Voiture voiture = new Voiture(); // 1
em.persist(voiture); // 2
tx.commit();
La partie essentielle sont les lignes 1 et 2 où on créé un objet de type Voiture, mais ce pourrait être
n’importe quel objet Java, puis on demande sa sauvegarde dans la basse de données via la méthode
em.persist(voiture). Le reste du code, notamment la ligne 3, montre qu’il est possible de
réaliser des transactions. L’EntityManager (ligne 4) est le point d’entrée principal de JPA car c’est via
un EntityManager qu’on accède aux méthodes de sauvegarde, de recherche, de suppression… dans
la base de données.
3. L’application
L’application utilisée pour illustrer l’utilisation de JPA permet à des particuliers de louer des voitures.
Elle dispose d’une interface utilisateur basique dans laquelle on saisit le nom d’une personne
désirant louer une voiture définit par son numéro d’immatriculation :

[e-mail]
Page 2
Le code de cette interface graphique occupe la couche Présentation dans l’architecture de
l’application (voir la figure suivante).
4. La couche Application
L’interface graphique accède à la couche Application via une interface :
package application;
public interface Location {
public void louer(String nomPersonne, String immatriculation) throws
VoitureException;
public void ajouterVoiture(String immatriculation) throws
VoitureException;
/**
*
* @param nomPersonne
* @return Le numero d'immatriculation de la voiture louee par
nomPersonne ou null si la personne n'a pas louee de voiture

[e-mail]
Page 3
* @throws PersonneException si il n'y a pas de personne ayant le nom
nomPersonne
*/
public String rechercheVoiture(String nomPersonne) throws
PersonneException;
}
Une implantation est bien évidement associée à cette interface : la classe LocationImpl qui n’est pas
détaillée ici.
5. La couche métier (les classes persistantes)
La couche Métier est composé de 2 classes, Voiture et Personne associées entre elles par une
association de 1 vers plusieurs.
Ce sont ces 2 classes qui vont être mappées en base de données avec 2 tables. Voici la partie
principale du code de la classe Personne :
package business;
@Entity
public class Personne {
Voiture voiture;
private long id;
@ManyToOne
public Voiture getVoiture() {
return voiture;
}
public void setVoiture(Voiture voiture) {
this.voiture = voiture;
}
@TableGenerator(
name = "personneGen",
table="PERSONNE_SEQUENCE_GENERATOR",
pkColumnName="GEN_KEY",
valueColumnName = "GEN_VALUE",
pkColumnValue = "PERSONNE_ID",
allocationSize = 10)
@Id
@GeneratedValue(strategy = GenerationType.TABLE, generator =
"personneGen")
public long getId() {
return id;
}
public void setId(long id) {

[e-mail]
Page 4
this.id = id;
}
}
On remarque la présence d’annotations telles que @Entity, @ManyToOne ou @Id . C’est grâce à ces
annotations que JPA peut générer automatiquement une table dans une base de données ainsi que
le code JDBC pour y accéder : l’annotation @ManyToOne permet de traduire des associations entre
objets d’un diagramme de classes en relation entre table dans la base de données ; l’annotation @Id
est obligatoire et sert à définir quel champ de la classe sera mappé avec la clef primaire de la table.
Ici, on demande à JPA de générer automatiquement les valeurs pour les clefs primaires grâce à
l’annotation @TableGenerator mais c’est optionnel.
6. La couche Services (où est géré la persistance)
La couche Application accède à la couche Services via une interface en utilisant le pattern Data
Access Object (DAO) :
package services;
import business.Personne;
import business.Voiture;
public interface DAO {
public void createVoiture(Voiture voiture);
public void createPersonne(Personne personne);
public Personne retrievePersonne(String nom);
public Voiture retrieveVoiture(String numImmatriculation);
public Voiture retrieveVoiture(Personne personne);
public void updateVoiture(Voiture voiture);
public void updatePersonne(Personne personne);
public void removeVoiture(Voiture voiture);
public void removePersonne(Personne personne);
}
Ce pattern DAO est très utilisé dans les applications JEE en général. C’est dans l’implantation de cette
interface que toute la persistance est gérée. Voici un extrait de cette implantation :
package services;
public class DOAImpl implements DAO{
EntityManager em = MyEntityManagerFactory.getEntityManager();
// …
public void createVoiture(Voiture voiture) {
EntityTransaction tx = em.getTransaction();
tx.begin();
em.persist(voiture);
tx.commit();
}

[e-mail]
Page 5
public void removeVoiture(Voiture voiture) {
EntityTransaction tx = em.getTransaction();
tx.begin();
em.remove(voiture);
tx.commit();
}
public Personne retrievePersonne(String nom) {
List liste = em.createQuery( "SELECT p FROM Personne p WHERE
p.nom LIKE :nomPersonne" ).
setParameter( "nomPersonne", nom ).
getResultList();
if(liste.size() == 0){
return null;
}
return (Personne)liste.get(0);
}
}
Le code des méthodes createVoiture et removeVoiture ressemble à celui de l’introduction de
ce document. La partie la plus intéressante, est contenue dans la méthode retrievePersonne. On
y voit une requête qui est envoyée à la base de données :
"SELECT p FROM Personne p WHERE p.nom LIKE :nomPersonne"
De fait, JPA possède un langage proche du SQL pour extraire de la base de données un ensemble
d’objets.
7. JPA + Spring
Dans cette application, nous utilisons aussi Spring (bien que JPA puisse être utilisé sans Spring dans
une application Java Standard Edition ou dans une application à la norme EJB). Spring est utilisé pour
assembler les couches de l’application. Le fichier XML applicationContext.xml, conforme à la
syntaxe Spring, où est défini cet assemblage est reprit en partie ici :
<bean id="louerVoitureDialog"
class="presentation.LouerVoitureDialog">
<property name="location">
<ref bean="location"/>
</property>
</bean>
<bean id="location" class="application.LocationImpl">
<property name="dao">
<ref bean="dao"/>
</property>
</bean>
<bean id="dao" class="services.DOAImpl"/>
Nous y retrouvons les trois beans correspondant aux implantations des couches Présentation,
Application et Services respectivement.