Travaux Pratiques Java Jee Spring

Université Abdelmalek Essaadi
Ecole Nationale des Sciences Appliquées

Al Hoceima
Travaux Pratiques
Développement des applications Web avec les

Frameworks Java et Java EE
Deuxième Année Génie Informatique
Module : Technologies Distribuées
Année Universitaire : 2021/2022
Ces travaux pratiques proposent un ensemble d’exercices d’application des

technologies Java EE étudiées dans le cours, à savoir : Servlets, JSP,
Filtres, Spring Core, Spring MVC, Spring Security, Spring DATA REST,
Spring DATA JPA, JPA et Hibernate.
Enseignant : Pr. Tarik BOUDAA

Email : t.boudaa@uae.ac.ma
Tarik BOUDAA, ENSA AL Hoceima 2021/2022
Table des matières

Travaux Pratiques N°1 : Servlets et Filtres ..................................................................... 3
1- Filtres et Servlets : ....................................................................................................................... 3
2- Jeu de dés 1: Servlets, gestion de la session, contexte et filtres .................................................. 4
3- Jeu de dés 2 : Servlets, gestion de la session, contexte et filtres ................................................. 4
Travaux Pratiques N°2 : Spring MVC et Injection de dépendances.................... 7
Travaux Pratiques N°3 : Applications CRUD avec JPA, Hibernate, Bean
Validator, Spring Data JPA ....................................................................................................... 9
1- Utilisation du Framework Hibernate dans une application autonome : ...................................... 9
2- Hibernate et applications Web avec Spring MVC....................................................................... 9
3- Validation des données avec Hibernate Validator ..................................................................... 12
4- Gestion de la persistance avec JPA ........................................................................................... 12
5- Gestion de la persistance avec Spring DATA JPA.................................................................... 12
6- Accès concurrents...................................................................................................................... 13
Travaux Pratiques N°4 : Applications Web sécurisées avec Spring Security

............................................................................................................................................................... 14
1- Utilisations de base de Spring Security ..................................................................................... 14
2- Spring Security avec une base de données et JDBC ................................................................. 14
Travaux Pratiques N°5 : Application Web avec gestion personnalisée des
habilitations et ORM avancé ................................................................................................. 15
Travaux Pratiques N°6 : Application Web REST et Spring Boot ......................... 17
1- REST avec Spring MVC: .......................................................................................................... 17
2- Spring MVC, REST et Framework Hibernate : ........................................................................ 17
3- Spring data REST ...................................................................................................................... 18
4- Spring Boot................................................................................................................................ 19
2
Travaux Pratiques N°1 : Servlets et

Filtres
1- Filtres et Servlets :
1. Créer une Servlet MyServlet qui enregistre toutes les données d’un étudiant ;
reçues par la méthode GET ; dans la session de l’utilisateur.
Exemple :
Après les invocations suivantes :
http://localhost/app/MyServlet?id=1&nom=test_nom1&prenom=test_prenom1
&dateNaissance=1/1/2000&cne=4444444444
http://localhost/app/MyServlet?id=2&nom=test_nom2&prenom=test_prenom
La session de l’utilisateur doit stocker dans une structure de données adéquate les
données suivantes :
- Etudiant 1 : id=1 ; nom="test_nom4" ; prenom="test_prenom4 ; dateNaissance
=4/2/2001 ;cne=1111111111
- Etudiant 2 : id=2 ; nom="test_nom2" ; prenom="test_prenom2 ;
dateNaissance=1/2/2001 ;cne=2222222222
- Etudiant 3 : id=3 ; nom="test_nom3" ; prenom="test_prenom3 ;
dateNaissance=1/3/2001 ;cne=3333333333
2. Créer un filtre MyFilter1 qui intercepte les requêtes envoyées vers MyServlet et
il vérifie si un étudiant ayant le même cne existe déjà dans la session. Dans ce
cas, le filtre redirige vers une page JSP qui affiche une erreur. Sinon il laisse la
Servlet s’exécuter.
3
3. Ajouter un deuxième filtre MyFilter2 qui doit s’exécuter avant MyFilter1 et qui
interdit l’exécution des requêtes contenant des personnes ayant l’âge < 22 ans.
2- Jeu de dés 1: Servlets, gestion de la session, contexte et filtres
Réaliser une application jeu de dés, à base de Servlets, JSP et filtres, qui offre les
fonctionnalités ci-dessous :
- L’utilisateur doit pouvoir créer un compte
- L’application stocke les informations de chaque utilisateur (nom,
prénom, login, mot de passe et meilleur score)
- L’application permet à l’utilisateur de :
 Se connecter / Se déconnecter
 Jouer sur l’application
 Consulter son meilleur score
 Consulter le meilleur score des autres joueurs
