Coursjpa TP

LA SPÉCIFICATION JPA
2019-2020 ESPRIT thouraya.louati@esprit.tn UP JavaEE / .NET (Bureau E204)

Séance 2
2
 Séquence 5: La spécification JPA

Charge : 3 heures
 Rappel DAO/JDBC
 Présentation des ORM et mapping Objet relationnel
 Présentation de la spécification JPA
 Configuration du driver JDBC et de la Datasource
 Le fichier persistence.xml
 Première entité ( Présentation de toutes les annotations
possibles pour une entité JPA).
Persistance
3
 Le Modèle Relationnel : les systèmes de gestion de bases de données

relationnels (SGBDR) sont devenus un pilier incontournable dans le
développement d’applications.
 Le Modèle Object : se base sur la programmation orientée objet.
Celle-ci permet aux applications d’atteindre un excellent niveau de
qualité et de flexibilité.
 Comment stocker les objets modélisés de la mémoire vers les SGBDR ?
On parle ainsi de persistance d’objets métiers.

Persistance
4
 Représentation d'une donnée, manipulée par l'application,

typiquement stockée dans un SGBD.
 La Persistance signifie que l’état du Entity existe (persiste) même
après la durée de l’exploitation de l’application (session).
Session Bean Entity

Gestion de compte Compte bancaire
Vérificateur de CB Carte de crédit
Système d'entrée gestion de commandes Commande, ligne de commande
Gestion de catalogue Produits
Gestionnaire d'enchères Enchère, Produit
Gestion d'achats Commande, Produit, ligne de commande
Persistance
5
 Pour persister les données :

Développer manuellement le code de projection des objets sur
le support relationnel (utilisation de JDBC natif).
OU
Utiliser un Framework de projection objet-relationnel:
EclipseLink, Hibernate… Ces Frameworks implémentent la
spécification JavaEE JPA.
Rappel JDBC/ DAO (Data Access Object)
6
 JDBC (Java DataBase Connectivity) est une API (Application

Programming Interface) pour les programmes utilisant la plateforme
Java créée par Sun Microsystems (rachetée par Oracle Corporation).
 Elle permet aux applications Java d'accéder à des bases de données,
en utilisant des pilotes JDBC (Drivers).
 Des pilotes JDBC sont disponibles pour tous les systèmes connus de
