JEE/Spring

Spring Data JPA

JABRANE Mourad

Laboratoire d'Ingénierie des Procédés, Informatique et Mathématiques (LIPIM).

Ecole Nationale des Sciences Appliquées, Université Sultan Moulay Slimane, Maroc.

Email: mourad.jabrane@usms.ac.ma
 Spring Data – Hibernate - JPA

Mapping Objet Relationnel (ORM)

Objet Objet

Mapping
logic
Objet

Base de données
Le Mapping Objet Relationnel est un processus qui permet de faire le lien entre les
objets d'une application et les tables d'une base de données relationnelle.
Objectif des Frameworks ORM : Hibernate

Le but d’un Framework ORM est de libérer le développeur de 95 pourcent des tâches de

programmation liées à la persistance des données communes.

•Le Framework ORM assure la portabilité de l’application par rapport aux SGBD

• Performances avec ORM comme Hibernate, on est sûre d’exploiter les meilleures

bonnes pratiques des techniques d’accès aux données.

 Spring Data JPA

JPA : Java Persistence API

• JPA est une spécification créée par Sun pour standardiser le mapping Objet
relationnel.
• Il définit un ensemble d’interfaces, de classes abstraites et d’annotations qui
permettent la description du mapping objet relationnel.
• Il existe plusieurs implémentation de JPA: Hibernate – Toplink – EclipseLink…
 Spring Data JPA

JPA : Java Persistence API

 Spring Data JPA Page-5

1. Créer un nouveau projet « Spring Starter Project »

2. Remplir le formulaire par l’ensemble des
configurations (Vous devez être connectés à
internet)
3. Ajouter les 5 dépendances

Java Entreprise Edition © 2021-2022

 Spring Data JPA

Dépendance Utilisation

Un module Spring qui a pour objectif de simplifier l'interaction

Spring Data J PA
avec différents systèmes de stockage de données
Une base de données relationnelle qui stocke les données en
H2 Database
mémoire de l’ordinateur
Spring Web Module Spring consacré au développement d'application Web
Un outil pour améliorer l’expérience de développement.
Spring Boot DevTools Pa rmi ses fonctionnalités: Redémarrage automatique, Propriété
par défaut…
Ensemble des annotations dédiées à réduire le code créer par le
Lombok
développeur
 Spring Data JPA

1. Pour accéder à la base de

données, on utilise le lien:
http://localhost:8080/h2-
console/
2. Insérer l’url de la BD et cliquer
sur « Connect »
3. Si le « username » n’est pas
configuré, sa valeur par défaut
est « sa »

AHAIDOUS Khadija © 202

Spring Data JPA
 Spring Data JPA

Annotations Lombok

Annotation Explication

@NoArgsConstructor Création d’un constructeur par défaut

@AllArgsConstructor Création d’un constructeur avec tous les paramètres

Combinaison entre: @Setter, @Getter, @ToString,

@Data
@AllArgsConstructor …
 Spring Data JPA

Annotations JPA

Annotation Explication

Annotation obligatoire qui indique que cette classe est une entité JP A et est
@Entity
mappée avec une table de base de données.
@Table Annotation facultative qui contient les informations de la table comme le nom.
@Id Annotation obligatoire qui marque un champ comme clé primaire.
Annotation facultative pour personnaliser le nom du colonne, définir le nombre
@Column
caractères…
@Temporal Annotation utilisée avec les attributs Date, pour préciser le format
@CreationTimestamp Ajout automatique de la date et heure actuelle lorsqu'un nouvel objet est créé.
 Spring Data JPA

Spring Data JPA

•Spring Data est un module de Spring qui a déjà créé des interfaces et des implémentations
génériques qui permettent de gérer les entités JPA.
•Spring Data nous évite de créer les interfaces et les implémentation JPA de la couche DAO.
•Il suffit de créer une interface qui hérite de l’interface JPARepository pour hériter toutes les
méthodes classiques qui permettent de gérer les entités JPA.
•En cas de besoin, vous avez la possibilité d’ajouter d’autres méthodes en les déclarant à
l’intérieur de l’interface JPARepository, sans avoir besoin de les implémenter. Spring Data le fera à
votre place.
Spring Data JPA
 Spring Data JPA

CRUD : Create – Read – Update - Delete

• La classe implémente l’interface « CommandLineRunner ».

Cette interface est utilisée pour indiquer qu’un Bean doit
exécuter lorsqu’il est contenu au sein d’une
SpringApplication.

• L’implémentation de cette interface nous oblige à redéfinir la

méthode « run», cette dernière s’exécute immédiatement
après de démarrage de l’application.
 Spring Data JPA

CRUD : Create
Insertion dans la base de donnée
 Spring Data JPA

CRUD : Create

Pr BADRI Tijane F. Z
 Spring Data JPA

CRUD : Read
Affichage dans la console
 Spring Data JPA

CRUD : Read
Récupérer un élément par son ID
 Spring Data JPA