Règles du jeu :
Lorsque le joueur lance le dès, s'il réalise deux fois successivement le même
résultat alors il reçoit 20 points (on incrémente son score de 20 points). Pour
chaque partie de jeu le joueur a droit à 20 lancées.
Enregistrer les données de l’application dans une structure de données adéquate,
dans le contexte de l’application.
3- Jeu de dés 2 : Servlets, gestion de la session, contexte et filtres
On considère un jeu dans lequel on lance 3 dés un par un dans n’importe quel
ordre, via une interface comme celle décrite sur la figure 1. Ces dés sont
numéroté 1, 2 et 3. Le champ de texte permet à l’utilisateur d’indiquer le numéro
du dé à lancer, le lancement du dé se fait via le bouton « Lancer le dé ». Durant
une partie, un même dé ne doit pas être lancé plusieurs fois, en effet, si un joueur
lance un même dé plus qu’une fois l’application arrête la partie de jeu et le joueur
reçoit un score = -1.
Si le résultat obtenu pour le dé numéro 1 est strictement inférieur au résultat

obtenu pour le dé numéro 2 et que le résultat obtenu pour le dé numéro 2 est
strictement inférieur au résultat obtenu pour le dé numéro 3 alors le joueur reçoit
4
un score égal à la somme des résultats obtenus pour les 3 dés. Sinon il reçoit un
score nul. L’application doit arrêter la partie une fois on peut conclure à propos
du score, par exemple si on obtient 6 pour le dé numéro 1 il ne sert à rien
d’attendre les résultats des autres dés, le score dans ce cas est 0.
Une partie de jeu se termine donc soit après avoir lancé les 3 dés ou suite à une
faute de lancement d’un même dé deux fois ou car la condition « résultat (dé 1)
< résultat (dé 2) < résultat (dé 3) » est surement n’est vérifiée (cas d’avoir 6 pour
le premier dé par exemple).
Figure 1 : Page lancement des dés
A la fin d’une partie, l’application affiche le score de la partie qui vient d’être
jouée ainsi que le meilleur score enregistré sur l’application (cf. figure 2).
Figure 2 : page de fin d'une partie

Cette application n’utilise pas une base de données mais elle stocke simplement
les données dans des structures de données adéquates dans le contexte de
l’application.
Les fonctionnalités à implémenter sont :
- L’utilisateur doit pouvoir créer un compte

- L’application stocke les informations de chaque utilisateur (nom,
prénom, login, mot de passe et meilleur score)
- L’application permet à l’utilisateur de :
5
 Se connecter / Se déconnecter
 Jouer sur l’application
 Consulter son meilleur score
 Consulter le meilleur score des autres joueurs
6
Travaux Pratiques N°2 : Spring MVC et

