UNIVERSITE SIDI MOHAMED BEN ABDELLAH
ÉCOLE NATIONALE DES SCIENCES APPLIQUÉES FÈS
COMPTE RENDU
TRAVAUX PRATIQUES
TP en JEE
Module : JEE
Filière : Génie Informatique 2
Réalisé par :
- EL FAKHRI Ismail
Encadré par :
- Pr. AMANE Meryem
Année Universitaire 2023-2024
Introduction :
Dans le premier exercice, nous nous plongeons dans la conception d'une
application web J2EE en suivant rigoureusement le modèle MVC (Modèle-Vue-
Contrôleur). L'objectif principal est de créer une fonctionnalité qui permettra aux
utilisateurs de calculer les mensualités en fonction de différents paramètres : le
montant emprunté (exprimé en DT), la durée de l'emprunt en mois, et le taux
d'intérêt global annuel (exprimé en pourcentage). Nous accorderons une attention
particulière à l'application des principes architecturaux de JEE pour assurer la
robustesse, la flexibilité et la scalabilité de l'application. Nous mettrons en place
des mécanismes de gestion des erreurs et des transactions, ainsi qu'une
architecture modulaire pour permettre une évolutivité aisée.
Dans le deuxième exercice, nous nous concentrons sur la gestion efficace d'une
bibliothèque à travers le développement d'une application web similaire basée sur
le modèle MVC. Cette application permettra aux utilisateurs d'ajouter des livres à
la bibliothèque, de les visualiser, et de calculer le nombre total de livres
disponibles. Pour ce faire, nous utiliserons une base de données relationnelle pour
stocker toutes les informations pertinentes sur les livres et les emprunts. Nous
ferons appel à l'API JDBC pour faciliter les interactions avec la base de données,
en garantissant ainsi une gestion efficace des opérations de lecture et d'écriture.
En outre, nous accorderons une attention particulière à la sécurité des données, en
mettant en place des mécanismes d'authentification et d'autorisation pour assurer
la confidentialité et l'intégrité des informations stockées dans la base de données.
TP N1
Exercice 1: Calculer la mensualité
Pour créer un formulaire qui calcule la mensualité à l'aide de Java Enterprise Edition (JEE)
Création de la page JSP (JavaServer Pages) : Créez une page JSP qui contiendra le formulaire de saisie
des données (montant emprunté, durée de l'emprunt, taux d'intérêt) et affichera le résultat du calcul
de la mensualité.
Définition de la servlet : Créez une servlet qui traitera les données soumises par le formulaire. Cette
servlet recevra les paramètres du formulaire, effectuera le calcul de la mensualité et renverra le
résultat à la page JSP.
Développement de la logique de calcul : Implémentez la logique de calcul de la mensualité dans la
servlet. Cette logique consiste généralement à utiliser la formule de calcul des mensualités basée sur
le montant emprunté, la durée de l'emprunt et le taux d'intérêt.
Interactions avec le formulaire et la servlet : Dans la page JSP, utilisez les balises HTML pour créer le
formulaire et les éléments de saisie des données. Définissez l'action du formulaire pour qu'il envoie
les données à la servlet lors de la soumission.
Récupération des données dans la servlet : Dans la servlet, récupérez les données soumises par le
formulaire à l'aide des méthodes appropriées (par exemple, [Link]()).
Calcul de la mensualité : Utilisez les valeurs récupérées pour calculer la mensualité en utilisant la
formule appropriée. Vous pouvez utiliser les types de données numériques de Java pour effectuer les
calculs.
Envoi du résultat à la page JSP : Une fois le calcul effectué, envoyez le résultat (la mensualité
calculée) à la page JSP pour l'afficher à l'utilisateur.
Affichage du résultat : Dans la page JSP, utilisez des balises HTML pour afficher le résultat du calcul
de la mensualité.
Tests et débogage : Testez votre formulaire en le soumettant avec différentes valeurs et assurez-vous
que le calcul de la mensualité fonctionne correctement. Effectuez le débogage si nécessaire pour
résoudre tout problème rencontré.
Enfin, nous avons créé la page JSP qui représente l'interface utilisateur pour le
calcul de la mensualité. Dans cette page JSP, nous avons mis en place un
formulaire avec la méthode "post", intégrant les champs nécessaires pour la
saisie des informations requises pour le calcul de la mensualité, tels que le
montant du prêt, le taux d'intérêt et la durée du prêt. Nous avons également
récupéré la valeur de la mensualité à partir du contrôleur si elle est non nulle.
Exercice 2: Gestion des livres
Dans cette étape, nous avons décidé d'adopter le modèle de conception MVC
(Modèle-Vue-Contrôleur) pour organiser notre application Java EE (Java
Platform, Enterprise Edition). Le modèle MVC divise l'application en trois
composants distincts : le Modèle, qui est responsable de la gestion des
données et de la logique métier, la Vue, qui représente l'interface utilisateur,
et le Contrôleur, qui agit comme un intermédiaire entre le modèle et la vue.
Pour notre projet, le modèle est chargé de la gestion des informations
concernant les livres ainsi que de la logique associée. La vue permet aux
utilisateurs d'interagir en ajoutant et en affichant des livres, tandis que le
contrôleur gère les entrées utilisateur, appelle les actions sur le modèle et met
à jour la vue en conséquence.
Nous avons mis en place une interface utilisateur intuitive, offrant à l'utilisateur
la possibilité d'ajouter et de consulter ses livres, tout en affichant le nombre total
de livres ajoutés. Pour cela, nous avons conçu la classe "Livre" afin de
représenter les caractéristiques essentielles d'un livre, accompagnée des
méthodes appropriées. Afin de garantir une structure bien organisée, nous avons
introduit une interface définissant les fonctionnalités requises, telles que la
récupération de tous les livres, l'ajout d'un nouveau livre, ainsi que le calcul du
nombre total de livres. Cette approche de séparation des responsabilités entre
l'interface et son implémentation favorise la collaboration, clarifie les rôles de
chaque composant, et assure la cohérence et la maintenabilité du code.
Ensuite j’ai avancé vers l'implémentation du modèle, où je devais stocker la liste
des livres pour chaque utilisateur.
Après avoir configuré le modèle, j'ai développé le contrôleur sous forme de
servlet. Cependant, un problème est survenu lorsque les utilisateurs ajoutaient
plusieurs livres, car seule la dernière entrée était affichée sans avoir de base de
données pour stocker les livres de manière persistante.
Pour résoudre cette problématique, j'ai opté pour l'utilisation des sessions.
Celles-ci me permettent de sauvegarder temporairement les livres pour chaque
utilisateur, assurant ainsi la disponibilité des livres ajoutés tout au long de la
session. J'ai adapté mon code pour exploiter les sessions, intégrant une méthode
permettant d'ajouter les livres à la session de l'utilisateur.
Cette approche garantit la conservation d'une liste distincte de livres pour
chaque utilisateur, assurant ainsi l'accessibilité et la persistance des livres ajoutés
pendant toute la durée de sa session. Le code a été implémenté dans la méthode
doPost, en cohérence avec l'utilisation de la méthode POST pour l'envoi des
données via le formulaire associé.
protected void doPost(HttpServletRequest request, HttpServletResponse response) throws
ServletException, IOException Il s'agit de la méthode appelée lorsque la Servlet reçoit une requête
HTTP POST.
int idLivre = [Link]([Link]("idLivre")); La servlet extrait le
paramètre idLivre de la requête et le convertit en entier.
int anne = [Link]([Link]("annee")); La servlet extrait le
paramètre annee (année) de la requête et le convertit en entier.
String auteur = [Link]("auteur"); La servlet extrait le paramètre auteur de la requête
en tant que chaîne de caractères.
String titre = [Link]("titre"); La servlet extrait le paramètre titre de la requête en tant
que chaîne de caractères.
String genre = [Link]("genre"); La servlet extrait le paramètre genre de la requête en
tant que chaîne de caractères.
HttpSession session = [Link](); La servlet obtient l'objet de session actuel de l'utilisateur,
ce qui permet de stocker et de récupérer des données spécifiques à l'interaction de l'utilisateur avec
l'application web.
modelBiblio model = (modelBiblio<modelBiblio>) [Link]("model"); La servlet récupère
l'objet modelBiblio de la session, qui semble être une classe personnalisée utilisée pour gérer les
données de l'application.
if (model == null) { model = new modelBiblio(); [Link]("model", model); } Si
l'objet modelBiblio n'existe pas dans la session, la servlet en crée un nouveau et le stocke dans la
session.
Livre livrel= new Livre(idLivre, titre, auteur, anne, genre); La servlet crée un nouvel objet Livre avec
les paramètres fournis.
List<Livre> listeLivre = [Link](); La servlet récupère la liste des livres à partir de
l'objet modelBiblio.
if (listeLivre == null) { listeLivre = new ArrayList<>(); } Si la liste des livres est nulle, la servlet l'initialise
en tant qu'ArrayList vide.
[Link](livrel); La servlet ajoute le nouveau livre à la liste des livres.
int resultat = [Link](); La servlet définit la variable resultat à la taille de la liste des livres.
[Link](resultat); La servlet met à jour l'objet modelBiblio avec la nouvelle taille de la
liste des livres.
[Link](listeLivre); La servlet met à jour l'objet modelBiblio avec la nouvelle liste des livres.
[Link]("model", model); La servlet stocke l'objet modelBiblio mis à jour dans la session.
[Link]("[Link]").forward(request, response); La servlet transmet les
objets request et response à la page [Link], qui est une JSP (JavaServer Page) compilée et
exécutée en tant que servlet, générant le HTML à envoyer au client.
Ce code est une combinaison de HTML et de Java dans une JSP (JavaServer Page) qui
représente une interface utilisateur pour une bibliothèque. Voici une explication détaillée :
1. <div class="container"> : Cette balise HTML définit un conteneur pour organiser le contenu
de la page.
2. <form action="biblioServlet" method="post"> : Cette balise HTML définit un formulaire
qui sera soumis au servlet biblioServlet en utilisant la méthode HTTP POST.
3. Les différents <label> et <input> : Ces balises HTML créent des étiquettes et des champs de
saisie pour entrer les informations d'un nouveau livre (id, titre, auteur, année de publication et
genre).
4. <input type="submit" value="Ajouter Livre"> : Ce bouton HTML soumet le formulaire
pour envoyer les données du livre au servlet biblioServlet.
5. <h2>Livres ajoutés : </h2> : Cette balise HTML définit un titre pour l'affichage des livres
ajoutés.
6. [Link] model = ([Link]<modelBiblio>)
[Link]("model"); : Cette ligne de code Java récupère l'objet modelBiblio de
l'attribut de session nommé "model".
7. <p> le nombre des livres est <%= model != null ? [Link](): 0 %> </p> :
Ce code Java utilise une expression JSP pour afficher le nombre total de livres dans la
bibliothèque, en utilisant la méthode getSommeLivre() de l'objet modelBiblio.
En résumé, ce code permet à l'utilisateur d'entrer des informations sur un nouveau livre à ajouter
à la bibliothèque, puis affiche le nombre total de livres dans la bibliothèque. Le formulaire
soumet les données du livre au servlet biblioServlet pour traitement et enregistrement dans une
session.
TP N2
Gestion d’une bibliothèque de Livre avec BD au lieu de Gestion des
Produits
Dans cette activité, nous nous pencherons sur le développement d'un système de gestion de
produits qui offrira aux utilisateurs diverses fonctionnalités. Ces fonctionnalités incluent la
possibilité de rechercher des produits en utilisant des mots-clés, ainsi que d'ajouter, de
supprimer et de modifier des produits dans le système.
Pour garantir une conception robuste et modulaire, nous allons mettre en œuvre la couche DAO
(Data Access Object). Cette couche joue un rôle crucial en séparant la logique métier de la
logique d'accès aux données. Concrètement, cela signifie que les classes DAO seront
responsables de la manipulation des données dans la base de données. Ainsi, les autres
composants de l'application pourront se concentrer exclusivement sur la logique métier sans
avoir à se soucier des détails de l'accès aux données.
1. Création de la base de donnée avec la tables PRODUITS
2. Création de la couche DAO :
Élaboration de la classe Produit, définissant les attributs ainsi que les méthodes
d'accès (setters et getters) pour les produits.
Conception de l'interface IProduit, englobant les signatures des méthodes pour
ajouter, afficher et supprimer des produits dans la base de données.
Réalisation de la classe ProduitDaoImpl, fournissant une implémentation des
méthodes de l'interface IProduit pour interagir avec la base de données.
Mise en place d'un singleton Connection qui assure la création et la gestion de la
connexion à la base de données, garantissant ainsi une unique connexion pour toute
l'application.
3. Création de la couche web :
Développement des fichiers JSP pour la présentation des pages web.
Création d'une servlet pour gérer les requêtes des utilisateurs et les diriger vers les
bonnes méthodes de la couche DAO.
4. L’exécution de l’application
o Commençant par la couche DAO :
La classe Produit (couche métier) : est une classe qui contient les attributs ainsi que
les getters et setters :
L'interface IProduitDao : Comprend les signatures des méthodes de notre
application
La méthode "save" : Ajoute un produit à la base de données.
La méthode "produitParMC" : Recherche un produit à partir d'un mot-clé.
La méthode "getProduit" : Renvoie un produit.
La méthode "update" : Permet de mettre à jour les attributs d'un produit.
La méthode "deleteProduit" : Supprime un produit de la base de données.
Le singleton Connection : permet d’établir la connexion à notre
base de donnée
La classe suit le modèle de conception Singleton, assurant qu'une seule instance de la connexion
est créée et partagée dans toute l'application.
Dans le bloc statique, la classe charge le pilote JDBC MySQL et établit une connexion à la base
de données "DB_CATAL" sur le serveur local, utilisant l'utilisateur "root" sans mot de passe.
Toute erreur survenue lors du chargement du pilote ou de l'établissement de la connexion est
capturée et imprimée.
La méthode statique getConnection() permet aux autres classes d'obtenir une référence à la
connexion établie, leur permettant d'effectuer des opérations sur la base de données sans avoir
à créer de nouvelles connexions à chaque fois.
ProduitDaoImp : cette classe implémente l’interface IProduitDao et
redéfinis les méthodes.
Ensuite la couche Web :
Le fichier JSP dédié à l'affichage des produits recherchés par
l'utilisateur :
Page [Link] :
Afin de garantir une cohérence visuelle et une réutilisation efficace du code, j'ai mis en place
un fichier nommé [Link]. Ce fichier englobe la partie de l'interface utilisateur qui se répète
sur toutes les pages de notre application, généralement située en haut de chaque page,
communément appelée l'en-tête ou header.
Le code de [Link] :
Le fichier JSP dédié à l’ajout d’un produit à la base de donnée :
Pour cette page, j'ai intégré la bibliothèque de balises JSTL (JavaServer Pages Standard Tag
Library). Cette ressource met à disposition un ensemble de balises personnalisées qui
simplifient le processus de création des pages JSP en offrant des fonctionnalités couramment
requises.
L'utilisation de la balise <c:forEach> au sein de la page, par exemple, permet de parcourir une
collection de données et de générer dynamiquement des éléments HTML. De la même manière,
d'autres balises telles que <c:if>, <c:choose>, <c:set>, et autres, proposent des fonctionnalités
de contrôle de flux, d'assignation de valeurs, et diverses opérations utiles directement dans les
pages JSP.
Le fichier JSP dédié à afficher les détails d’un produit après l’ajout
ou la mise à jour :
[Link] :
Le fichier JSP dédié à mettre à jour un produit:
[Link] :
Le fichier servlet ou le contrôleur de l’application:
Dans l'architecture de cette servlet, j'ai adopté une approche basée sur des conditions if et else
if afin de gérer efficacement les différentes requêtes entrantes. Cette méthode assure que chaque
requête est dirigée vers la fonctionnalité appropriée de l'application, garantissant ainsi une
expérience utilisateur homogène et intuitive.
Lorsqu'une requête est reçue, je commence par extraire le chemin de la requête en utilisant la
méthode getServletPath() de l'objet HttpServletRequest. Ensuite, j'utilise des instructions
conditionnelles pour déterminer l'action à effectuer en fonction du chemin de la requête.
Par exemple, si le chemin correspond à "/[Link]", je redirige l'utilisateur vers la page de
recherche de produits où il peut saisir un mot-clé pour trouver des produits. Si le chemin est
"/[Link]", je récupère le mot-clé de recherche et j'interroge la base de données pour obtenir
les produits correspondants. De manière similaire, les autres chemins sont gérés en fonction de
leur action respective, que ce soit l'affichage d'un formulaire de saisie de produit, la suppression
d'un produit existant ou la mise à jour des informations d'un produit.
En utilisant cette approche conditionnelle, je garantie une gestion modulaire et extensible des
requêtes HTTP, ce qui facilite l'intégration de nouvelles fonctionnalités à l'application. De plus,
cela offre une navigation fluide à l'utilisateur, lui permettant d'effectuer différentes actions avec
facilité et transparence.
L’exécution de l’application :
Afficher tous les produits (c-à-d le mot de passe doit être vide) :
Les produits qui se trouvent dans la base de données sont correctement affichés
après l'exécution de la requête.
Afficher les produits avec la désignation contient le mot clé ‘HP’:
Ajouter un produit à la base de donnée
Lorsqu’on clique sur « save » le produit s’enregistre automatiquement dans la base de donnée.
Mettre à jour le produit de ID=15 : changer la quantité de 30 à 100 et le prix le
rendre 8000 :
Supprimer le produit d’id=15 :
Conclusion :
En résumé, ce rapport a exploré deux travaux pratiques distincts dans le domaine du
développement d'applications web J2EE. Le premier TP s'est penché sur le calcul des
mensualités de prêts bancaires et la gestion des emprunts de livres, tandis que le deuxième
TP a mis l'accent sur la gestion complète d'une bibliothèque de livres. À travers ces projets,
nous avons appliqué avec rigueur les principes de l'architecture web JEE en adoptant le
modèle MVC, assurant ainsi une structure claire et une maintenabilité optimale. Nous avons
également exploré l'utilisation de l'API JDBC pour interagir efficacement avec des bases de
données relationnelles. Ces exercices ont constitué une opportunité enrichissante pour
renforcer nos compétences en développement web J2EE, tout en créant des applications
fonctionnelles adaptées à des besoins spécifiques.