bases de données relationnelles.
Exemple: User
7
public class User {

private int id;
private String login;
private String password;
private String nom;
private String prenom;
private String email;
private String role;
public User() {}
public User(int id, String login, String password, String nom, String prenom, String
email, String role) {
this.id = id;
this.login = login;
this.password = password;
this.nom = nom;
this.prenom = prenom;
this.email = email;
this.role = role;
}
//Getters and Setters
public String toString() {
return "User [id=" + id + ", login=" + login + ", password=" + password + ", nom=" +
nom + ", prenom=" + prenom
+ ", email=" + email + ", role=" + role + "]"; } }
Exemple: Interface DAO
8
public interface IUserDAO {
// Ajout User :
public void addUser(User user);
// Suppression User :
public void removeUser(User user);
// Mise à jour User :

public void modifyUser(User user);
// Récupération User :
public User getUserById(int id);
// Récupération List of Users :

public ArrayList<User> getAllUsers();
}
Exemple: User
9
public class UserDAOImpl implements IUserDAO {

public final static String DB_URL = "jdbc:mysql://localhost/formation";
public final static String USER = "root";
public static final String PASSWORD = "";
public void addUser(User user) {
Connection conn = null;
PreparedStatement preparedStmt = null;
try {
conn = DriverManager.getConnection(DB_URL,USER,PASSWORD);
String insertSQL = "INSERT INTO USER "
+ " (ID, LOGIN, PASSWORD, NOM, PRENOM, EMAIL, ROLE) "
+ " VALUES "
+ " (?, ?, ?, ?, ?, ?, ?) ";
preparedStmt = conn.prepareStatement(insertSQL);
preparedStmt.setInt(1, user.getId());
preparedStmt.setString(2, user.getLogin());
preparedStmt.setString(3, user.getPassword());
preparedStmt.setString(4, user.getNom());
preparedStmt.setString(5, user.getPrenom());
preparedStmt.setString(6, user.getEmail());
preparedStmt.setString(7, user.getRole());
preparedStmt.execute(); }}
public void removeUser(User user) {}
public void modifyUser(User user) {}
Exemple: User
10
public class UserService {
public static void main(String[] args) {
UserDAOImpl userDAOImpl = new UserDAOImpl();
User user = new User("JPH", "pwd", "JPH", "Jean-Philippe", "test@mail.com",

"Team");
userDAOImpl.addUser(user);
User user2 = new User(4, "", "", "", "", "", "");
userDAOImpl.removeUser(user2);
}
}
Télécharger les codes sources de cet exemple à partir de cet URL:

https://tinyurl.com/yblrrnxe et tester l’exemple.
Rappel JDBC/ DAO (Data Access Object)
11
 L’utilisation de l’API JDBC était une solution pour les

développeurs java pour unifier l’accès à une base de données
SQL. (manipuler les données dans une base de donnée SQL (CRUD: Create-Read-Update-
Delete))
 Inconvénients :
Pas de séparation entre le code technique et le code métier.
Utilisation du langage SQL rend la couche d’accès aux
données difficilement maintenable.
ORM
12
 L'ORM (Object-Relational Mapping) est un concept faisant le lien

entre le monde de la base de données et le monde de la
programmation orientée objet.
 C’est une technique de programmation qui permet d’associer une
ou plusieurs classes avec une table, et chaque attribut de la
classe avec un champ de la table.
 Technique de programmation
ORM:
• Opérations SQL courantes
• Vision homogène
• Haut niveau
• Transfert automatique des données.
• Évite les inconvénients liés à l’utilisation de l’API JDBC nativement
( réduire la quantité du code).
ORM
13
Sans
ORM
Avec
ORM
13
Introduction JPA
14
 Java Persistance API (abrégée en JPA) est une interface de

programmation Java permettant de normaliser l’utilisation et
la communication avec la couche de données, d’une application
Java, la gestion des données relationnelles, manipulation des
données et de leurs relations.
 C’est une spécification Java EE basée sur le concept ORM
(Object Relational mapping). Spécification Java (version 2.1, JSR 338, mai 2013)
 L'utilisation de JPA nécessite un fournisseur de persistance
(ORM) qui implémente les spécifications JPA.
14
Introduction JPA
15
 Il y a plusieurs fournisseurs de persistance (différentes mises en

œuvre) qui implémentent la spécification JPA, tel que,
Hibernate, Toplink, datanucleus, Toplink, EclipseLink, Apache
OpenJPA, etc.
 Dans ce cours nous allons utiliser Hibernate comme
implémentation de la spécification JPA.
15
Vocabulaire JPA
16
 Persistance/persister:
Action de sauvegarder des données dans une base de données (SGBD).
Correspondance objet – relationnel (mapping Objet/Relationel)
 Les attributs d'un objet sont enregistrés sur un support persistant
 Entité: Un ensemble de données d’un même type (e.g: Personne)