Injection de dépendances
Travail à faire :
1. Créer une application Web AppWeb avec Spring MVC basée sur une
configuration par code Java qui effectuent les choses suivantes :
a) Un contrôleur Spring MVC qui effectue le même travail que celui de la
Servlet MyServlet de l’exercice TP1-EX1.
b) Deux intercepteurs effectuant le même travail des filtres MyFilter1 et
MyFilter2 de l’exercice TP1-EX1.
c) Un contrôleur Spring MyController qui reçoit les données des étudiants (id,
nom, prénom, date naissance, cne) envoyées via un formulaire il les enregistre
dans la session puis il les affiche dans une JSP sous forme d’une table HTML
en utilisant les balises de JSTL. Si une personne portant le même id existe
déjà dans la session le contrôleur effectue (si nécessaire) une mise à jour des
données de la session.
2. Ecrire une classe nommée CalculAgeImpl qui implémente l’interface
ICalculAge. La méthode calculer prend en paramètre une date et retourne l’âge
d’une personne exprimé en nombre entier d'années :
public interface ICalculAge {
public int calculer(Date d) ;
}
3. Injecter dans MyController une instance de CalculAgeImpl en utilisant
@autowired et une injection par constructeur.
4. Changer le code précédent de MyController et le code JSP pour afficher dans la
table HTML l’âge au lieu de la date de naissance.
5. Ajouter une Classe CompareAgeImpl qui implémente l’interface
ICompareAge ci-dessous. La méthode comparer retourne 1 si d1<d2, 0 si d1=d2
et -1 si d1>d2.
7
public interface ICompareAge {

public int comparer(Date d1, date d2) ;
}
6. Injecter une instance de CompareAgeImpl dans MyController en utilisant une
injection par attribut puis l’utiliser pour trier par âge croissant les étudiants
existant dans la session et les afficher dans une table HTML.
7. Ajouter une deuxième implémentation CalculAgeMoisImpl de l’interface
ICalculAge qui retourne l’âge en nombre de mois.
8. Injecter via un mutateur (setter) une instance de CalculAgeMoisImpl dans
MyController puis l’utiliser pour trier par âge décroissant les étudiants existant
dans la session et les afficher dans une table HTML (par mois).
8
Travaux Pratiques N°3 : Applications

CRUD avec JPA, Hibernate, Bean
Validator, Spring Data JPA
1- Utilisation du Framework Hibernate dans une application

autonome :
1. Configurer une application Hibernate de base et vierge.
2. Ecrire une classe Etudiant (même attributs de la classe du TP précédent) puis
l’annoter avec les annotations JPA pour que sa persistance soit gérée par Hibernate.
3. Implémenter une classe générique DaoImpl<T> avec Hibernate natif qui
implémente les fonctionnalités définies dans l’interface ci-dessous :
public interface Dao<T>{
public Long save(T o) ;
public void update(T o) ;
public void delete(Long id) ;
public T findById(Long id) ;
public List<T> getAll() ;
}
4. En utilisant le code générique précédent, implémenter une classe EtudiantDaoImpl
qui implémente l’interface suivante :
public interface EtudiantDao extends Dao<Etudiant>{
public List<T> findByNometPrenom(String pNom, String pPrenom) ;
}
5. Ecrire un test unitaire de la classe EtudiantDaoImpl.
2- Hibernate et applications Web avec Spring MVC
L’objectif de cet exercice est le développement d’une application de gestion des

inscriptions à un événement via les interfaces décrites ci-dessous.
9
Ecrire le code de cette application avec Spring MVC et Hibernate en réutilisant une
partie du code écrit dans le TP précédent.
Inscription :
Le bouton envoyer permet d’enregistrer les données dans une base données. La liste des
inscrits s’affiche au-dessous du formulaire.
Si l’opération est effectuée avec succès une page s’affiche contenant un message
indiquant le succès de l’opération sinon une page d’erreur doit être affichée.
Gestion des inscriptions
L’application dispose également d’une page de gestion des inscrits et permet de modifier
les informations d’une personne ou supprimer une personne de la base de données.
10
Le lien « delete » permet de supprimer une personne
Le lien « update » redirige vers le formulaire (pré-rempli) de mise à jour d’une personne
(voir figure ci-dessous) :
Contraintes techniques à respecter :
- Utiliser une architecture en 3 couches (couche présentation, couche logique

métier, couche d’accès aux données)
- Décomposer l’application en deux projets maven, un pour la partie logique métier
et un autre contenant la partie web de l’application
- Utiliser l’injection de dépendance et la programmation par interface pour assurer
le découplage entre les couches de l’application
11
3- Validation des données avec Hibernate Validator
Dans le code de l’application précédente, ajouter les règles de validations suivantes avec
Hibernate Validator:
- Tous les champs de texte sont obligatoires

