Formation Java EE L'api JPA

Formation Java EE
L'api JPA
 TP n°1 : Mapping d'une classe simple avec une table

 TP n°2 : Héritage (Stratégie : JOINED)
 TP n°3 : Héritage (Stratégie : SINGLE_TABLE)
 TP n°4 : Héritage (Stratégie : TABLE_PER_CLASS)
Formation JPA : TPs 1 à 4 1

I. Objectif ............................................................................................................................................................ 3
II. Pré-requis ....................................................................................................................................................... 3
III. Développement de l'application ...................................................................................................................3
Etape 1 : Installation de la base de données MySQL 5.0................................................................................ 3
Etape 2 : Configuration de JPA/Hibernate ...................................................................................................16
Etape 3 : Configuration de Log4J ..................................................................................................................20
Etape 4 : Mapping d'une classe avec une table simple ................................................................................20
Etape 5 : Mapping d'une relation d'héritage avec la stratégie JOINED .......................................................25
Etape 6 : Mapping d'une relation d'héritage avec la stratégie SINGLE_TABLE ............................................31
Etape 7 : Mapping d'une relation d'héritage avec la stratégie TABLE_PER_CLASS .....................................33
Conclusion ........................................................................................................................................................39

I. Objectif
L'objectif de ce TP est de vous montrer comment utiliser JPA pour :
 Mapper une classe simple avec une table ;

 Mapper une relation d'héritage en utilisant la stratégie JOINED ;
 Mapper une relation d'héritage en utilisant la stratégie SINGLE_TABLE ;
 Mapper une relation d'héritage en utilisant la stratégie TABLE_PER_CLASS.
II. Pré-requis
Pour réaliser ce TP vous aurez besoin de :
 Java 1.5 ou plus ;

 Eclipse ;
 MySQL 5.0 (le serveur et le client) ;
 Log4j 1.2.13 ;
 Les librairies de Hibernate version 3.6.10 :
III. Développement de l'application
Etape 1 : Installation de la base de données MySQL 5.0

Tout d'abord, commencer par installer le serveur de base de données MySQL 5.0.
 Lancer l'exécutable se trouvant dans le dossier ../tools/MySQL 5.0/Setup.exe et suivez les étapes
suivantes :

Cliquer sur le bouton Next :
Cliquer sur Next :

Cliquer sur Install :

Cliquer sur Next :
Cliquer ensuite sur Finish :

Cliquer ensuite sur Next :
Cocher "Standard Configuration" puis cliquer sur Next :
Cliquer sur Next :

Entrer le mot de passe (par exemple root) et cliquer sur le bouton Next. Noter que l'administrateur par
défaut crée par MySQL est root.
Cliquer sur Execute.

Cliquer sur Finish.
 Installer l'administrateur. Pour ceci, cliquer sur l'exécutable se trouvant dans le dossier
Formation_Hibernate/tps/tools/MySQL 5.0/mysql-gui-tools-5.0-r17-win32 et suivez les étapes
suivantes :

Cliquer sur Next :
Cliquer sur Next :
Cliquer sur Next :

Cliquer sur Next :
Cliquer sur Install :

Cliquer sur Finish.
 Créer le schéma "formation". Pour ceci, lancer "MySQL Administrator"
Cliquer sur OK :

Cliquer sur Catalogs :

Cliquer à droite de la souris sur la zone encadrée ci-dessus :

Cliquer sur "Create New Schema" :
Entrer le nom de votre nouveau schéma (par exemple formation) et cliquer sur le bouton OK.

Le schéma formation est maintenant crée comme montre la figure ci-dessus.
Etape 2 : Configuration de JPA/Hibernate
 Créer la bibliothèque utilisateur JPA_HIBERNATE. Pour ceci, dans Eclipse, cliquer sur Window ==>
Preferences :

 Cliquer sur "User Librairies" ci-dessus :
 Cliquer sur New :

 Entrer le nom de la bibliothèque (JPA_HIBERNATE) et cliquer sur OK.
 Cliquer sur "Add External JARs ..." :

Ajouter les JARs puis cliquer sur le bouton OK.
De la même manière, créer la bibliothèque DIVERS et ajouter le driver de la base de données MySQL 5.0 et
le JAR de log4j :

Etape 3 : Configuration de Log4J
Le contenu du fichier log4j.properties est le suivant :
# Direct log messages to stdout

log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target=System.out
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L -%m%n
# Direct log messages to a log file

log4j.appender.file=org.apache.log4j.RollingFileAppender
log4j.appender.file.File=c:\\logs\\log.log
log4j.appender.file.MaxFileSize=10MB
log4j.appender.file.MaxBackupIndex=10
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} %5p %c{1}:%L -%m%n
# Root logger option