 Deux approches
Création du modèle de données depuis JPA.
Schéma et Données existantes dans un SGBD.
 Principes de mise en correspondance (langage JPQL)
Une classe Java  Une table SQL
16
Une propriété d’une classe Une colonne dans une table SQL
Une référence entre classes  une relation entre tables SQL
Un objet  un enregistrement dans une table SQL
Exemple
17
Hibernate
18
 Hibernate est un Framework open source gérant la

persistance des objets en base de données relationnelle.
Il gère le Mapping entre les objets de l’application et la
base de données.
C’est un projet maintenu par l’entreprise JBoss, appartenant
à RedHat.
L’utilisation de JPA / HIBERNATE nous permet de gagner du
temps en développement :
 Génération automatiquement du CRUD.
 Génération automatique des tables à partir des entités Java.
La sérialisation - désérialisation
19
 Le mécanisme de sérialisation consiste à convertir un objet en

une suite de bits.
 Nous pouvons ainsi sérialiser les objets sur disque, sur une
connexion réseau (notamment Internet), sous un format
indépendant des systèmes d'exploitation.
 Java fournit un mécanisme simple, transparent et standard de
sérialisation des objets via l'implémentation de l'interface
java.io.Serializable.
19
La mise en œuvre
Les entités JPA - Développement
21
 Une entité JPA est une classe JAVA qui doit satisfaire les
conditions suivantes :
Être déclarée avec l'annotation @Entity.
 chaque Entity est mise en correspondance avec une table.
 par défaut une table avec le même nom que la classe
 sauf si on utilise l’annotation @Table(name="...")
Posséder au moins une propriété déclarée comme identité de
l’entité avec l'annotation @Id (clé primaire).
Implémenter l’interface java.io.Serializable.
21
Tous les attributs doivent être « private » ou « protected »et
avoir obligatoirement des accesseurs et des mutateurs (les
méthodes getters et setters).
22
24
Exemple 1:
24
Exemple 2:
package tn.esprit.entity;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue; import
javax.persistence.Id;
import javax.persistence.Table;
@Entity
@Table( name = "T_EMPLOYEE")
public class Employee implements Serializable {
@Id
@GeneratedValue (strategy = GenerationType.IDENTITY)
@Column(name="EMPL_ID")
private int id; // Clé primaire
@Column(name="EMPL_NAME")
private String name;
// Constructeur et accesseurs (getters) et mutateurs

(setters)
}
25
Exemple 3:
@Entity
public class Personne implements Serializable {
private String nom;

private int age;
public Personne( String nom, int age ) {

this.nom = nom;
this.age = age;
}
public String getNom() { return nom; }

public void setNom( String nom ) { this.nom = nom;
}
public int getAge() { return age; }
public void setAge( int age ) { this.age = age; }
}
26
Exemple 4:
@Id : clé primaire

@Entity
public class Personne implements Serializable {
private long id;
private String nom;
private int age;
this.nom = nom;
this.age = age;
}
@Id
@GeneratedValue
public long getId() { return id; }
public void setId( long id ) { this.id = id; }
// méthodes getNom, setNom, getAge, setAge
}
Les entités JPA: Annotation
27
 Pour donner à la table un autre nom que le nom de la classe, il

faut ajouter une annotation @Table.
 Pour donner à une colonne de la table un autre nom que le nom

de l’attribut correspondant, il faut ajouter une annotation
@Column.
27
Les entités JPA: Annotation
28
 Exemple 2:
Correspondance attributs et colonnes.
Annotation @Table et @Column.
@Entity @Entity
@Table(name="ECRIVAINS") @Table(name="LIVRES")
public class Auteur { public class Ouvrage {
@Column("NOM_ID") @COLUMN("TITRE_ID")
String nom; String titre;
List<Ouvrage> oeuvres; Auteur auteur;
// constructeur // constructeur
// getter/setter nom // getter/setter titre 28
// getter/setter oeuvres // getter/setter auteur
} }
Stratégies d’auto génération des IDs
29
 @GeneratedValue Définit la manière dont la base gère la

génération de la clé primaire. L’attribut "strategy" obligatoire
pouvant avoir comme valeur : AUTO/IDENTITY/SEQUENCE/
TABLE :
@Id
29
30
 Si l’ID est de type String, int, byte, char, double, float, long ou
short, l’insertion de l’id peut se faire automatiquement par l’une
des stratégies suivantes :
strategy = GenerationType.AUTO: la génération de la clé primaire est
garantie par le fournisseur de persistance (hibernate), une séquence unique de clé
primaire pour tout le schéma de base de données défini dans une table
hibernate_sequence.
strategy = GenerationType.TABLE: la génération des clés primaires est
garantie par le fournisseur de persistance (hibernate), une séquence de clés primaires
par table définie dans une table hibernate_sequences, cette table contient deux
colonnes : une pour le nom de la séquence et l’autre pour la prochaine valeur.
strategy = GenerationType.IDENTITY: La génération de la clé primaire se fait
à partir d’une identité propre au SGBD. Il utilise un type de colonne spéciale à la base
30
de données.
Exemple pour MySQL, il s’agit d’un AUTO_INCREMENT. Avec PostgreSQL ou Oracle,
c’est une séquence.
31
strategy = GenerationType.SEQUENCE: la génération de la clé primaire est

garantie par le fournisseur de persistance (hibernate), une séquence de clé primaire
pour un schéma de base de données défini dans une table hibernate_sequence. (=
GenerationType.AUTO), mais c’est nous définissions les détails de la
séquence).
31
32
@Id : clé primaire