CRUD : Update
Mettre à jour un élément
 Spring Data JPA

CRUD : Delete
Suppression d’un élément : soit par son identifiant ou bien l’objet.
 Spring Data JPA

findByX

On peut personnaliser les requêtes de sélection, en suivant le format: findByX (X représente la colonne)

Java Entreprise Edition

 Spring Data JPA

deleteByX
On peut personnaliser les requêtes de suppression, en suivant le format: deleteByX (X représente la
colonne)

On peut retourner la liste ou seulement le nombre de lignes supprimées.

 Spring Data JPA

Requêtes composées

On peut aussi composer des requêtes:

Voir : Table 3. Supported keywords inside method names

https://docs.spring.io/spring-data/jpa/docs/current/reference/html/#repositories.core-concepts
Exemple d’interface JPARepository

public interface ProduitRepository extends JpaRepository<Produit, Long> {

@Query("select p from Produit p where p.designation like :x and p.prix>:y")
public List<Produit> chercherProduits(
@Param("x")String mc, @Param("y")double prixMin);
}
 application.properties

spring.datasource.url=jdbc:mysql://localhost:3306/Etudiant?createDatabaseIfNotExist=true
spring.datasource.username=root
spring.datasource.password=#spring.h2.console.enabled=true
server.port=8082
spring.jpa.hibernate.ddl-auto = update
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MariaDBDialect
spring.jpa.show-sql=true
Mapping des associations et de l’héritage
Association OneToMany, ManyToOne, OneToOne : Exemple Rendez-
Vous Médecins , Patients

▸On souhaite gérer les rendez-vous des consultations des patients effectuées par des médecins.
▸Chaque Rendez-vous concerne un patient et un médecin.
▸Pour chaque rendez-vous on associe une seule consultation issue de rendez-vous.
▸Un Patient peut prendre plusieurs rendez-vous

Patient
Id : Long
nom : String
email : String 1 *
RendezVous Consultation
Id : Long 1 1 Id : Long
Medecin dateRDV : Date dateConsultation: Date
1 * rapportConsultation : Date
Id : Long heureRDV : Date
nom : String
email : String
Specialite : String
Association OneToMany, ManyToOne, OneToOne : Exemple Rendez-Vous Médecins ,
Patients @Entity
@Entity @Data @AllArgsConstructor @NoArgsConstructor
@Data @NoArgsConstructor @AllArgsConstructor public class Medecin {
public class Patient { @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
@Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Long id;
private Long id; private String nom;
private String nom; private String specialite;
private String email; private String email;
@OneToMany(mappedBy = "patient" fetch = FetchType.LAZY) @OneToMany(mappedBy = "medecin")
} private Collection<RendezVous> rendezVous; private Collection<RendezVous> rendezVous;
}

@Entity @Entity
@Data @NoArgsConstructor @AllArgsConstructor @Data @NoArgsConstructor @AllArgsConstructor
public class RendezVous {
@Id @GeneratedValue(strategy = GenerationType.IDENTITY)
public class Consultation {
private Long id; @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
private Date dateRendezVous; private Long id;
@ManyToOne private Date dateConsultation;
private Medecin medecin;
private String rapportConsultation;
@ManyToOne
private Patient patient; private double prixConsultation;
@OneToOne @OneToOne(mappedBy = "consultation")
private Consultation consultation; private RendezVous rendezVous;
}
}
 Cas de ManyMany

▸On suppose que l’on souhaite de créer une application qui permet de gérer des Utilisateurs
appartenant à des groupes. Chaque Groupe peut contenir plusieurs utilisateurs.

Utilisateurs Groupe
Id : Long usename * * Id : Long groupName:
: String password : String
String

@Entity @Entity
@Data @NoArgsConstructor @AllArgsConstructor @Data @AllArgsConstructor @NoArgsConstructor
public class Utilisateur { public class Groupe {
@Id @GeneratedValue(strategy = GenerationType.IDENTITY) @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id; private Long id;
@Column(unique = true) @Column(unique = true)
private String userName; private String groupName;
private String password; @ManyToMany(fetch = FetchType.EAGER)
@ManyToMany(mappedBy = "utilisateurs",fetch = FetchType.EAGER) private Collection<Utilisateur> utilisateurs=new ArrayList<>();
private Collection<Groupe> groupes=new ArrayList<>(); }
}
 TABLE_PER_CLASS
Mapping de l’héritage
ETUDIANTS
▸ Différentes stratégies de Mapping de l’héritage ID NOM DATE_NAISSANCE NOTE

• Une table par hiérarchie (SINGLE_TABLE) 1 N1 d1 15

• Une table pour chaque classe concrète (TABLE_PER_CLASS)
• Une table pour la classe parente et une table pour chaque classe fille (JOINED_TABLE) ENSEIGNANTS
ID NOM DATE_NAISSANCE MATIERE
Personne SINGLE_TABLE : PERSONNES
2 N2 d2 MATH
Id : Long ID TYPE NOM DATE_NAISSANCE NOTE MAIETRE
Nom: String
dateNaissance : Date
1 ET N1 d1 15 NULL

