Atelier 1

ATELIER 1 : ▪ GET : pour récupérer le contenu d’un document ▪ POST: soumissionner des formulaires (envoyer la
requête, les données saisies par l’utilisateurs)
L’objectif de cet atelier est de créer la structure d’un projet web en respectant le pattern MVC tel que nous l’avions présenté
dans le premier chapitre par la spécification des trois couches suivantes
. • Couche DAO : pour la persistance de données
• Couche Métier : représente le métier de l’application
• Couche présentation qui regroupe les modèles, les vues, et les contrôleurs.
La création du model :
Nous allons créer notre première class Model qui représente l’entité Produit, chaque produit est caractérisé par son id, nom,
quantité et son prix unitaire
• Créer un constructeur empty et full-paramètres pour cette classe,
• Déclarer tous les attributs privés
• Créer les getters et setters pour tous les attributs • Créer un méthode to String.
*Couche Model :
Création de la couche DAO : Commencer par la création d’une interface qui définit la signature de la méthode qui
permet de récupérer un produit en le cherchant par son Id. Cette interface assure le contrat à respecter entre la couche DAO
et la couche métier :
*Couche DAO :
-Interface DAO
Classe DAO : Après il faut créer la classe Produit DAO qui représente une implémentation de l’interface précédente :
Création de la couche métier : Au niveau du package de la couche métier, créer une interface Java avec le nom
IProduitMetier (c'est le contrat entre la couche métier et la couche présentation). Dans cette interface déclarer la signature
d'une méthode qui renvoie un produit sur la base du id. Voir le code suivant :
*Couche Metier:
Interface Metier
import ma.ac.uir.model.Produit;
public interface IProduitMetier {
public Produit searchProduitById(int id);}
Classe Metier : Créer une implémentation ProduitMetier pour
l'interface IProduitMetier. Voir l'écran ci-dessous et noter la déclaration et l'instanciation de l'objet dao comme attribut de la
classe ProduitMetier. NB: Nous déclarons toujours en utilisant le contrat et nous instancions en utilisant l'implémentation.
Création de la couche présentation :

Créer une Servlet au niveau du package de la couche présentation. Si HttpServlet n'est pas reconnu dans le projet, noter que
l'api Servlet.jar est disponible dans le dossier d'installation de Tomcat, dans le répertoire common>lib:
Cliquer droit sur votre projet>properties>Java Built path Cliquer sur add Library> Server Runtime et cela pour reconnaitre
les jars du Tomcat.
Pour la création de votre Servlet, il faut respecter les points suivants :
• Création d'un objet de la couche métier ;
• Récupération de l’id à partir du formulaire
• Appel de la couche métier
• Mise à jour de la requête http
• Redirection vers une autre vue (prodRechRes.jsp) Création du formulaire de recherche « prodRech.jsp » dans un dossier
views à créer dans le dossier webapp
*Couche Presentataion
*Views: La vue pour la jsp : qui recherhce le produit par Id :
ProdRech: La vue pour la jsp : qui recherhce le produit par Id :
ProdRechRes: La vue qui affiche le résultat :

Adapter votre couche DAO pour rechercher le produit à partir de la base de données.
Utiliser JDBC pour l’implémentation de votre solution :
Exercice de fin de chapitre :

1) On va créer la servlet authentification
Sans oublier le singleton de connnexion puis on a creér une classe user contenant le prepared statement
**** string to string

Private static final long serial Version Uid =1L :fournir une version unique à la classe lors de la sérialisation des objets de cette classe .
*ATELIER 2 : Tp2 : pattern MVC et la couche DAO
Etape1 :Configuration de la connexion au serveur BD :Adapter le code de votre class singleton pour établir la connexion
avec la BD, il faut intégrer le driver de connexion dans votre projet pour remédier au problème àl’import de la classe
Connection. Attention qu’il faut utiliser la classe Connection issue de la bibliothèque « java.sql.Connection »
Remarque : Il faut intégrer le driver de connexion dans

votre projet pour remédier au problème à l’import de la
classe Connection. Attention qu’il faut utiliser la classe
Connection issue de la bibliothèque « java.sql.Connection
» Copier votre fichier jar dans le dossier lib de votre
projet Intégrer le jar dans le build path de votre projet.
Vous pouvez tester la connexion à la base de données

via le singleton en utilisant la classe suivante :
Etape2 : Creation de la base de données Démarrer votre

serveur BD MySQL et créer la base de données « tp2BD
»
TestDAO:
Etape 3 : Implémentation des méthodes CRUD (Produit) : Implémenter les fonctions nécessaires
pour la gestion de l’entité Produit. Pour ce faire, nous allons procéder par la modification de l’interface « IProduitDAO »
pour la déclaration de la signature des méthodes CRUD dans le contrat (interface) :
*Couche DAO : pour la persistance de données.