@GeneratedValue: générer automatiquement la clé
@Entity
public class Personne {
private long id;
private String nom;
private int age;
this.nom = nom;
this.age = age; }
@Id
@GeneratedValue
public long getId() { return id; }
public void setId( long id ) { this.id = id; }
// méthodes getNom, setNom, getAge, setAge}
32
33
 Exemple:
1-
@Id
@Id
 Comment le champ EMPL_ID de la table T_EMLPYEE sera

33
alimenté dans chacun des deux cas?
2- Exécuter la requête SQL : show table status;
Basic Types
34
 Java primitive types (boolean, int, etc)

 wrappers for the primitive types (java.lang.Boolean, java.lang.Integer,etc)
 java.lang.String
 java.math.BigInteger
 java.math.BigDecimal
 java.util.Date
 java.util.Calendar
 java.sql.Date
 java.sql.Time
 java.sql.Timestamp
 byte[] or Byte[]
 char[] or Character[]
34
 enums
https://docs.jboss.org/hibernate/orm/5.2/userguide/html_single/Hibernate_User_Guide.html#basic
Les dates
35
 Lorsqu'une entité JPA a un attribut de type temporel (Calendar

ou Date de java.util), il est obligatoire d'indiquer de quel type
temporel est cet attribut par une annotation @Temporal.
TemporalType.DATE: la date va être sauvegardée dans la base de
données sous forme d’une date (jour, mois, année)
TemporalType.TIMESTAMP: la date va être sauvegardée dans la base
de données sous forme d’une date (jour, mois, année) + heure à la
microseconde.
TemporalType.TIME: Un temps sur 24 heures (heures, minutes, secondes à
la milliseconde près)
35
Les énumérations
36
@Enumerated :
 EnumType.String: Si la valeur de l’attribut va être stockée dans la base de
données sous forme de String qui représente la valeur de l’énumération.
 EnumType.Ordinal: Si la valeur de l’attribut va être stockée dans la base
de données sous forme d’un Integer qui représente la valeur de
l’énumération.
36
Classe Embeddable
37
@Embeddable :
 Il existe aussi des classes « insérées » ou « incorporées » (embedded)
dont les données n’ont pas d’identité dans la BD mais sont insérées
dans une des tables associées à une entité persistante.
Clé composite
38
 Pas recommandé, mais une clé primaire peut être composée de

plusieurs colonnes.
Peut arriver quand la BD existe, déjà, ou quand la classe correspond à
une table association (association M:N avec information).
2 possiblités:
 @IdClass
 @EmbeddedId et @Embeddable
 Dans les 2 cas, la clé primaire doit être représentée par une
classe Java dont les attributs correspondent aux composants de
la clé primaire.
38
 La classe doit être public, posséder un constructeur sans
paramètre, être sérialisable et redéfinir equals et hashcode.
Clé composite avec @IdClass
39
 @IdClass correspond au cas où la classe entité comprend

plusieurs attributs annotés par @Id
La classe entité est annotée par @IdClass qui prend en paramètre le
nom de la classe clé primaire.
 La classe clé primaire n’est pas annotée (comme
@Embeddable) ; ses attributs ont les mêmes noms et mêmes
types que les attributs annotés @Id dans la classe entité.
39
Clé composite avec @EmbeddedId
40
 @EmbeddedId correspond au cas où la classe entité comprend

un seul attribut annoté @EmbeddedId
 La classe clé primaire est annotée par @Embeddable
40
Héritage
41
 Pour représenter un modèle hiérarchique dans un modèle

relationnel, JPA propose alors trois stratégies possibles :
Une seule table unique pour l'ensemble de la hiérarchie des classes.
L'ensemble des attributs de toute la hiérarchie des entités est mis à plat
et regroupé dans une seule table (il s'agit d'ailleurs de la stratégie par
défaut).
Une table pour chaque classe concrète. Chaque entité concrète de la
hiérarchie est associée à une table.
Jointure entre sous-classes. Dans cette approche, chaque entité de la
hiérarchie, concrète ou abstraite, est associée à sa propre table. Ainsi,
nous obtenons dans ce cas là une séparation des attributs spécifiques de
la classe fille par rapport à ceux de la classe parente. Il existe alors, une
table pour chaque classe fille, plus une table pour la classe parente. Une
jonction est alors nécessaire pour instancier la classe fille.
Héritage single Table (par défaut)
42
 La colonne Discriminator est gérée par JPA, certes une