#log4j.rootLogger=INFO, file, stdout
# Hibernate logging options (INFO only shows startup messages)
#log4j.logger.org.hibernate=DEBUG
# Log JDBC bind parameter runtime arguments
#log4j.logger.org.hibernate.type=DEBUG
Etape 4 : Mapping d'une classe avec une table simple

Arborescence du projet :
 Créer le projet java TPJPA et créer l'arborescente suivante :
 remarquer les 03 package : dao, modele et test dans src ;

 remarquer le dossier META-INF dans src ;
 remarquer le fichier log4j.properties dans src.
Noter que la même arborescence sera respectée par les 04 projets.
Noter que le fichier persistence.xml, le fichier log4j.properties et la couche dao seront les mêmes
pour les 04 projets.
persistence.xml
Le contenu du fichier persistence.xml est :

<?xml version="1.0" encoding="UTF-8"?>
<persistence version="1.0"
xmlns="http://java.sun.com/xml/ns/persistence">
<persistence-unit name="unite1" transaction-type="RESOURCE_LOCAL">

<provider>org.hibernate.ejb.HibernatePersistence</provider>
<properties>

<property name="hibernate.archive.autodetection" value="class, hbm" />
<property name="hibernate.show_sql" value="true" />
<property name="hibernate.format_sql" value="true" />
<property name="use_sql_comments" value="true" />

<property name="hibernate.connection.driver_class" value="com.mysql.jdbc.Driver" />
<property name="hibernate.connection.url" value="jdbc:mysql://localhost:3306/formation" />
<property name="hibernate.connection.username" value="root" />
<property name="hibernate.connection.password" value="admin" />

<property name="hibernate.hbm2ddl.auto" value="update" />

<property name="hibernate.dialect" value="org.hibernate.dialect.MySQL5InnoDBDialect" />
</properties>
</persistence-unit>
</persistence>
 Configurer votre user/password. Dans ce fichier, username est root et password est admin.
 Configurer l'URL. Dans ce fichier, l'URL est jdbc:mysql://localhost:3306/formation
La couche dao : SessionBuilder, IDao et DaoImpl
Dans le package dao, créer la classe SessionBuilder, l'interface IDao et la classe DaoImpl :
package dao;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import org.apache.log4j.Logger;
public class SessionBuilder {
private static EntityManagerFactory sessionFactory = null;
private static final Logger log = Logger.getLogger("SessionBuilder");
private SessionBuilder() {
}
public static EntityManagerFactory getSessionFactory() {

if (sessionFactory == null) {
try {
// Create the SessionFactory
sessionFactory = Persistence.createEntityManagerFactory("unite1");
} catch (Exception e) {
System.err.println("sessionFactory error " + e);
log.error("SessionFactory creation failed", e);
}
}
log.info("Session Factory crée avec succés");
return sessionFactory;
}
public static EntityManager openSession() {

return getSessionFactory().createEntityManager();
}
}

Remarquer que le classe SessionBuilder respecte le Design Pattern Singleton. L'objectif du
singleton est que la classe sera instanciée une seule fois. Dans ce TP, la factory permettant de créer
la session sera instanciée une seule fois.
package dao;
import java.util.List;
import modele.Personne;
public interface IDao {

void add(Personne e);
List<Personne> getAllPersons();
}
package dao;
import javax.persistence.EntityManager;
import javax.persistence.EntityTransaction;
import org.apache.log4j.Logger;
public class DaoImpl implements IDao {

private EntityManager session;
private static final Logger log = Logger.getLogger("DaoImpl");
public void add(Personne personne) {

try {
log.info("ajout de la personne " + personne + " en cours ...");
session = SessionBuilder.openSession();
EntityTransaction tx = session.getTransaction();
tx.begin();
session.merge(personne);
tx.commit();
e.printStackTrace();
log.error("Erreur de l'ajout de la personne",e);
}
finally {
session.close();
}
log.info("personne " + personne + " ajouté avec succés.");
}
public List<Personne> getAllPersons() {

List<Personne> liste=null;
try {
session = SessionBuilder.openSession();
EntityTransaction tx = session.getTransaction();
tx.begin();
liste=(List<Personne>) session.createQuery("from Personne").getResultList();
tx.commit();
return liste;
e.printStackTrace();
}
finally {
session.close();
return liste;
}
}
}