- Valider l’adresse email
- Le mot de passe doit être une chaîne de caractères de 10 caractères minimum et
20 caractères maximum.
- L’âge doit être un entier entre 20 et 90
- L'identifiant national doit être composé de 2 lettres majuscules suivies de 8
chiffres
La figure suivante montre comment elles doivent s’afficher les erreurs de validation de
données :
4- Gestion de la persistance avec JPA
Refaire l’exercice 1 en utilisant JPA.
5- Gestion de la persistance avec Spring DATA JPA
Ré-implémenter la couche persistance de l’exercice 2 avec Spring DATA JPA.
12
6- Accès concurrents
1- Effectuer une copie du code de l’application de l’exercice TP3-EX1, puis écrire
un code mettant en évidence quelques problèmes d’accès concurrent vue dans le
cours en changeant à chaque fois les paramètres d’isolation et de propagation
transactionnel de l’annotation @Transactional.
2- Implémenter le versionning d’entités avec Hibernate pour éviter les problèmes
d’accès concurrents sur les entités représentant les personnes en base de données.
On suppose que plusieurs utilisateurs peuvent modifier en même temps les
mêmes données des personnes en base de données.
13
Travaux Pratiques N°4 : Applications

Web sécurisées avec Spring Security
1- Utilisations de base de Spring Security
L’objectif de cet exercice est de sécuriser l’application de l’exercice TP3-EX1 avec

Spring Security en utilisant en premier lieu une configuration basique de la sécurité qui
définit les utilisateurs dans le code Java de configuration.
Cette application gère plusieurs rôles et chaque rôle a accès uniquement à un sous-
ensemble des cas d’utilisations :
Cas d’utilisation Rôle

Inscription Anonyme (Sans authentification)
Authentification Anonyme (Sans authentification)
Consultation de la liste des inscriptions Organisateur
Modifier/Supprimer/Consulter les Administrateur
inscriptions
2- Spring Security avec une base de données et JDBC
Améliorer le code précédent pour utiliser JDBC et une base de données pour la gestion
des comptes utilisateurs. Ajouter la protection contre les attaques CRSF et implémenter
le hachage des mots de passe avec un gain de sel.
14
Travaux Pratiques N°5 : Application

Web avec gestion personnalisée des
habilitations et ORM avancé
Travail à faire :
Le digramme de classe donné sur la figure 1, décrit les entités d’une application de
gestion d’absence.
1- Ecrire ces classes en Java en les annotant avec les annotations de JPA puis
générer la base de données.
2- Cette application possèdes 4 types de rôles : Cadre ADMIN, ETUDIANT, PROF
et ADMIN. Implémenter une gestion personnalisée de l’authentification et la
gestion des autorisations basées sur la couche Service de l’application et ce en
personnalisant UserDetailsService de Spring Security et en respectant la
conception donnée sur la figure 1 pour les classes : Utilisateur, Compte et Role.
3- Développer avec Spring, Spring MVC et Hibernate le sous-ensemble des
fonctionnalités de cette application décrites ci-dessous par rôle :
Use Case Rôle

Recherche par nom Cadre ADMIN
Ajouter/Supprimer/Modifier un étudiant Administrateur
Recherche par CNE/ Code Massar Cadre ADMIN – PROF
Afficher la liste des classes Cadre ADMIN – PROF
Afficher la liste des étudiants d’une classe Cadre ADMIN – PROF
Imprimer la liste des étudiants d’une classe (Transformer la liste en Cadre ADMIN
fichier PDF avec iText par exemple)
Exporter au format CSV ou Excel (avec Apache POI) les listes des Cadre ADMIN
étudiants d’une classe
Statistiques d’étudiants par classe Cadre ADMIN
Afficher la liste des inscriptions de l’étudiant Cadre ADMIN
15
4- Ajouter les fonctionnalités de traçabilité ci-dessous disponibles pour le compte