configuration personnalisée est permise pour le nom de la
colonne discriminateur et la valeur de discrimination.
persistence.xml
43
 Le fichier persistence.xml doit être stocké dans

le répertoire META-INF
 Il contient un ou plusieurs tags <persistence-
unit>
 Il contient les informations sur la connexion à la
43
base de données à utiliser.
En résumé
44
Java Persistence API

 Interface de programmation pour la gestion de données
relationnelles.
 Manipulation des données d’un SGBD comme des objets.
 Sauvegarde des informations transparentes.
 Abstraction de SQL.
 Différentes implémentations.
TP1: Création de la premiere entité
45
 Lancer MySQL server.

 Créer une base de donnés qui s’appelle “imputation”.
Créer la base de données à utiliser : create database imputation;
Taper : show databases;
Taper : use imputation;
Taper : show tables;
45
46
 Vous aurez:
Enter password:
Welcome to the MySQL monitor. Commands end with ; or \g.
Your MySQL connection id is 31
Server version: 5.6.17 MySQL Community Server (GPL)
mysql> create database imputation;
Query OK, 1 row affected (0.02 sec)
mysql> show databases;
+--------------------+
| Database |
+--------------------+
| imputation |
mysql> use imputation;
Database changed
mysql> show tables;
Empty set (0.00 sec)
47
 Création d’une DataSource

 Une datasource est une structure de données utilisée pour décrire une
connexion (URL, Driver, UserName, …) à une source de donnée (base de
données).
 Exemple:
<datasource jta="true" jndi-name="java:/ImputationDS" pool-
name="ImputationDS" enabled="true" use-ccm="true">
<connection-url>jdbc:mysql://localhost:3306/imputation</connection-url>
<driver-class>com.mysql.jdbc.Driver</driver-class>
<driver>mysql</driver>
<security>
<user-name>root</user-name>
</security>
</datasource>
Comment créer une DataSource ?

48
 Aller dans le fichier standalone.xml (de WildFly), et vérifier si vous avez une
DataSource qui permet de vous connecter à votre base de données
« imputation » ?
 Nous allons créer cette DataSource. Il y a deux façons :
 Méthode 1 : Modifier directement el fichier standalone.xml (risque d’erreur, à
ne pas faire).
 Méthode 2 (conseillée) : Utiliser l’interface d’administration de WildFly. Voici la
démarche :
 Démarrer votre WildFly (Plugin Server sur Eclipse), dans les logs vous trouverez
l’URL de la console d’administration :
WFLYSRV0051: Admin console listening on http://127.0.0.1:10990
 Ouvrir la console d’administration : http://127.0.0.1:10990 (login admin / mot
de passe adminwidfly)
 (Les captures d’écran sont sur les slides suivants:) Configuration -> Subsystems -
> Datasources -> View -> Add -> MySQL Datasource -> Name : ImputationDS
JNDI Name java:/ImputationDS -> Detected Driver -> mysql ->
jdbc:mysql://localhost:3306/imputation (ajouter login et password) -> Test
49
50
52
53
54
55
 Cliquer «Test connection».

55
 Cliquer «Test connection».

56
Revérifier standalone.xml :
57
 Nous allons utiliser un archétype de projet déjà prêt.

 Ajouter l’URL du catalogue de projets à votre Eclipse (Voir
slide suivant) :
 http://repo.maven.apache.org/maven2/archetype-
catalog.xml
 Assurez-vous d’avoir Internet
 Window– Preferences – Maven – Archetypes – Add Remote
Catalog
 Entrez l’URL ci-dessus et un nom de ce dépôt d’archetypes)
 Cliquer sur Verify pour vous assurer que Eclipse a téléchargé
les archetypes
 Cliquer sur Enable All pour activer l’utilisation de ce dépôt.
58
58
http://repo.maven.apache.org/maven2/archetype-catalog.xml
<archetype>
<groupId>org.wildfly.archetype</groupId>
<artifactId>wildfly-javaee7-webapp-ear-blank-archetype</artifactId>
<version>8.2.0.Final</version>
<description>An archetype that generates a starter Java EE 7 webapp project for
JBoss Wildfly. The project is an EAR, with an EJB-JAR and WAR</description>
</archetype>
59
 Créer un nouveau projet de type Maven, et NE cochez PAS la