2 PROF N2 d2 NULL MATH

Etudiant Enseignant
JOINED_TABLE
note: double matiere: String
ETUDIANTS
NOTE #ID
PERSO NNES
15 1
NOM DATE_NAISSANCE
ID
ENSEIGNANTS
MATIERE #ID 1 N1 d1

MATH 2 2 N2 d2
 @Entity
Mapping de l’héritage : Stratégie SINGLE_TABLE @Data @NoArgsConstructor @AllArgsConstructor
@DiscriminatorValue("ETUD")
public class Etudiant extends Personne {
Personne private double note;
}
Id : Long
Nom: String
dateNaissance : @Entity
Date @Data @NoArgsConstructor @AllArgsConstructor
@DiscriminatorValue("PROF")
public class Enseignant extends Personne {
private String matiere;
Etudiant Enseignant }

note: double matiere: String

@Autowired
private PersonneRepository personneRepository;
@Entity Etudiant etudiant=new Etudiant();
@Data @NoArgsConstructor @AllArgsConstructor etudiant.setNom("Hassan");
@Inheritance(strategy = InheritanceType.SINGLE_TABLE) etudiant.setDateNaissance(new Date());
@DiscriminatorColumn(name = "TYPE",length = 4) etudiant.setNote(14);
public abstract class Personne { personneRepository.save(etudiant);
@Id @GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id; Enseignant enseignant=new Enseignant();
private String nom; enseignant.setNom("Mohamed");
private Date dateNaissance; enseignant.setDateNaissance(new Date());
} enseignant.setMatiere("MATH");
personneRepository.save(enseignant);

public interface PersonneRepository extends JpaRepository<Personne,Long> {

}
 @Entity
Mapping de l’héritage : Stratégie TABLE_PER_CLASS @Data @NoArgsConstructor @AllArgsConstructor
public class Etudiant extends Personne {
private double note;
Personne }
Id : Long
Nom: String
dateNaissance : @Entity
Date @Data @NoArgsConstructor @AllArgsConstructor
public class Enseignant extends Personne {
private String matiere;
}
Etudiant Enseignant
note: double matiere: String
@Autowired
private PersonneRepository personneRepository;

@Entity Etudiant etudiant=new Etudiant();

@Data @NoArgsConstructor @AllArgsConstructor etudiant.setNom("Hassan");
etudiant.setDateNaissance(new Date());
@Inheritance(strategy = etudiant.setNote(14);
InheritanceType.TABLE_PER_CLASS) public personneRepository.save(etudiant);
abstract class Personne {
@Id @GeneratedValue(strategy = GenerationType.TABLE) Enseignant enseignant=new Enseignant();
enseignant.setNom("Mohamed");
private Long id; enseignant.setDateNaissance(new Date());
private String nom; enseignant.setMatiere("MATH");
personneRepository.save(enseignant);
private Date dateNaissance;
}
public interface PersonneRepository extends JpaRepository<Personne,Long> {
}
 @Entity
Mapping de l’héritage : Stratégie JOINED_TABLE @Data @NoArgsConstructor @AllArgsConstructor
public class Etudiant extends Personne {
private double note;
Personne }
Id : Long
Nom: String
dateNaissance : @Entity
Date @Data @NoArgsConstructor @AllArgsConstructor
public class Enseignant extends Personne {
private String matiere;
}
Etudiant Enseignant
note: double matiere: String
@Autowired
private PersonneRepository personneRepository;

@Entity Etudiant etudiant=new Etudiant();

@Data @NoArgsConstructor etudiant.setNom("Hassan");
etudiant.setDateNaissance(new Date());
@AllArgsConstructor @Inheritance(strategy = etudiant.setNote(14);
InheritanceType.JOINED) public abstract personneRepository.save(etudiant);
class Personne {
@Id @GeneratedValue(strategy = GenerationType.TABLE) Enseignant enseignant=new Enseignant();
enseignant.setNom("Mohamed");
private Long id; enseignant.setDateNaissance(new Date());
private String nom; enseignant.setMatiere("MATH");
personneRepository.save(enseignant);
private Date dateNaissance;
}
public interface PersonneRepository extends JpaRepository<Personne,Long> {
}
TP Jpa, Hibernate,Spring data

• Support:
• Voir support de cours.
• Travail a faire:
• Créer un projet spring boot avec les dépondances; spring data jpa, lombok, spring web,
spring web dev tools, et h2 database,
• Créer l’entité Jpa Etudiant.
• Configurer le data source (application.properties)
• Créer l’interface Etudiant Repository basé sur spring data.
• Tester l’application avec des opération d’ajout de consultation de mise a jour et de
suppression des étudiants.
• Utiliser une base de donnée Mysql au lieu de h2.