Le modèle Personne.java :
package modele;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
@Entity
public class Personne {
@GeneratedValue
@Id
private int identifiant;
private String pseudo;
private String mail;
private String codePostal;
public Personne(String pseudo, String mail, String codePostal) {

super();
this.pseudo = pseudo;
this.mail = mail;
this.codePostal = codePostal;
}
@Override
public String toString() {
return "Personne [identifiant=" + identifiant + ", pseudo=" + pseudo
+ ", mail=" + mail + ", codePostal=" + codePostal + "]";
}
public Personne() {
super();
}
public int getIdentifiant() {

return identifiant;
}
public void setIdentifiant(int identifiant) {

this.identifiant = identifiant;
}
public String getPseudo() {

return pseudo;
}
public void setPseudo(String pseudo) {

}
public String getMail() {

return mail;
}
public void setMail(String mail) {

this.mail = mail;
}
public String getCodePostal() {

return codePostal;
}
public void setCodePostal(String codePostal) {

}
}

La classe Test.java (dans le package test) :
package test;
import dao.DaoImpl;
import dao.IDao;
public class Test {

private static IDao dao = new DaoImpl();
private static void add(String pseudo, String mail, String codePostal) {

dao.add(new Personne(pseudo, mail, codePostal));
}
private static void display() {

List<Personne> liste = dao.getAllPersons();
for (Personne personne : liste) {
System.out.println(personne);
}
}
public static void main(String[] args) {

add("user01", "user01@gmail.com", "10000");
display();
}
}
Vérifier que la table suivante est créée :

Vérifier que les 04 personnes ont été ajoutées :
Etape 5 : Mapping d'une relation d'héritage avec la stratégie JOINED
 Créer le projet tpjpaHeritage(JOINED)

 La couche dao est la même que le projet tpjpa
 Le fichier persistence.xml, le fichier log4j.properties est le même que le projet tpjpa.
Les 03 classes du modèle :
Personne
Etudiant Professeur
La classe Personne.java :
package modele;
import javax.persistence.Inheritance;
import javax.persistence.InheritanceType;
@Entity
@Inheritance(strategy = InheritanceType.JOINED)
@GeneratedValue
@Id
super();
this.mail = mail;
}


@Override
return "Personne [identifiant=" + identifiant + ", pseudo=" + pseudo
+ ", mail=" + mail + ", codePostal=" + codePostal + "]";
}
public Personne() {
super();
}

return identifiant;
}

}

return pseudo;
}

}

return mail;
}

this.mail = mail;
}

return codePostal;
}

}
}
La classe Professeur.java :
package modele;
import javax.persistence.PrimaryKeyJoinColumn;
@Entity
@PrimaryKeyJoinColumn(name="id")
public class Professeur extends Personne {
private String diplome;
public Professeur(String pseudo, String mail, String codePostal,

String diplome) {
super(pseudo, mail, codePostal);
this.diplome = diplome;
}
@Override
return "Professeur : " + diplome + " " + getIdentifiant() + " "
+ getPseudo();
}
public Professeur() {
super();
}

public String getDiplome() {
return diplome;
}
public void setDiplome(String diplome) {

}
}
La classe Etudiant.java :
package modele;
import java.util.Date;
import javax.persistence.PrimaryKeyJoinColumn;
@Entity
@PrimaryKeyJoinColumn(name="id")
public class Etudiant extends Personne {
private Date dateInscription;
public Etudiant(String pseudo, String mail, String codePostal,

Date dateInscription) {
this.dateInscription = dateInscription;
}

return "Etudiant : " + dateInscription.toString() + " "
+ getIdentifiant() + " " + getPseudo();
}
public Date getDateInscription() {

return dateInscription;
}
public Etudiant() {
super();
}
public void setDateInscription(Date dateInscription) {

}
}
La classe Test.java :
package test;
import modele.Etudiant;
import modele.Professeur;
import dao.DaoImpl;
import dao.IDao;
public class Test {

private static void addPersonne(String pseudo, String mail, String codePostal) {

dao.add(new Personne(pseudo, mail, codePostal));
}
private static void addProfesseur(String pseudo, String mail, String codePostal,String diplome) {
dao.add(new Professeur(pseudo,mail,codePostal,diplome));

}
private static void addEtudiant(String pseudo, String mail, String codePostal,Date dateInscription)
{
dao.add(new Etudiant(pseudo,mail,codePostal,dateInscription));
}

}
}

addPersonne("user01", "user01@gmail.com", "10000");
addProfesseur("user05", "user05@gmail.com", "50000","INGENIEUR D'ETAT");

addProfesseur("user06", "user06@gmail.com", "60000","DOCTEUR D'ETAT");
addProfesseur("user07", "user07@gmail.com", "70000","phd");
addProfesseur("user08", "user08@gmail.com", "80000","INGENIEUR D'ETAT");
addEtudiant("user09", "user09@gmail.com", "90000",new Date());