case « skip archetype » , car justement nous allons utiliser un
template de projet.
 Choisissez le template : wildfly-javaee7-webapp-ear-blank-

archetype
61
62
63
 Modifier les entrées suivantes dan le pom.xml su Projet parent :

<version.wildfly>11.0.0.Final</version.wildfly>
………………….
<maven.compiler.target>1.8</maven.compiler.target>
<maven.compiler.source>1.8</maven.compiler.source>
 Faire un bouton droit sur le projet parent et faire un Maven ->

Update Project
 Dans le pom du projet web, ajouter la dépendance suivante :
<dependency>
<groupId>javax</groupId>
<artifactId>javaee-api</artifactId>
<version>7.0</version>
</dependency>
64
 Dans cette partie, on va travailler que sur le projet EJB :

Aller au projet EJB et mettez à jour le fichier persistence.xml
sous <src/main/resources/META-INF> pour pointer vers
votre DataSource : https://www.dropbox.com/s/tuyqki9wc90jdq7/persistence.xml?dl=0
<?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="imputation-ejb">
<jta-data-source>java:/MySqlDSJEE</jta-data-source>
<properties>
<property name="hibernate.hbm2ddl.auto" value="update" />
<property name="hibernate.show_sql" value="true" />
<property name="hibernate.format_sql" value="true" />
<property name="hibernate.dialect" value="org.hibernate.dialect.MySQL5InnoDBDialect" />
</properties>
</persistence-unit>
</persistence>
65
 Dans le projet EJB Créer un package

tn.esprit.imputation.entity sous <src/main/java>
 Créer l’entité utilisateur avec les attributs nom, prenom et
adresse email
 N’oublier pas de mettre les annotations nécessaires.
 Donner des noms personnalisés à la table et aux colonnes
(différents des noms par défaut)
 Voici le résultat final souhaité :
66
67
 Déployer le projet sur WildFly et voir les logs

21:00:59,914 INFO [java.sql.DatabaseMetaData] (ServerService
Thread Pool -- 66) HHH000262: Table not found: T_UTILISATEUR
21:00:59,945 INFO [org.hibernate.tool.hbm2ddl.SchemaUpdate]
(ServerService Thread Pool -- 66) HHH000232: Schema update
complete
 Vérifier dans la base de données :
show tables;
describe t_utilisateur;
 Si vous voulez recommencer le test de création, supprimer la table
avec : drop table t_utilisateur;
68
@Entity
@Table(name="T_UTILISATEUR")
public class Utilisateur implements Serializable {
@Id
@GeneratedValue( strategy = GenerationType.IDENTITY )
@Column(name="UT_ID")
int id;
@Column(name="UT_NOM")
String nom;
@Column(name="UT_PRENOM")
String prenom;
@Column(name="UT_ADRESS_MAIL")
String adresseMail;
public Utilisateur() {}
public String getNom() {return nom;}
public void setNom(String nom) {this.nom = nom;}
public String getPrenom() {return prenom;}
public void setPrenom(String prenom) {this.prenom = prenom;}
public String getAdresseMail() {return adresseMail;}
public void setAdresseMail(String adresseMail) {this.adresseMail = adresseMail;}
}
69
 Créer d’autres entités en variant les stratégies de génération des

clés et analyser les résultats:
@GeneratedValue (strategy = GenerationType.AUTO)
@GeneratedValue (strategy = GenerationType.TABLE)
@GeneratedValue (strategy = GenerationType.SEQUENCE)
@GeneratedValue //Pour générer automatiquement la clé
Comment les Ids (les clés primaires) ont été générés dans chacun de ces
cas?
Exécuter la requête SQL : show table status;
70
 Tester l’annotation @Temporal
TemporalType.DATE: la date va être sauvegardée dans la base de données sous forme d’une
date (jour, mois, année)
TemporalType.TIMESTAMP: la date va être sauvegardée dans la base de données sous forme
d’une date (jour, mois, année) + heure à la microseconde.
TemporalType.TIME: Un temps sur 24 heures (heures, minutes, secondes à la milliseconde près)
Date aujourdhui ;
@Temporal(TemporalType.TIMESTAMP)
public Date getDateNaissance(){
return aujourdhui;
}
71
 Tester l’annotation @Enumerated New-Other-Enum