IProduitDao :
*ProduitDao: Donnez une implémentation de ces méthodes dans la classe « ProduitDAO.java »

GetProduitByID :
DeletProduit & UpdateProduit:
GetALLProduit
: Create or insert :
InsertProduit: GetAllProduit :
SaveProduit:
Commencer par la création d’une interface qui définit la

signature de la méthode qui permet de récupérer un produit en
le cherchant par son Id. Cette interface assure le contrat à
respecter entre la couche DAO et la couche métier :
*Couche Metier: Interface Produit: &class ProduitMetier
*Couche Presentation ProduitDeletServlet,ProduitListingServlet,ProduitServlet
Le 1 er exemple get produit by id :
Pour pouvoir récupérer le produit par id , on doit créer une jsp ( formulaire dans lequel on
cherche le produit par son id :
En suivant le pattern Mvc on a besoin d’une servlet

Le 2 eme exemple get all produits :
Le 3eme exemple c’est Delete :
ListePdt se trouve en haut
Le 4 eme exemple c’est modifier : Pour modifier un produit, on doit créer ModifServ :
Liste Pdt c’est la même Pour supprimer un produit, on doit créer :
Chapitre 3 : JSTL ET SESSION
3layerd architecture :
*Couche DAO
ClasseEtudiantDAO
package ma.ac.uir.dao;
import ma.ac.uir.model.Etudiant;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import com.mysql.jdbc.PreparedStatement;
public class EtudiantDAO implements IEtudiantDAO{
@Override
public Etudiant getEtudiantById(int id) {
Etudiant etdTemp = new Etudiant();
// recuperer l'objet de connexion
Connection conn = SingletonConnection.getConnection();
// executer un requete jdbc
try{
PreparedStatement ps = (PreparedStatement) conn.prepareStatement("select * from etudiant where id = " + id);
ResultSet rs = ps.executeQuery();
while(rs.next()) {
// fetching du result set
String nom = (String)rs.getString("nom") ;
int idp = rs.getInt("id");
float moyenne = rs.getInt("moyenne");
//init letudiant a modifier
etdTemp = new Etudiant(idp, nom, moyenne);}
System.out.println(etdTemp);
}catch (SQLException e){
e.printStackTrace();}
return etdTemp; }
@Override
public ArrayList<Etudiant> getEtudiantByName(String nom) {
return null;}
@Override
public Etudiant deleteEtudiant(int id) {
// TODO Auto-generated method stub
return null;}
@Override
public ArrayList<Etudiant> getEtudiants() {
// init ma liste
ArrayList<Etudiant> listEtd = new ArrayList<>();
PreparedStatement ps;
try {
ps = (PreparedStatement) conn.prepareStatement("select * from etudiant");
// creation d'un etudiant temporaire
Etudiant e = new Etudiant();
// charger la liste
while (rs.next()) {
e = new Etudiant();
String nom = (String) rs.getString("nom");
int id = rs.getInt("id");
float moyenne = rs.getInt("moyenne")
e.setIdEtudiant(id);
e.setNomEtudiant(nom);
e.setMoyenneEtudiant(moyenne);
// ajouter dans la liste des resultat
listEtd.add(e);}
} catch (SQLException e) {
System.out.println(listEtd.size());
return listEtd;}}
*InterfaceEtudiantDAO
public interface IEtudiantDAO {
// méthode abstraite
public Etudiant getEtudiantById(int id);
public ArrayList<Etudiant> getEtudiantByName(String nom);
public Etudiant deleteEtudiant(int id);
public ArrayList<Etudiant> getEtudiants();}
Singleton de connexion : le même
*Couche metier
package ma.ac.uir.metier;
import ma.ac.uir.dao.EtudiantDAO;
import ma.ac.uir.dao.IEtudiantDAO;
public class EtudiantMetier implements IEtudiantMetier{
IEtudiantDAO dao = new EtudiantDAO();
@Override
public Etudiant rechEtdById(int id) {
// méthode délégué
return dao.getEtudiantById(id);}
@Override
public ArrayList<Etudiant> getAllEtudiant() {
return dao.getEtudiants();}}
*InterfaceEtudiantMetier
public interface IEtudiantMetier {
public Etudiant rechEtdById(int id);
public ArrayList<Etudiant> getAllEtudiant();}
*Couche model :
package ma.ac.uir.model;
public class Etudiant {
private int idEtudiant;
private String nomEtudiant;
private float moyenneEtudiant;
// constructeur vide
public Etudiant() {}
// constructor full-params
public Etudiant(int idEtudiant, String nomEtudiant, float moyenneEtudiant) {
this.idEtudiant = idEtudiant;
this.nomEtudiant = nomEtudiant;
this.moyenneEtudiant = moyenneEtudiant;}
public int getIdEtudiant() {
return idEtudiant;}
public void setIdEtudiant(int idEtudiant) {
this.idEtudiant = idEtudiant;}
public String getNomEtudiant() {
return nomEtudiant;}
public void setNomEtudiant(String nomEtudiant) {
this.nomEtudiant = nomEtudiant;}
public float getMoyenneEtudiant() {
return moyenneEtudiant;}
public void setMoyenneEtudiant(float moyenneEtudiant) {
this.moyenneEtudiant = moyenneEtudiant;}
@Override
public String toString() {
return "Etudiant [idEtudiant=" + idEtudiant + ", nomEtudiant=" + nomEtudiant + ", moyenneEtudiant="
+ moyenneEtudiant + "]";}}
*Classe User :
public class User {}
*Couche Presentation
package ma.ac.uir.presentation;
import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import ma.ac.uir.metier.EtudiantMetier;
import ma.ac.uir.metier.IEtudiantMetier;
* Servlet implementation class RechEtudiantServelet*/
@WebServlet("/RechEtudiantServlet")
public class RechEtudiantServlet extends HttpServlet {
private static final long serialVersionUID = 1L;
IEtudiantMetier metier = new EtudiantMetier();
protected void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
// getting params
int id = Integer.parseInt(request.getParameter("idEtudiant"));
// call the service couche metier
Etudiant modelEtd = metier.rechEtdById(id);
// setting attributes to submit the model
request.setAttribute("myStudent", modelEtd);
// forward
request.getRequestDispatcher("/views/resultRechId.jsp").forward(request, response);}}
*ServletList:
import ma.ac.uir.metier.EtudiantMetier;
import ma.ac.uir.metier.IEtudiantMetier;
/** * Servlet implementation class ServletListe */
@WebServlet("/ServletListe")
public class ServletListe extends HttpServlet {
IEtudiantMetier metier = new EtudiantMetier();
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
ArrayList<Etudiant> lEtd = metier.getAllEtudiant();
request.setAttribute("listeEtd", lEtd);
request.getRequestDispatcher("/views/listeEtd.jsp").forward(request, response);}}
Views:
Etudiant.jsp
<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
pageEncoding="ISO-8859-1"%>
<%@ taglib uri="http://java.sun.com/jstl/core" prefix="c" %>
<%@ page import="java.util.ArrayList" %>
<%@ page import="ma.ac.uir.model.Etudiant" %>
<%ArrayList<Etudiant> m = null;
if(request.getAttribute("listeEtd") != null ){
m = (ArrayList<Etudiant>)request.getAttribute("listeEtd");}%>
<!DOCTYPE html>
<html>
<head>
<meta charset="ISO-8859-1">
<title>La liste des étudiants </title>
</head>
<body>
<table width=300px border=1>
<tr>
<td> id </td>
<td> nom </td>
<td> moyenne </td>
<td> Modification</td>
<td> Suppression</td>
</tr>
<%ArrayList<Etudiant> l = m;
Etudiant e = new Etudiant();
for (int i = 0; i < l.size(); i++){
e = l.get(i);%>
<tr>
<td> <%= e.getIdEtudiant() %></td>
<td> <%= e.getNomEtudiant() %></td>
<td> <%= e.getMoyenneEtudiant() %></td>
<td> <a href="<%= "./modifEtd?id="+e.getIdEtudiant() %>" > Modif </a> </td>
<td> <a href="<%= "./supEtd?id="+e.getIdEtudiant() %>" > Supp </a> </td>
</tr>
<%}%>
</table>
</body>
</html>
*EtudiantJSTL.jsp
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<!DOCTYPE html>
<html>
<head>
<title>La liste des étudiants </title>
</head>
<body>
<tr>
<td> id </td>
<td> nom </td>
<td> moyenne </td>
</tr>
<c:forEach items="${ listeEtd }" var="e" varStatus="status">
<tr>
<td> <c:out value="${ e.getIdEtudiant() }" /> </td>
<td> <c:out value="${ e.getNomEtudiant() }" /> </td>
<td> <c:out value="${ e.getMoyenneEtudiant() }" /> </td>
<td> <a href="${pageContext.request.contextPath}/modifServ?id=<c:out value="${ e.getIdEtudiant() }" /> " > Modif</a>
</td>
<td> Supp</td>
</tr>
</c:forEach>
</table>
le nom ${sessionScope.client.getNomEtudiant()}
</body>
</html>
*Home.jsp:
<!DOCTYPE html>
<html>
<head>
<title>Recherche des étudiants </title>
</head>
<body>
<h1> Formulaire de recherche </h1>
<form method="post" action="${pageContext.request.contextPath}/RechEtudiantServlet">
<table border=1>
<tr>
<td> ID Etudiant </td>
<td> <input type="text" name="idEtudiant" /> </td>
</tr>
<tr>
<td colspan="2" align="center"> <button type="submit"> Rechercher </button></td>
</tr>
</table>
</form>
</body>
</html>
*listETD.jsp
<!DOCTYPE html>
<html>
<head>
<title>Insert title here</title>
</head>
<body>
<tr>
<td> id </td>
<td> nom </td>
<td> moyenne </td>
</tr>
<c:forEach items="${ listeEtd }" var="e" varStatus="status">
tr>
<td> <c:out value="${ e.getIdEtudiant() }" /> </td>
<td> <c:out value="${ e.getNomEtudiant() }" /> </td>
<td> <c:out value="${ e.getMoyenneEtudiant() }" /> </td>
<td> <a href="${pageContext.request.contextPath}/modifServ?id=<c:out value="${ e.getIdEtudiant() }" /> " > Modif</a>
</td>
<td> Supp</td>
</tr></c:forEach>
</table>
</body>
</html>
ResultRechId.jsp
<%@ taglib uri="http://java.sun.com/jstl/core" prefix="c" %>
<%@ page import="ma.ac.uir.model.*" %>
<% // test model initialization
Etudiant resultat = null;
if(request.getAttribute("myStudent") != null)
resultat = (Etudiant)request.getAttribute("myStudent");
%>
<!DOCTYPE html>
<html>
<head>
<title>Resultat de la recherche </title>
</head>
<body>
Les informations de l'étudiant recherché <%= resultat%>
</body>
</html>
EXEMPLE : SESSION
package serv
import javax.servlet.http.HttpSession;
/*** Servlet implementation class Authentification*/
@WebServlet("/Authentification")
public class Authentification extends HttpServlet {
/*** @see HttpServlet#HttpServlet()*/
public Authentification() {
super();
// TODO Auto-generated constructor stub}
/*** @see HttpServlet#doGet(HttpServletRequest request, HttpServletResponse response)*/
// TODO Auto-generated method stub}
/*** @see HttpServlet#doPost(HttpServletRequest request, HttpServletResponse response)*/
protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
// TODO Auto-generated method stub
String login=request.getParameter("login");
String password=request.getParameter("password");
int id=User.authentification(login, password);
HttpSession session =request.getSession(); //<<<<<<<<<<===== init de la session/*
session.setAttribute("loginUser", login);
session.setAttribute("PasswordUser", password);
session.setAttribute("UserId", id);*/
if(id!=-1){
request.setAttribute("msg", "operation reussie");
session.setAttribute("loginUser", login);
session.setAttribute("PasswordUser", password);
session.setAttribute("UserId", id);
}else{
request.setAttribute("msg", "probleme d'authentification");}
request.getRequestDispatcher("home.jsp").forward(request,response);}}
Classe USER:
package serv;
import java.sql.PreparedStatement;
//import utilitaire.*;
public class User {
private int id;
private String login, password;
public User() {
super();
// TODO Auto-generated constructor stub}
public User(int id, String login, String password) {
super();
this.id = id;
this.login = login;
this.password = password;}
public int getId() {
return id;}
public void setId(int id) {
this.id = id;}
public String getLogin() {
return login;}
public void setLogin(String login) {
this.login = login;}
public String getPassword() {
return password;}
public void setPassword(String password) {
this.password = password;}
@Override
public String toString() {
return "User [id=" + id + ", login=" + login + ", password=" + password+ "]";}
public static int authentification(String login, String password){
User u1 = new User();
int idRes = -1;
try{
PreparedStatement ps = (PreparedStatement) conn.prepareStatement("select * from user where login = ? and password = ?");
ps.setString(1, login);
ps.setString(2, password);
if(rs.next()){
// creation de l'utilisateur
int id = rs.getInt("id");
String log = (String)rs.getString("login") ;
String pwd = rs.getString("password");
u1 = new User(id, log, pwd);
idRes = id;}
}catch (SQLException e){
return idRes;}}
*Singleton de connection
Authentification.jsp
<%@ page language="java" contentType="text/html; charset=ISO-8859-1" pageEncoding="ISO-8859-1"%>
<!DOCTYPE html>
<html>
<head>
</head>
<body>
<form method="post" action="${pageContext.request.contextPath}/Authentification">
<table border=1>
<tr>
<td> Login </td>
<td> <input type="text" name="login" /> </td>
</tr>
<tr>
<td> Password </td>
<td> <input type="text" name="password" /> </td>
</tr>
<tr>
<td colspan="2" align="center"> <button type="submit"> Se connecter </button></td>
</tr>
</table>
</form>
</body>
</html>
Home.jsp
<%if(session.getAttribute("UserId")==null){
System.out.println("vous n'avez pas le droit");
response.sendRedirect("./authentification.jsp");}
/*if(session.getAttribute("loginUser")==null){
System.out.println("vous n'aver pas le droit");
response.sendRedirect("./authentification.jsp");}
if(session.getAttribute("PasswordUser")==null){
System.out.println("vous n'aver pas le droit");
response.sendRedirect("./authentification.jsp");}*/%>
<!DOCTYPE html >
<html>
<head>
<meta charset=ISO-8859-1">
</head>
<body>
<h1>home</h1>
<%String msg=(String)request.getAttribute("msg");%>
<h3><%=msg %></h3>
</br>
Login=<%=session.getAttribute("loginUser") %>
</br>
password=<%=session.getAttribute("PasswordUser") %>
</br>
id=<%=session.getAttribute("UserId") %>
</body></html>
Exercice de cc:
Entité Adherent.java
public class Adherent {
private int id;
private String nom;
private String email;
private int idClub;
// Les getters et setters}
Entité Club.java
public class Club {
private int idClub;
private String nomClub;
private String description;
// Les getters et setters}
Servlet SearchServlet.java :
import java.util.List;
@WebServlet("/search")
public class SearchServlet extends HttpServlet {
protected void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
int clubId = Integer.parseInt(request.getParameter("clubId"));
// Utilisez une classe de service ou une classe DAO pour effectuer la recherche
List<Adherent> adherents = AdherentDAO.getAdherentsByClub(clubId);
request.setAttribute("adherents", adherents);
request.getRequestDispatcher("result.jsp").forward(request, response);}}
Classe DAO AdherentDAO.java :
import java.util.List;
public class AdherentDAO {
public static List<Adherent> getAdherentsByClub(int clubId) {
List<Adherent> adherents = new ArrayList<>();
try (Connection connection = DBConnection.getConnection();
PreparedStatement preparedStatement = connection.prepareStatement("SELECT * FROM tbl_adherent WHERE idClub
= ?")) {
preparedStatement.setInt(1, clubId);
try (ResultSet resultSet = preparedStatement.executeQuery()) {
while (resultSet.next()) {
Adherent adherent = new Adherent();
adherent.setId(resultSet.getInt("id"));
adherent.setNom(resultSet.getString("nom"));
adherent.setEmail(resultSet.getString("email"));
adherent.setIdClub(resultSet.getInt("idClub"));
adherents.add(adherent);}}
e.printStackTrace(); // Gérer les exceptions de manière appropriée dans une application réelle}
return adherents;}}
JSP result.jsp :
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Search Result</title>
</head>
<body>
<h2>Search Result</h2>
<table border="1">
<tr>
<th>ID</th>
<th>Nom</th>
<th>Email</th>
<th>Club</th>
</tr>
<c:forEach var="adherent" items="${adherents}">
<tr>
<td>${adherent.id}</td>
<td>${adherent.nom}</td>
<td>${adherent.email}</td>
<td>${adherent.idClub}</td>
</tr>
</c:forEach>
</table>
</body>
</html>
Etape4 :Nous souhaitons intégrer une classe pour
représenter les catégories de produits. Une catégorie est
caractérisée par son « ID » et « nomCategorie ». Les catégories sont enregistrées dans la table catégorie dans la base de
données. 1. Ajouter la classe Categorie 2. Adapter la table des produits pour faire la liaison avec la table catégorie (clé
étrangère). 3. Implémenter une solution pour faire le filtrage par catégorie de produits. (implémenter )
CategorieDAO :Classe :
import java.util.LinkedList;
import ma.ac.uir.model.*;
public class CategorieDao implements ICategorieDAO {
@Override
public LinkedList<categorie> getAllCategorie() {
LinkedList<categorie> listCat = new LinkedList<>();
PreparedStatement ps;
try {
ps = (PreparedStatement) conn.prepareStatement("select * from categorie");
categorie cat = new categorie();
while (rs.next()) {
cat = new categorie();
int idCateg = rs.getInt("idCateg");
String nomCategorie = (String) rs.getString("nomCategorie");
cat.setIdCateg(idCateg);
cat.setNomCategorie(nomCategorie);
listCat.add(cat);}} catch (SQLException e) {
System.out.println(listCat);
return listCat;}
@Override
public LinkedList<Produit> getAllProduitbyIdcateg(int idCateg) {
LinkedList<Produit> lp = new LinkedList<Produit>();
try {
PreparedStatement ps = (PreparedStatement) conn.prepareStatement("SELECT * FROM produit WHERE idCateg ="
+idCateg);
Produit produit = new Produit();
if (rs.next()) {
produit = new Produit();
String nom = rs.getString("nom");
int idp = rs.getInt("id");
int quantite = rs.getInt("quantite");
float prixUnit = rs.getInt("prixUnit");
produit = new Produit(idp,nom,quantite,prixUnit);
lp.add(produit);}
System.out.println(lp);
return lp;}}
interface :
public interface ICategorieDAO {
public LinkedList<categorie> getAllCategorie();
public LinkedList<Produit> getAllProduitbyIdcateg(int idCateg);}
Categorie Metier:
import ma.ac.uir.dao.*;
import ma.ac.uir.model.categorie;
public class CategorieMetier implements ICategorieMetier {
ICategorieDAO dao = new CategorieDao();
@Override
public LinkedList<categorie> getAllCategorie() {
return dao.getAllCategorie();}
@Override
public LinkedList<Produit> getAllProduitbyIdcateg(int idCateg) {
return dao.getAllProduitbyIdcateg(idCateg);}}
interface Categorie;
public interface ICategorieMetier {
public LinkedList<categorie> getAllCategorie();
public LinkedList<Produit> getAllProduitbyIdcateg(int idCateg);}
1. Ajouter la classe Categorie
Categorie Model:
public class categorie {
private int idCateg;
private String nomCategorie;
public categorie() {
super();}
public categorie(int idCateg, String nomCategorie) {
super();
this.idCateg = idCateg;
this.nomCategorie = nomCategorie;}
public int getIdCateg() {
return idCateg;}
public void setIdCateg(int idCateg) {
this.idCateg = idCateg;}
public String getNomCategorie() {
return nomCategorie;}
public void setNomCategorie(String nomCategorie) {
this.nomCategorie = nomCategorie;}}
FiltrageProduitServlet:
import ma.ac.uir.metier.ICategorieMetier;
import ma.ac.uir.metier.CategorieMetier;
/** * Servlet implementation class filtrageProdServlet */
@WebServlet("/filtrageProdServlet")
public class filtrageProdServlet extends HttpServlet {
ICategorieMetier metier = new CategorieMetier();
int IdCateg=Integer.parseInt(request.getParameter("filiere"));
LinkedList<Produit> lp = metier.getAllProduitbyIdcateg(IdCateg);
request.setAttribute("ListeProd", lp);
System.out.println("from controller model size == " +lp.size());
request.getRequestDispatcher("/views/listeproduitcateg.jsp").forward(request, response);}}
ListeServletModifie:
import ma.ac.uir.metier.*;
@WebServlet("/ListeServletModifie")
public class ListeServletModifie extends HttpServlet {
IProduitMetier metier = new ProduitMetier();
public ListeServletModifie() {
super(); }
LinkedList<Produit> lProd = metier.getAllProduit();
request.setAttribute("listePdt", lProd);
request.getRequestDispatcher("/views/listePdt.jsp").forward(request, response);}}
ModifServ :
package ma.ac.uir.presentation ;
@WebServlet("/ModifServ")
public class ModifServ extends HttpServlet {
public ModifServ() {
super(); }
int id = Integer.parseInt(request.getParameter("id"));
Produit p = metier.getProduitById(id);
request.setAttribute("produit", p);
request.getRequestDispatcher("/views/updateProduct.jsp").forward(request,response);}}
produitServlet:package ma.ac.uir.presentation;
import ma.ac.uir.metier.IProduitMetier;
import ma.ac.uir.metier.ProduitMetier;
/*** Servlet implementation class ProduitServlet*/
@WebServlet("/ProduitServlet")
public class ProduitServlet extends HttpServlet {
int id = Integer.parseInt(request.getParameter("idprod"));
Produit model = metier.getProduitById(id);
request.setAttribute("leproduit", model);
request.getRequestDispatcher("/views/ProdRechRes.jsp").forward(request, response);}}
ServletCategList:
@WebServlet("/ServletCategList")
public class ServletCategList extends HttpServlet {
ICategorieMetier metier = new CategorieMetier();protected void doGet(HttpServletRequest request, HttpServletResponse
response) throws ServletException, IOException {
LinkedList<categorie> Lcat = metier.getAllCategorie();
request.setAttribute("listecat", Lcat);
request.getRequestDispatcher("/views/listecat.jsp").forward(request, response);}}
ServletListe:
@WebServlet("/ServletListe")
public class ServletListe extends HttpServlet {
LinkedList<Produit> LPdt = metier.getAllProduit();
request.setAttribute("listePdt", LPdt);
request.getRequestDispatcher("/views/listePdt.jsp").forward(request, response);}}
SuppServlet:
@WebServlet("/SuppServ")
public class SuppServ extends HttpServlet {
metier.deleteProduit(id);
LinkedList<Produit> Lpdt = metier.getAllProduit() ;
request.setAttribute("listePdt", Lpdt);
request.getRequestDispatcher("/views/listePdt.jsp").forward(request, response); } }
UpdateServ:
@WebServlet("/updateServ")
public class updateServ extends HttpServlet {
public updateServ() {
super();}
//inside the getParameter() we put the values of the name in the form
String name = request.getParameter("nom");
int quantity = Integer.parseInt(request.getParameter("quantite"));
float price = Float.parseFloat(request.getParameter("prixUnit"));
Produit updatedProduct = new Produit();
updatedProduct.setId(id);
updatedProduct.setNom(name);
updatedProduct.setQuantite(quantity);
updatedProduct.setPrixUnit(price);
boolean updated= metier.updateProduit(updatedProduct);
if(updated) {
request.setAttribute("ListProd", updatedProduct);
request.getRequestDispatcher("/ListeServletModifie").forward(request,response);}
else {
String errorMessage = "Erreur de modification.";
// Set the error message as a request attribute
request.setAttribute("errorMessage", errorMessage);
request.getRequestDispatcher("/views/updateProduct.jsp").forward(request, response);}}}
ListCat:
<!DOCTYPE html>
<html>
<head>
</head>
<body>
<form method="post" action="${pageContext.request.contextPath}/filtrageProdServlet">
choix de categorie
<select name="filiere">
<option> choisir une categorier </option>
<c:forEach items="${ listecat }" var="c" varStatus="status">
<option value="<c:out value="${ c.getIdCateg() }" /> ">
<c:out value="${ c.getNomCategorie() }" />
</option>
</c:forEach>
</select>
<button type="submit">filtrer</button>
</form>
</table>
</body>
</html>
Listpdt:
<%@ page import="java.util.LinkedList" %>
<%@ page import="ma.ac.uir.model.Produit" %>
<%
LinkedList<Produit> m = null;
if(request.getAttribute("listePdt") != null){
m = (LinkedList<Produit>)request.getAttribute("listePdt");}
%>
<!DOCTYPE html>
<html>
<head>
</head>
<body>
<tr>
<td> id </td>
<td> nom </td>
<td> quantite </td>
<td> prixUnit </td>
</tr>
<%
LinkedList<Produit> l = m;
Produit p = new Produit();
for(int i = 0; i < l.size(); i++){
p = l.get(i);%>
<tr>
<td> <%= p.getId() %> </td>
<td> <%= p.getNom() %> </td>
<td> <%= p.getQuantite() %> </td>
<td> <%= p.getPrixUnit() %> </td>
<td> <a href="<%= "./ModifServ?id="+p.getId() %>" > Modif</a> </td>
<td> <a href="<%="./SuppServ?id="+p.getId() %>" > Supp</a> </td>
</tr>
<%}%>
</table>
</body>
</html>
ListProduitCteg:
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8" %>
<%@ page import="java.util.LinkedList" %>
<%@ page import="ma.ac.uir.model.Produit" %>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Liste des Produits par Catégorie</title>
</head>
<body>
<h1>liste des produits par catégorie</h1>
<table border="1">
<tr>
<th>ID du produit</th>
<th>Nom du produit</th>
<th>Quantité du produit</th>
<th>Prix du produit</th>
</tr>
<c:forEach var="lProd" items="${ListeProd}" varStatus="status">
<tr>
<td> <c:out value="${ lProd.getId() }" /> </td>
<td> <c:out value="${ lProd.getName() }" /> </td>
<td> <c:out value="${ lProd.getQuantity() }" /> </td>
<td> <c:out value="${ lProd.getPrixUnit() }" /> </td>
</tr>
</c:forEach>
</table>
</body>
</html>
ProdRech:
<!DOCTYPE html>
<html>
<head>
</head>
<body>
<h2> Recherche produit par Id</h2>
<form method="post" action="${pageContext.request.contextPath}/ProduitServlet">
entrez l'id : <input type="text" name="idprod"/><br />
<input type="submit" value="Rechercher"/>
</form>
</body>
</html>
ProdRechRes :
<%@ page import="ma.ac.uir.model.*" %>
<%
Produit resultat = new Produit();
if(request.getAttribute("leproduit") != null)
resultat = (Produit)request.getAttribute("leproduit") %>
<!DOCTYPE html>
<html>
<head>
</head>
<body>
Les infos <%= resultat %>
</body>
</html>
UpdateProduct :
<!DOCTYPE html>
<html>
<head>
</head>
<body>
<h2>Modifier votre produit</h2>
<form action="${pageContext.request.contextPath}/updateServ" method="post">