de type ADMIN:
- Lors de la suppression d’un étudiant par erreur on doit avoir toujours un
moyen pour le récupérer.
- Chaque modification sur un étudiant doit être tracée.
TypeSeance
- idTypeSeance : int
- intitule : String
- alias : String
0..*
typeSeance Absence Matiere
0..1
- idAbsence : int - idMatiere : int
absences 0..* 1..1
- dateHeureDebutAbsence : Date - nom : String
absences matiere
- dateHeureFinAbsence : Date - code : String
PieceJustificative
- etat : int
- idPieceJustificative : int 0..*
- typeSaisie : String
- cheminFichier : String absences 1..*
- intitule : String matieres
0..* 1..*
- dateLivraison : Date piecesJustificatives absence 0..*
- etat : int absencesMarquees
- source : String
1..1
inscription
1..1
observateur Inscription
Enseignant - idInscription : int
- specialite : String - annee : int
- etat : int 1..1
module
Module
0..* 0..*
inscriptions inscriptions - idModule : int
- titre : String
- code : String
Etudiant 0..*
Utilisateur modules
1..1
- idUtilisateur : int - cne : String
etudiant
- dateNaissance : Date
- nom : String
- prenom : String
- identifiant : String
- email : String 1..1 1..1
1..1 - telephone : String niveau niveau
proprietaire - nomArabe : String Niveau
- prenomArabe : String
- photo : String - idNiveau : int
- alias : String
- titre : String
0..* CadreAdministrateur
comptes
- grade : String
Compte
- idCompte : int
- enabled : int
- accountNotExpired : int
- accountNotLocked : int
- login : int JournalisationEvenements
- password : int - idEvenement : int
- disconnectAccount : boolean - details : String
- accepteDemandeAutorisationAbsence : boolean 0..* - adresseIP : String
- affichePhoto : boolean evenements - DateHeure : Date
- afficheEmail : boolean 1..1 - typeEvenement : String
compte - criticite : String
Role
- idRole : int
- nomRole : String
0..*
comptes 1..1
role
Figure 1
16
Travaux Pratiques N°6 : Application

Web REST et Spring Boot
1- REST avec Spring MVC:

1. Télécharger et installer le client de teste d’API REST POSTMAIN depuis :
https://www.postman.com/downloads/
2. Ecrire un contrôleur REST nommé MyRestController qui implémente les
opérations CRUD ci-dessous sur les objets de type Etudiant :
- Supprimer un étudiant par id
- Retrouver un étudiant par id
- Ajouter un étudiant
- Modifier un étudiant
- Lister les étudiants
Les données doivent être stockées dans le contexte de l’application au lieu de la
base de données.
3. Tester votre API REST avec POSTMAIN.
4. Ecrire une application Java console autonome basée sur Jackson qui consomme
le service REST permettant de lister les étudiants.
5. Injecter dans votre contrôleur REST une instance de CalculAgeMoisImpl écrite
dans le TP 2 puis ajouter un service REST qui reçoit la date de naissance d’une
personne et retourne son âge en nombre de mois. Tester ce service depuis votre
application Console.
2- Spring MVC, REST et Framework Hibernate :
1. Configurer une application SpringMVC/Hibernate vierge en se basant sur les
codes réalisés dans les TPs précédents.
2. Implémenter une classe générique SpringDaoImpl<T> basée sur Spring et
Hibernate et qui implémente les fonctionnalités définies dans l’interface
générique ci-dessous :
public interface Dao<T>{
17
public Long save(T o) ;

public void update(T o) ;
public void delete(Long id) ;
public T findById(Long id) ;
public List<T> getAll() ;
}
3. En utilisant le code générique précédent, implémenter une classe
SpringEtudiantDaoImpl qui implémente l’interface suivante :
public interface SpringEtudiantDao extends Dao<Etudiant>{
public List<T> findByNometPrenom(String pNom, String pPrenom) ;
}
4. En se basant sur SpringEtudiantDaoImpl telle qu’elle est définit dans la question
précédente, écrire un service métier EtudiantServiceImpl qui reçoit par injection
une instance de SpringEtudiantDaoImpl et implémente les fonctionnalités
déclarées par l’interface EtudiantService ci-dessous :
public interface EtudiantService{
public void addNewStudent(Etudiant o) ;
public list<T> findAllStudentWithSameNameAs(String nom) ;
public list<T> updateStudent(Etudiant e) ;
public List<T> getAllStudentAgeLessThan(int age) ;
}
5. Ecrire un contrôleur REST qui expose les services de EtudiantService sous forme
de service Web REST. Et tester ces services depuis POSTMAIN.
6. Ecrire un contrôleur Web et les pages JSP nécessaires pour proposer les
fonctionnalités définies dans EtudiantService sous forme d’une application Web
Spring MVC.
3- Spring data REST
Ecrire une nouvelle application qui propose une API REST qui inclut les mêmes services
web de l’application de l’exercice 2 mais cette fois-ci en utilisant Spring data REST.
18
4- Spring Boot
Proposer une autre implémentation de l’application de l’exercice TP3-EX1 en se basant