EnumType.String: Si la valeur de l’attribut va être stockées dans la base de données sous

forme de String qui représente la valeur de l’énumération.
EnumType.Ordinal: Si la valeur de l’attribut va être stockées dans la base de données sous
forme de Integer qui représente la valeur de l’énumération.
72
 Tester l’annotation @Embeddable :

73
 Tester l’annotation @IdClass :
@IdClass correspond au cas où la classe entité comprend plusieurs attributs

annotés par @Id
La classe entité est annotée par @IdClass qui prend en paramètre le nom de la
classe clé primaire.
74
 Tester l’annotation @EmbeddedId et @Embeddable :
@EmbeddedId correspond au cas où la classe entité comprend un seul attribut annoté

@EmbeddedId
La classe clé primaire est annoté par @Embeddable
75
 Tester les annotations de l’héritage:

@Inheritance(strategy=InheritanceType.SINGLE_TABLE)
@inheritance(strategy = inheritancetype.table_per_class)
@inheritance(strategy = inheritancetype.joined)

Coursjpa TP

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

Coursjpa TP

Transféré par

Droits d'auteur :

Formats disponibles

LA SPÉCIFICATION JPA

2019-2020 ESPRIT thouraya.louati@esprit.tn UP JavaEE / .NET (Bureau E204)

 Séquence 5: La spécification JPA

 Le Modèle Relationnel : les systèmes de gestion de bases de données

On parle ainsi de persistance d’objets métiers.

 Représentation d'une donnée, manipulée par l'application,

Session Bean Entity

 Pour persister les données :

 JDBC (Java DataBase Connectivity) est une API (Application

public class User {

public interface IUserDAO {

// Mise à jour User :

// Récupération List of Users :

public class UserDAOImpl implements IUserDAO {

public class UserService {

public static void main(String[] args) {

UserDAOImpl userDAOImpl = new UserDAOImpl();

User user = new User("JPH", "pwd", "JPH", "Jean-Philippe", "test@mail.com",

Télécharger les codes sources de cet exemple à partir de cet URL:

 L’utilisation de l’API JDBC était une solution pour les

 L'ORM (Object-Relational Mapping) est un concept faisant le lien

 Java Persistance API (abrégée en JPA) est une interface de

 Il y a plusieurs fournisseurs de persistance (différentes mises en

 Entité: Un ensemble de données d’un même type (e.g: Personne)

 Hibernate est un Framework open source gérant la

 Le mécanisme de sérialisation consiste à convertir un objet en

// Constructeur et accesseurs (getters) et mutateurs

private String nom;

public Personne( String nom, int age ) {

public String getNom() { return nom; }

@Id : clé primaire

 Pour donner à la table un autre nom que le nom de la classe, il

 Pour donner à une colonne de la table un autre nom que le nom

 @GeneratedValue Définit la manière dont la base gère la

strategy = GenerationType.SEQUENCE: la génération de la clé primaire est

@Id : clé primaire

 Comment le champ EMPL_ID de la table T_EMLPYEE sera

 Java primitive types (boolean, int, etc)

 Lorsqu'une entité JPA a un attribut de type temporel (Calendar

 Pas recommandé, mais une clé primaire peut être composée de

 @IdClass correspond au cas où la classe entité comprend

 @EmbeddedId correspond au cas où la classe entité comprend

 Pour représenter un modèle hiérarchique dans un modèle

 La colonne Discriminator est gérée par JPA, certes une

 Le fichier persistence.xml doit être stocké dans

Java Persistence API

 Lancer MySQL server.

 Création d’une DataSource

Comment créer une DataSource ?

 Cliquer «Test connection».

 Cliquer «Test connection».

 Nous allons utiliser un archétype de projet déjà prêt.

 Créer un nouveau projet de type Maven, et NE cochez PAS la

 Choisissez le template : wildfly-javaee7-webapp-ear-blank-

 Modifier les entrées suivantes dan le pom.xml su Projet parent :

 Faire un bouton droit sur le projet parent et faire un Maven ->

 Dans cette partie, on va travailler que sur le projet EJB :

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

 Dans le projet EJB Créer un package

 Déployer le projet sur WildFly et voir les logs

 Créer d’autres entités en variant les stratégies de génération des

 Tester l’annotation @Temporal

 Tester l’annotation @Enumerated New-Other-Enum