display();
}
}
 Vérifier que les 03 tables suivantes ont été crées :

Noter que id est une clé étrangère référençant la colonne id de la table PERSONNE.
Noter que id est une clé étrangère référençant la colonne id de la table PERSONNE.
Vérifier les lignes ajoutées au niveau des trois tables :

Etape 6 : Mapping d'une relation d'héritage avec la stratégie SINGLE_TABLE
 Créer le projet tpjpaHeritage(SIGLE_TABLE)
 La classe Test est la même que celle du projet tpjpaHeritage(JOINED).

La classe Personne :
package modele;
import javax.persistence.DiscriminatorColumn;
import javax.persistence.DiscriminatorValue;
@Entity
@Inheritance(strategy=InheritanceType.SINGLE_TABLE)
@DiscriminatorColumn(name="descriminateur")
@DiscriminatorValue(value="p")
@Id
@GeneratedValue
@Override
return "Personne" + identifiant + " " + pseudo;
}
public Personne() {
super();
// TODO Auto-generated constructor stub
}
super();
this.mail = mail;
}
return identifiant;
}
}
return pseudo;
}
}
return mail;
}
this.mail = mail;
}
return codePostal;
}
}
}

La classe Etudiant :
package modele;
@Entity
@DiscriminatorValue("etud")
public class Etudiant extends Personne{
public Etudiant(String pseudo, String mail, String codePostal,

}
@Override
return "Etudiant : " + dateInscription.toString() + " " + getIdentifiant() + " " +
getPseudo();
}
}
public Etudiant() {
super();
}

}
La classe Professeur :
package modele;
@Entity
@DiscriminatorValue("prof")
public class Professeur extends Personne{
@Override
return "Professeur : " + diplome + " " + getIdentifiant() + " " + getPseudo();
}
public Professeur(String pseudo, String mail, String codePostal,
String diplome) {
}
super();
}
return diplome;
}
}
}

La classe Test :
 Vérifier que le l'exécution de la méthode main donne le résultat suivant :
 La table PERSONNE suivante est créée :
 Les lignes suivantes seront crées au niveau de la table PERSONNE :
Etape 7 : Mapping d'une relation d'héritage avec la stratégie TABLE_PER_CLASS

 Créer le projet tpjpaHeritage(TABLE_PER_CLASS)

La classe Personne :

package modele;
@Entity
@Inheritance(strategy=InheritanceType.TABLE_PER_CLASS)
@Id
public Personne(int identifiant,String pseudo, String mail, String codePostal) {
super();
this.mail = mail;
}
@Override
return "Personne" + identifiant + " " + pseudo;
}
public Personne() {
super();
}
return identifiant;
}
}
return pseudo;
}
}
return mail;
}
this.mail = mail;
}
return codePostal;
}
}
}
La classe Etudiant :
package modele;
@Entity
public class Etudiant extends Personne{
@Override
return "Etudiant : " + dateInscription.toString() + " " + getIdentifiant() + " " +
getPseudo();

}
public Etudiant(int identifiant,String pseudo, String mail, String codePostal,
super(identifiant,pseudo, mail, codePostal);
}
}
public Etudiant() {
super();
}

}
La classe Professeur :
package modele;
@Entity
public class Professeur extends Personne{
@Override
return "Professeur : " + diplome + " " + getIdentifiant() + " " + getPseudo();
}
public Professeur(int identifiant,String pseudo, String mail, String codePostal,
String diplome) {
super(identifiant,pseudo, mail, codePostal);
}
super();
}
return diplome;
}
}
}
La classe Test :
package test;
import modele.Etudiant;
import modele.Professeur;
import dao.DaoImpl;
import dao.IDao;

public class Test {
private static void addPersonne(int identifiant,String pseudo, String mail, String

codePostal) {
dao.add(new Personne(identifiant,pseudo, mail, codePostal));
}
private static void addProfesseur(int identifiant,String pseudo, String mail, String

codePostal,String diplome) {
dao.add(new Professeur(identifiant,pseudo,mail,codePostal,diplome));
}
private static void addEtudiant(int identifiant,String pseudo, String mail, String

codePostal,Date dateInscription) {
dao.add(new Etudiant(identifiant,pseudo,mail,codePostal,dateInscription));
}

}
}

addPersonne(1,"user01", "user01@gmail.com", "10000");
addProfesseur(5,"user05", "user05@gmail.com", "50000","INGENIEUR D'ETAT");