<label for="id">Product ID:</label>
<input type="number" name="id" value="${produit.id}">
<label for="nom">Product Name:</label>
<input type="text" name="nom" value="${produit.nom}">
<label for="quantite">Quantity:</label>
<input type="text" name="quantite" value="${produit.quantite}">
<label for="prixUnit">Unit Price:</label>
<input type="text" name="prixUnit" value="${produit.prixUnit}">
<input type="submit" value="Update Product">
</form>
</body>
</html
Modèle MVC (Modèle-Vue-Contrôleur) :
Définition : Le modèle MVC est un pattern architectural qui divise une application en trois composants principaux : le
Modèle (représentation des données et de la logique métier), la Vue (interface utilisateur) et le Contrôleur (gestion des
événements et de la logique de l'application).
Fonctionnalité : Il facilite la séparation des préoccupations, améliorant ainsi la maintenabilité et la flexibilité du code.
Couches DAO (Data Access Object) :
Définition : Les objets d'accès aux données (DAO) sont des classes qui fournissent une interface standard pour interagir
avec une source de données, comme une base de données.
Fonctionnalité : Les DAO isolent la logique d'accès aux données du reste de l'application, permettant ainsi de changer
facilement la source de données sans modifier le reste du code.
Mapping :
Définition : Le mapping fait référence à la correspondance entre les objets d'une application et les enregistrements dans une
base de données relationnelle.
Fonctionnalité : Il permet de transférer les données entre la représentation objet dans le code de l'application et la structure
tabulaire dans la base de données.
JDBC (Java Database Connectivity) :
Définition : JDBC est une API Java permettant de se connecter et d'interagir avec des bases de données relationnelles.
Fonctionnalité : JDBC fournit des méthodes pour exécuter des requêtes SQL, récupérer et mettre à jour des données dans la
base de données depuis une application Java.
Session :
Définition : Dans le contexte des applications web, une session représente une interaction continue entre un utilisateur et une
application sur une période de temps.
Fonctionnalité : La session permet de stocker des informations spécifiques à un utilisateur entre différentes requêtes HTTP,
ce qui facilite la gestion de l'état et la personnalisation de l'expérience utilisateur.
JSTL (JavaServer Pages Standard Tag Library) :
Définition : JSTL est une bibliothèque de balises qui étend la fonctionnalité des pages JSP en fournissant des tags
réutilisables pour effectuer des opérations courantes.
Fonctionnalité : JSTL simplifie le développement de pages JSP en fournissant des tags pour la logique conditionnelle, les
boucles, l'accès aux bases de données, et d'autres opérations, réduisant ainsi la nécessité d'inclure du code Java directement
dans les pages JSP.
Servlets :
Définition : Les servlets sont des classes Java qui étendent les fonctionnalités des serveurs web pour générer des réponses
dynamiques aux requêtes HTTP.
Fonctionnalité : Ils sont utilisés pour gérer la logique côté serveur dans une application web Java.
JSP (JavaServer Pages) :
Définition : Les JSP sont des pages HTML avec des balises spéciales qui encapsulent de la logique Java.
Fonctionnalité : Ils permettent la création de pages web dynamiques en intégrant du code Java directement dans le HTML.
Frameworks Web :
Exemple : Spring MVC, JavaServer Faces (JSF), Struts.
Fonctionnalité : Ces frameworks facilitent le développement d'applications web en fournissant des structures, des modèles et
des composants réutilisables.
Spring Framework :
Modules : Spring Core, Spring MVC, Spring Boot, Spring Data.
Fonctionnalité : Spring simplifie le développement Java en fournissant une infrastructure complète pour gérer la
configuration, la sécurité, l'accès aux données, etc.
RESTful Web Services :
Définition : Architectural style permettant la communication entre systèmes via des opérations HTTP standard.
Fonctionnalité : Utilisé pour construire des services web simples, évolutifs et interopérables.
Annotations Java :
Exemples : @RequestMapping, @Autowired (Spring), @WebServlet (Servlets).
Fonctionnalité : Les annotations simplifient la configuration en remplaçant la configuration XML traditionnelle.
ORM (Object-Relational Mapping) :
Exemple : Hibernate.
Fonctionnalité : Simplifie l'interaction avec les bases de données relationnelles en permettant de manipuler des objets Java
plutôt que des requêtes SQL directes.
Sécurité Web :
Concepts : Authentification, autorisation, gestion des sessions.
Fonctionnalité : Protéger les applications web contre les menaces de sécurité.
Gestionnaire de Dépendances :
Exemple : Apache Maven, Gradle.
Fonctionnalité : Facilite la gestion des dépendances, la construction, et le déploiement de projets Java.
Conteneurs Web :
Exemple : Apache Tomcat, Jetty.
Fonctionnalité : Fournit un environnement d'exécution pour les applications web Java.
.

Atelier 1

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

Atelier 1

Transféré par

Droits d'auteur :

Formats disponibles

ATELIER 1 : ▪ GET : pour récupérer le contenu d’un document ▪ POST: soumissionner des formulaires (envoyer la

requête, les données saisies par l’utilisateurs)

Création de la couche présentation :

*Views: La vue pour la jsp : qui recherhce le produit par Id :

ProdRech: La vue pour la jsp : qui recherhce le produit par Id :

ProdRechRes: La vue qui affiche le résultat :

Exercice de fin de chapitre :

**** string to string

Remarque : Il faut intégrer le driver de connexion dans

Vous pouvez tester la connexion à la base de données

Etape2 : Creation de la base de données Démarrer votre

*Couche DAO : pour la persistance de données.

*ProduitDao: Donnez une implémentation de ces méthodes dans la classe « ProduitDAO.java »

Commencer par la création d’une interface qui définit la

En suivant le pattern Mvc on a besoin d’une servlet

ListePdt se trouve en haut

Vous aimerez peut-être aussi