sur Spring boot et implémenter la sécurité avec une implémentation personnalisée de
l’authentification et la gestion des autorisations basées sur votre propre couche Services.
Ajouter également dans cette application une API REST sécurisée par Spring Security
et permettant la consultation de la liste des inscriptions.
19

Travaux Pratiques Java Jee Spring

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

Travaux Pratiques Java Jee Spring

Transféré par

Droits d'auteur :

Formats disponibles

Université Abdelmalek Essaadi

Ecole Nationale des Sciences Appliquées

Développement des applications Web avec les

Deuxième Année Génie Informatique

Module : Technologies Distribuées

Année Universitaire : 2021/2022

Ces travaux pratiques proposent un ensemble d’exercices d’application des

Enseignant : Pr. Tarik BOUDAA

Table des matières

1- Filtres et Servlets : ....................................................................................................................... 3

2- Jeu de dés 1: Servlets, gestion de la session, contexte et filtres .................................................. 4

3- Jeu de dés 2 : Servlets, gestion de la session, contexte et filtres ................................................. 4

Travaux Pratiques N°2 : Spring MVC et Injection de dépendances.................... 7

Travaux Pratiques N°3 : Applications CRUD avec JPA, Hibernate, Bean

Validator, Spring Data JPA ....................................................................................................... 9

1- Utilisation du Framework Hibernate dans une application autonome : ...................................... 9

2- Hibernate et applications Web avec Spring MVC....................................................................... 9

3- Validation des données avec Hibernate Validator ..................................................................... 12

4- Gestion de la persistance avec JPA ........................................................................................... 12

5- Gestion de la persistance avec Spring DATA JPA.................................................................... 12

Travaux Pratiques N°4 : Applications Web sécurisées avec Spring Security

1- Utilisations de base de Spring Security ..................................................................................... 14

2- Spring Security avec une base de données et JDBC ................................................................. 14

Travaux Pratiques N°5 : Application Web avec gestion personnalisée des

habilitations et ORM avancé ................................................................................................. 15

Travaux Pratiques N°6 : Application Web REST et Spring Boot ......................... 17

1- REST avec Spring MVC: .......................................................................................................... 17

2- Spring MVC, REST et Framework Hibernate : ........................................................................ 17

3- Spring data REST ...................................................................................................................... 18

Travaux Pratiques N°1 : Servlets et

Si le résultat obtenu pour le dé numéro 1 est strictement inférieur au résultat

Figure 1 : Page lancement des dés

Figure 2 : page de fin d'une partie

Les fonctionnalités à implémenter sont :

- L’utilisateur doit pouvoir créer un compte

Travaux Pratiques N°2 : Spring MVC et

public interface ICompareAge {

Travaux Pratiques N°3 : Applications

1- Utilisation du Framework Hibernate dans une application

L’objectif de cet exercice est le développement d’une application de gestion des

Gestion des inscriptions

Le lien « delete » permet de supprimer une personne

Contraintes techniques à respecter :

- Utiliser une architecture en 3 couches (couche présentation, couche logique

3- Validation des données avec Hibernate Validator

- Tous les champs de texte sont obligatoires

4- Gestion de la persistance avec JPA

Refaire l’exercice 1 en utilisant JPA.

5- Gestion de la persistance avec Spring DATA JPA

Ré-implémenter la couche persistance de l’exercice 2 avec Spring DATA JPA.

Travaux Pratiques N°4 : Applications

1- Utilisations de base de Spring Security

L’objectif de cet exercice est de sécuriser l’application de l’exercice TP3-EX1 avec

Cas d’utilisation Rôle

2- Spring Security avec une base de données et JDBC

Travaux Pratiques N°5 : Application

Use Case Rôle

4- Ajouter les fonctionnalités de traçabilité ci-dessous disponibles pour le compte

Travaux Pratiques N°6 : Application

1- REST avec Spring MVC:

public Long save(T o) ;

3- Spring data REST

Proposer une autre implémentation de l’application de l’exercice TP3-EX1 en se basant