addProfesseur(6,"user06", "user06@gmail.com", "60000","DOCTEUR D'ETAT");
addProfesseur(7,"user07", "user07@gmail.com", "70000","phd");
addProfesseur(8,"user08", "user08@gmail.com", "80000","INGENIEUR D'ETAT");
addEtudiant(9,"user09", "user09@gmail.com", "90000",new Date());

display();
}
}
 Vérifier que le l'exécution de la méthode main donne le résultat suivant :

 Les trois tables PERSONNE,ETUDIANT et PROFESSEUR suivantes seront crées :

 Les lignes suivantes seront insérées au niveau des trois tables:

Conclusion
La meilleure stratégie a priori est JOINED : c’est la seule implémentation de l’héritage au sens strict,
tant en Java que dans le modèle de données. Elle implique néanmoins systématiquement des jointures
en lecture, et potentiellement plusieurs requêtes en écritures. Les requêtes de recherche peuvent vite
devenir lourdes.
La stratégie SINGLE_TABLE est une alternative très honnête : les performances en lecture et écriture
sont très bonnes. En revanche, on a potentiellement un grand nombre de colonnes et beaucoup de
valeurs NULL.
Le mode TABLE_PER_CLASS est un peu le parent pauvre de ce comparatif avec ses allures d’usine à
gaz. Il est vrai que l’on perd tout-à-fait l’intérêt de l’héritage dans l’approche base de données (ce qui
n’est pas le cas du point de vue Java). On a potentiellement beaucoup de données dupliquées, ce qui
signifie qu’une modification sur une des tables impliquées risque de devoir être répercutée sur une ou
plusieurs autre(s) table(s). Il propose toutefois des performances correctes en lecture et en écriture
(même s’il faut gérer « à la main » la cohérence des données entre la super-classe et les sous-
classes).

Formation Java EE L'api JPA

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Formation Java EE L'api JPA

Transféré par

Droits d'auteur :

Formats disponibles

Formation Java EE

 TP n°1 : Mapping d'une classe simple avec une table

Formation JPA : TPs 1 à 4 1

Formation JPA : TPs 1 à 4 2

 Mapper une classe simple avec une table ;

 Java 1.5 ou plus ;

III. Développement de l'application

Etape 1 : Installation de la base de données MySQL 5.0

Formation JPA : TPs 1 à 4 3

Cliquer sur Next :

Formation JPA : TPs 1 à 4 4

Formation JPA : TPs 1 à 4 5

Cliquer ensuite sur Finish :

Formation JPA : TPs 1 à 4 6

Cocher "Standard Configuration" puis cliquer sur Next :

Cliquer sur Next :

Formation JPA : TPs 1 à 4 7

Cliquer sur Execute.

Formation JPA : TPs 1 à 4 8

Formation JPA : TPs 1 à 4 9

Cliquer sur Next :

Cliquer sur Next :

Formation JPA : TPs 1 à 4 10

Cliquer sur Install :

Formation JPA : TPs 1 à 4 11

 Créer le schéma "formation". Pour ceci, lancer "MySQL Administrator"

Formation JPA : TPs 1 à 4 12

Formation JPA : TPs 1 à 4 13

Formation JPA : TPs 1 à 4 14

Formation JPA : TPs 1 à 4 15

Etape 2 : Configuration de JPA/Hibernate

Formation JPA : TPs 1 à 4 16

 Cliquer sur New :

Formation JPA : TPs 1 à 4 17

 Cliquer sur "Add External JARs ..." :

Formation JPA : TPs 1 à 4 18

Formation JPA : TPs 1 à 4 19

Le contenu du fichier log4j.properties est le suivant :

# Direct log messages to stdout

# Direct log messages to a log file

# Root logger option

Etape 4 : Mapping d'une classe avec une table simple

 Créer le projet java TPJPA et créer l'arborescente suivante :

 remarquer les 03 package : dao, modele et test dans src ;

Le contenu du fichier persistence.xml est :

Formation JPA : TPs 1 à 4 20

La couche dao : SessionBuilder, IDao et DaoImpl

public class SessionBuilder {

private static EntityManagerFactory sessionFactory = null;

private static final Logger log = Logger.getLogger("SessionBuilder");

public static EntityManagerFactory getSessionFactory() {

public static EntityManager openSession() {

Formation JPA : TPs 1 à 4 21

public interface IDao {

public class DaoImpl implements IDao {

public void add(Personne personne) {

public List<Personne> getAllPersons() {

Formation JPA : TPs 1 à 4 22

public Personne(String pseudo, String mail, String codePostal) {

public int getIdentifiant() {

public void setIdentifiant(int identifiant) {

public String getPseudo() {

public void setPseudo(String pseudo) {