Résumé Structuré du Module Java EE :
Développement d'Applications d'Entreprise
Ce module est une exploration complète de la plateforme Java EE, conçue pour le développement
d'applications d'entreprise robustes et évolutives. Il couvre l'ensemble du processus, depuis les
fondations de la communication web jusqu'aux architectures modernes et aux frameworks de
persistance.
I. Introduction à la Plateforme Java EE
La Plateforme Java EE (Java Platform, Enterprise Edition) est un ensemble de
spécifications et d'APIs basées sur Java, destinées à la création d'applications d'entreprise
distribuées, performantes et sécurisées. Elle est privilégiée dans les secteurs critiques comme
la finance et les gouvernements.
1. Qu'est-ce que Java EE ?
Java EE étend le langage Java avec des fonctionnalités pour la gestion des transactions, la
sécurité, la messagerie, la persistance des données, et d'autres services d'entreprise, permettant
aux développeurs de se concentrer sur la logique métier. Elle est conçue pour des applications
à grande échelle, offrant robustesse et maturité professionnelle.
2. Architecture Client-Serveur :
C'est le modèle de base où un Client HTTP (navigateur web, application mobile) envoie des
requêtes à un Serveur HTTP (ex: Apache Tomcat, JBoss, GlassFish, Oracle WebLogic
Server). Le serveur exécute le code Java EE dans un Conteneur (environnement d'exécution
pour les composants JEE) et renvoie une réponse.
o Fonctionnement Client-Serveur :
1. Le client établit une connexion réseau (socket) avec le serveur.
2. Le client envoie une Requête HTTP demandant un document (statique
ou dynamique).
3. Le serveur reçoit, analyse la requête et la transmet au composant Java
EE approprié (ex: Servlet). Ce composant exécute la logique métier.
4. Le serveur génère une Réponse HTTP (contenant le document et un
code de statut).
5. La connexion est gérée (fermée ou maintenue via Keep-Alive).
II. Protocole HTTP (HyperText Transfer Protocol)
HTTP est le protocole de communication sans état qui régit l'échange de documents entre un
client et un serveur web. Chaque requête est indépendante des précédentes.
1. Méthodes HTTP : Elles indiquent l'action souhaitée sur une ressource.
o GET : Récupérer des données. Paramètres dans l'URL. (Ex: /produits?id=123)
o POST : Soumettre des données (corps de la requête). Utilisé pour la
création/modification de ressources ou l'envoi de formulaires.
o PUT : Mettre à jour/créer une ressource à une URL spécifique.
o DELETE : Supprimer une ressource.
o HEAD : Récupérer les en-têtes d'une ressource sans son corps.
o OPTIONS : Demander les options de communication supportées par le
serveur/ressource.
2. En-têtes HTTP : Fournissent des métadonnées sur la requête/réponse.
o Génériques : Content-length, Content-Type, Connection.
o Requête : Accept, Accept-encoding, Accept-language, Cookie, Host, User-
agent.
o Réponse : Date, Expires, Last-Modified, Location (pour les redirections), Set-
Cookie (pour demander au client de stocker un cookie).
3. Codes de Statut HTTP : Indiquent le résultat de la requête (nombre à trois chiffres).
o 1xx (Information) : Ex: 100 Continue.
o 2xx (Succès) : Ex: 200 OK, 201 Created, 204 No Content.
o 3xx (Redirection) : Ex: 301 Moved Permanently, 302 Found, 304 Not
Modified.
o 4xx (Erreur Client) : Ex: 400 Bad Request, 401 Unauthorized, 403 Forbidden,
404 Not Found.
o 5xx (Erreur Serveur) : Ex: 500 Internal Server Error, 501 Not Implemented.
III. Modèle MVC (Model-View-Controller)
Le Modèle MVC est un design pattern architectural crucial pour structurer les applications
web, favorisant la séparation des préoccupations pour une meilleure maintenabilité,
évolutivité et collaboration.
• Composants du MVC :
o Modèle (Model) : Représente les données de l'application et la logique métier.
Gère l'état et interagit avec la base de données.
o Vue (View) : Responsable de l'affichage des données du modèle à l'utilisateur
(généralement des pages JSP). Elle est "stupide" et ne contient pas de logique
métier.
o Contrôleur (Controller) : Reçoit les requêtes, interagit avec le Modèle
(couche métier/DAO) pour récupérer ou modifier les données, puis choisit la
Vue appropriée à afficher (généralement des Servlets). C'est l'orchestrateur.
• Flux typique en Java EE MVC :
1. Requête Client (via navigateur) vers le Contrôleur (Servlet).
2. Le Contrôleur crée des objets HttpServletRequest et HttpServletResponse.
3. Le Contrôleur appelle la Couche Métier (du Modèle) pour les traitements.
4. Les résultats sont stockés dans un Objet Modèle (JavaBean), souvent dans l'objet
request ou session (request.setAttribute("modele", monObjet);).
5. Le Contrôleur effectue un Forwarding (redirection interne côté serveur) vers la Vue
(JSP) (request.getRequestDispatcher("/WEB-INF/maVue.jsp").forward(request, response);).
Le client ne voit pas le changement d'URL.
6. La Vue JSP accède au Modèle (via request.getAttribute("modele")), génère le HTML
dynamique.
7. La Réponse HTML est envoyée par le serveur au Client.
• Modèles MVC 1 et MVC 2 :
o MVC 1 : Les JSP agissent à la fois comme Vues et Contrôleurs (contiennent
de la logique métier et des redirections). Plus simple mais conduit à du code
"spaghetti".
o MVC 2 (ou Front Controller Pattern) : Le modèle recommandé. Utilise une
seule Servlet centrale (Contrôleur Frontal) pour toutes les requêtes, qui délègue
ensuite à des sous-contrôleurs/services métier, puis forwarde vers une JSP qui
ne fait que de l'affichage. Assure une séparation claire des responsabilités.
IV. API Servlet
L'API Servlet est le cœur de la technologie côté serveur pour les applications web Java. Une
Servlet est une classe Java qui s'exécute sur un conteneur web (comme Tomcat) et qui répond
aux requêtes HTTP.
1. Concept : Une Servlet étend javax.servlet.http.HttpServlet, fournissant une
implémentation des méthodes du cycle de vie et de traitement des requêtes HTTP. Elle
est le Contrôleur dans le modèle MVC.
2. Cycle de Vie : Géré par le conteneur web.
o Instanciation : La Servlet est instanciée une seule fois (souvent au démarrage
de l'application ou à la première requête).
o init(ServletConfig config) : Appelée UNE SEULE FOIS après l'instanciation.
Pour les initialisations lourdes (connexion BD, chargement config).
o service(ServletRequest req, ServletResponse res) : Appelée pour chaque
requête client. Elle dispatche vers la méthode doXXX() appropriée (doGet,
doPost, etc.) selon la méthode HTTP.
o doGet(HttpServletRequest req, HttpServletResponse resp) / doPost(...) etc. :
Contiennent la logique de traitement spécifique à chaque méthode HTTP.
o destroy() : Appelée UNE SEULE FOIS avant que la Servlet ne soit déchargée
de la mémoire (arrêt de l'application). Pour libérer les ressources.
3. Objets HttpServletRequest et HttpServletResponse :
o HttpServletRequest : Représente la requête entrante du client. Permet de lire
les paramètres (getParameter()), les en-têtes, les informations de session
(getSession()), et les attributs (getAttribute()).
o HttpServletResponse : Représente la réponse à envoyer au client. Permet de
définir le type de contenu (setContentType()), d'écrire le contenu
(getWriter().write()), d'ajouter des cookies (addCookie()), et d'envoyer des
redirections (sendRedirect()).
4. Session et Cookies : Cruciaux pour maintenir l'état dans le protocole HTTP sans état.
o Session HTTP (HttpSession) : Stocke des informations spécifiques à un
utilisateur (session.setAttribute()) sur le serveur (RAM). Identifiée par un
JSESSIONID (souvent un cookie). Les données persistent tant que la session
est active.
o Cookies : Petits fichiers texte que le serveur demande au client de stocker sur
sa machine. Le client les renvoie à chaque requête au même domaine. Utilisés
pour le suivi de session, la mémorisation des préférences
(response.addCookie(new Cookie("nom", "valeur"));).
Exemple de Code de Servlet simple (Java) :
import javax.servlet.ServletConfig;
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 javax.servlet.http.HttpSession; // Pour la gestion des sessions
import javax.servlet.http.Cookie; // Pour la gestion des cookies
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Date;
@WebServlet(name = "MaPremiereServlet", urlPatterns = {"/accueil"})
public class MaPremiereServlet extends HttpServlet {
// Méthode init: appelée une seule fois à l'initialisation de la Servlet
@Override
public void init(ServletConfig config) throws ServletException {
super.init(config);
System.out.println("MaPremiereServlet : Initialisation réussie !");
}
// Méthode doGet: Traite les requêtes HTTP GET
@Override
protected void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
// 1. Lire un paramètre de la requête (URL): Exemple GET /accueil?nom=Alice
String nomUtilisateur = request.getParameter("nom");
if (nomUtilisateur == null || nomUtilisateur.isEmpty()) {
nomUtilisateur = "Visiteur";
}
// 2. Gestion de la Session: Compteur de visites pour l'utilisateur courant
HttpSession session = request.getSession(); // Récupère session ou en crée une
Integer compteurVisites = (Integer) session.getAttribute("compteurVisites");
if (compteurVisites == null) {
compteurVisites = 1;
} else {
compteurVisites++;
}
session.setAttribute("compteurVisites", compteurVisites); // Mettre à jour la session
// 3. Gestion des Cookies: Définir un cookie
Cookie lastVisitCookie = new Cookie("lastVisit", new Date().toString());
lastVisitCookie.setMaxAge(60 * 60 * 24 * 7); // Valide 7 jours
response.addCookie(lastVisitCookie); // Envoyer le cookie au client
// Récupérer un cookie existant (si défini précédemment)
String lastLoggedInUser = "Non défini";
Cookie[] cookies = request.getCookies();
if (cookies != null) {
for (Cookie c : cookies) {
if ("loggedInUser".equals(c.getName())) {
lastLoggedInUser = c.getValue();
break;
}
}
}
// 4. Construire la Réponse HTML
response.setContentType("text/html;charset=UTF-8");
PrintWriter out = response.getWriter();
out.println("<!DOCTYPE html><html><head><title>Ma Servlet</title>");
out.println("<style>body { font-family: sans-serif; margin: 20px; }</style>");
out.println("</head><body>");
out.println("<h1>Bonjour, " + nomUtilisateur + " !</h1>");
out.println("<p>Vous avez visité cette page <strong>" + compteurVisites + "</strong>
fois dans cette session.</p>");
out.println("<p>Dernier utilisateur connu (via cookie 'loggedInUser') : <strong>" +
lastLoggedInUser + "</strong></p>");
out.println("<p>Un cookie 'lastVisit' a été mis à jour.</p>");
out.println("<form method='POST' action='/monApp/accueil'>"); // Simule un formulaire
de connexion
out.println(" <input type='text' name='username' placeholder='Username'><br>");
out.println(" <input type='password' name='password' placeholder='Password'><br>");
out.println(" <input type='submit' value='Connexion (POST)'>");
out.println("</form>");
out.println("</body></html>");
out.close();
}
// Méthode doPost: Traite les requêtes HTTP POST (Ex: soumission de formulaire)
@Override
protected void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
String username = request.getParameter("username");
String password = request.getParameter("password");
// Simuler une logique de connexion
if ("admin".equals(username) && "pass".equals(password)) {
// Stocker l'utilisateur en session
request.getSession().setAttribute("loggedInUser", username);
// Définir un cookie "se souvenir de moi"
Cookie userCookie = new Cookie("loggedInUser", username);
userCookie.setMaxAge(60 * 60 * 24 * 30); // 30 jours
response.addCookie(userCookie);
response.getWriter().println("<h1>Connexion r\u00E9ussie ! Bienvenue " + username
+ ".</h1>");
} else {
response.getWriter().println("<h1>\u00C9chec de la connexion.</h1><p>Nom
d'utilisateur ou mot de passe incorrect.</p>");
}
response.getWriter().println("<p><a href='/monApp/accueil'>Retour \u00E0
l'accueil</a></p>");
}
// Méthode destroy: appelée une seule fois à la destruction de la Servlet
@Override
public void destroy() {
System.out.println("MaPremiereServlet : Destruction et lib\u00E9ration des
ressources.");
}
}
V. Technologie JSP (JavaServer Pages)
Les JSP sont une technologie Java EE puissante et simple qui combine HTML, XML,
Servlets et JavaBeans pour créer des vues dynamiques. Elles sont compilées en Servlets par le
conteneur web.
1. JSP vs. Servlet :
o Servlet : Classe Java pour le traitement (Contrôleur).
o JSP : Page HTML avec du code Java. Pour l'affichage des vues.
o Une JSP est automatiquement déployée et, lors du premier appel, convertie en
Servlet, compilée et exécutée.
2. Balises JSP de base (<%...%>) :
o Scriptlets (<% code Java %>) : Incluent des blocs de code Java.
o Déclarations (<%! déclaration Java %>) : Déclarent variables/méthodes au
niveau classe.
o Expressions (<%= expression Java %>) : Évaluent une expression Java et
affichent son résultat.
3. Directives JSP (<%@ ... %>) : Contrôlent le comportement du conteneur.
o page : Définit les propriétés de la page (ex: import, pageEncoding).
o taglib : Inclut des bibliothèques de balises personnalisées (comme la JSTL).
o include : Inclut le contenu d'un autre fichier statiquement (au moment de la
compilation).
4. Inclusion Dynamique (<jsp:include>) :
o <jsp:include page="page.jsp" /> : Inclut le contenu d'une autre ressource
dynamiquement (à l'exécution). Chaque page est compilée en sa propre
Servlet.
5. Transmission de Données :
o Serveur vers JSP (Attributs) : La Servlet stocke des objets dans la requête
(request.setAttribute()), que la JSP récupère (request.getAttribute()).
o Client vers Serveur (Paramètres) : Données envoyées par l'URL (GET) ou le
corps de la requête (POST), lues via request.getParameter().
6. Portée (Scope) des Objets : Durée de vie et accessibilité des objets.
o page : Accessible uniquement dans la JSP actuelle.
o request : Accessible pendant toute la durée d'une requête HTTP.
o session : Accessible durant toute la session d'un utilisateur.
o application : Accessible durant toute la vie de l'application, par tous les
utilisateurs.
VI. JavaBeans comme Modèles
Les JavaBeans sont des composants Java réutilisables, essentiels pour représenter le Modèle
dans une architecture MVC.
1. Conventions de JavaBean :
o Classe public.
o Constructeur par défaut public et sans arguments.
o Peut implémenter java.io.Serializable.
o Champs (propriétés) private, accessibles via méthodes public getter (getNom())
et setter (setNom(String nom)).
2. Avantages : Paramétrable, persistant, réutilisable, dynamique (grâce à l'introspection,
les outils peuvent manipuler ses propriétés via les getters/setters).
3. Mise en place : Les classes compilées des JavaBeans doivent être dans /WEB-
INF/classes.
Exemple de Code de JavaBean simple (Java) :
import java.io.Serializable;
public class Produit implements Serializable { // 1. Public et Serializable (recommandé)
private static final long serialVersionUID = 1L; // Pour la sérialisation
// 2. Champs privés (propriétés)
private Long id;
private String nom;
private double prix;
// 3. Constructeur par défaut (public et sans arguments) - OBLIGATOIRE
public Produit() {
}
// Constructeur avec arguments (optionnel)
public Produit(Long id, String nom, double prix) {
this.id = id;
this.nom = nom;
this.prix = prix;
}
// 4. Getters et Setters publics pour chaque propriété
// Convention: getPropriete(), setPropriete(valeur)
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getNom() {
return nom;
}
public void setNom(String nom) {
this.nom = nom;
}
public double getPrix() {
return prix;
}
public void setPrix(double prix) {
this.prix = prix;
}
@Override
public String toString() {
return "Produit{id=" + id + ", nom='" + nom + "', prix=" + prix + "}";
}
}
VII. Expression Language (EL) et JSTL (Java Standard Tag Library)
L'EL et la JSTL sont des outils clés pour simplifier les JSP et réduire l'utilisation de scriptlets
Java, rendant les vues plus propres et maintenables.
1. Expression Language (EL) :
o Syntaxe : \${expression}.
o Rôle : Accéder et manipuler simplement des objets et attributs sans code Java.
o Opérations : Permet des opérations arithmétiques (+, -, *, /, %), logiques
(&&, ||, !), de comparaison (==, !=, <, >).
o Test d'état : empty expression retourne true si l'expression est null ou vide.
o Accès aux propriétés : \${Bean.propriete} (appelle getPropriete()).
o Accès aux collections : \${maListe[index]} ou \${maMap['cle']}.
o Objets Implicites de l'EL : Accès direct aux scopes (pageScope,
requestScope, sessionScope, applicationScope), paramètres (param,
paramValues), cookies (cookie), en-têtes (header), etc.
2. Java Standard Tag Library (JSTL) :
o Objectif : Simplifier les JSP en utilisant des balises XML au lieu de scriptlets
Java pour les logiques de contrôle.
o Utilisation : Déclaration taglib en JSP, ex: <%@ taglib prefix="c"
uri="http://java.sun.com/jsp/jstl/core" %>.
o Bibliothèques principales : Core (c:), Format (fmt:), XML (x:), SQL (sql:),
Fonctions (fn:).
o Balises Core (c:) :
▪ <c:out value="\${expression}" /> : Affiche une expression EL, avec
échappement XML par défaut (sécurité XSS).
▪ <c:if test="\${condition}"> : Condition simple.
▪ <c:choose>, <c:when>, <c:otherwise> : Conditions multiples.
▪ <c:forEach items="\${collection}" var="element"> : Itération sur des
collections.
▪ <c:forTokens var="token" items="chaine" delims="delimiteurs"> :
Itération sur les jetons d'une chaîne.
Exemple de Code JSP avec EL et JSTL :
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<%@ page import="java.util.List, java.util.ArrayList" %>
<%@ page import="com.example.Produit" %> <%-- Assurez-vous que le package de Produit
est correct --%>
<!DOCTYPE html>
<html>
<head>
<title>JSP avec EL et JSTL</title>
</head>
<body>
<h1>Exemple de JSP avec EL et JSTL</h1>
<%-- Simulation d'un modèle (List de Produit) stocké dans la requête par une Servlet --%>
<%
List<Produit> produits = new ArrayList<>();
produits.add(new Produit(1L, "Laptop", 1200.0));
produits.add(new Produit(2L, "Souris", 25.0));
produits.add(new Produit(3L, "Clavier", 75.0));
request.setAttribute("listeProduits", produits); // Stocké dans la portée 'request'
// Simuler un message en session
session.setAttribute("messageBienvenue", "Bienvenue sur notre boutique !");
%>
<h2>Affichage avec EL et JSTL</h2>
<h3>Message de Bienvenue (via Session Scope):</h3>
<p><c:out value="\${sessionScope.messageBienvenue}" /></p>
<h3>Paramètre de Requête (ex: /maPage.jsp?utilisateur=Paul):</h3>
<p>Utilisateur : <c:out value="\${param.utilisateur}" default="Invité" /></p>
<h3>Liste des Produits (via c:forEach) :</h3>
<table border="1">
<thead>
<tr><th>ID</th><th>Nom</th><th>Prix</th></tr>
</thead>
<tbody>
<c:forEach items="\${requestScope.listeProduits}" var="p">
<tr>
<td><c:out value="\${p.id}" /></td>
<td><c:out value="\${p.nom}" /></td>
<td><c:out value="\${p.prix}" /> €</td>
</tr>
</c:forEach>
</tbody>
</table>
<h3>Condition simple (c:if) :</h3>
<c:set var="prixTotal" value="\${1200 + 25 + 75}" scope="request" /> <%-- Calcul avec
EL --%>
<p>Prix total des produits (simulé) : <c:out value="\${prixTotal}" /> €</p>
<c:if test="\${prixTotal > 1000}">
<p style="color: green;">C'est une commande importante !</p>
</c:if>
<h3>Condition multiple (c:choose) :</h3>
<c:set var="stock" value="10" />
<c:choose>
<c:when test="\${stock > 50}">
<p>Produit en stock suffisant.</p>
</c:when>
<c:when test="\${stock > 0}">
<p style="color: orange;">Stock faible, commandez rapidement !</p>
</c:when>
<c:otherwise>
<p style="color: red;">Rupture de stock !</p>
</c:otherwise>
</c:choose>
</body>
</html>
VIII. API JDBC (Java Database Connectivity)
JDBC est l'API standard de Java pour interagir avec des bases de données relationnelles.
1. Rôle : Permet à une application Java de se connecter à une base de données,
d'exécuter des requêtes SQL et de manipuler des données. Assure la portabilité avec
différentes SGBD (MySQL, Oracle, PostgreSQL).
2. Architecture : L'application Java utilise l'API JDBC, qui via le JDBC Driver
Manager, charge les JDBC Drivers spécifiques à un SGBD.
3. Classes/Interfaces Principales :
o DriverManager : Gère les pilotes et établit la connexion.
o Connection : Représente une connexion active à la base de données.
o Statement : Exécute des requêtes SQL simples et statiques.
o PreparedStatement : Requêtes SQL paramétrées (performances et sécurité
contre les injections SQL). À privilégier.
o ResultSet : Contient les résultats d'une requête SELECT. Permet de parcourir
les lignes et extraire les données (getString(), getInt()).
4. Architecture en Couches (Client/DAO) :
o La logique JDBC est encapsulée dans la couche DAO (Data Access Object).
o Client.java : JavaBean représentant une entité métier (ex: un client).
o SingletonConnection.java : Classe utilitaire pour une connexion unique à la
base de données.
o IClientDao.java (Interface DAO) : Définit les opérations CRUD.
o ClientDAOImpl.java : Implémente IClientDao avec le code JDBC (ex: save
avec PreparedStatement).
o Le Contrôleur (ControleurServlet) appelle la couche DAO pour les opérations
de persistance, puis stocke le modèle (ex: ClientModele) dans la requête et
forwarde vers la JSP.
Exemple de Code DAO simple (Java) :
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
// Importez votre classe Produit si elle est dans un autre package
// import com.example.Produit;
// 1. Singleton pour la connexion à la base de données (simulé)
class SingletonConnection {
private static Connection connection;
static { // Bloc static: exécuté une seule fois au chargement de la classe
try {
// Charger le pilote JDBC (pour MySQL)
Class.forName("com.mysql.cj.jdbc.Driver"); // 'cj' pour les versions récentes
// Établir la connexion
connection = DriverManager.getConnection(
"jdbc:mysql://localhost:3306/ma_base_de_donnees?useSSL=false&serverTimezone=UTC",
"root",
"your_password" // Remplacez par votre mot de passe
);
System.out.println("Connexion \u00E0 la base de donn\u00E9es \u00E9tablie.");
} catch (Exception e) {
e.printStackTrace();
System.err.println("Erreur de connexion \u00E0 la base de donn\u00E9es : " +
e.getMessage());
}
}
public static Connection getConnection() {
return connection;
}
}
// 2. Interface DAO pour les opérations sur les produits
interface IProduitDao {
Produit save(Produit p) throws SQLException;
List<Produit> findByNom(String nom) throws SQLException;
List<Produit> findAll() throws SQLException;
}
// 3. Implémentation DAO avec JDBC
class ProduitDaoImpl implements IProduitDao {
@Override
public Produit save(Produit p) throws SQLException {
Connection conn = SingletonConnection.getConnection();
// Utilisation de PreparedStatement pour insérer (s\u00E9curit\u00E9 anti-injection SQL)
String sql = "INSERT INTO PRODUITS (NOM, PRIX) VALUES (?, ?)";
try (PreparedStatement ps = conn.prepareStatement(sql,
PreparedStatement.RETURN_GENERATED_KEYS)) {
ps.setString(1, p.getNom());
ps.setDouble(2, p.getPrix());
ps.executeUpdate();
// R\u00E9cup\u00E9rer l'ID g\u00E9n\u00E9r\u00E9
try (ResultSet rs = ps.getGeneratedKeys()) {
if (rs.next()) {
p.setId(rs.getLong(1));
}
}
System.out.println("Produit sauvegard\u00E9: " + p);
return p;
}
}
@Override
public List<Produit> findByNom(String nom) throws SQLException {
List<Produit> produits = new ArrayList<>();
Connection conn = SingletonConnection.getConnection();
// Utilisation de PreparedStatement avec LIKE pour la recherche
String sql = "SELECT ID, NOM, PRIX FROM PRODUITS WHERE NOM LIKE ?";
try (PreparedStatement ps = conn.prepareStatement(sql)) {
ps.setString(1, "%" + nom + "%");
try (ResultSet rs = ps.executeQuery()) {
while (rs.next()) {
Produit p = new Produit();
p.setId(rs.getLong("ID"));
p.setNom(rs.getString("NOM"));
p.setPrix(rs.getDouble("PRIX"));
produits.add(p);
}
}
System.out.println("Recherche par nom '" + nom + "' : " + produits.size() + "
r\u00E9sultats.");
return produits;
}
}
@Override
public List<Produit> findAll() throws SQLException {
List<Produit> produits = new ArrayList<>();
Connection conn = SingletonConnection.getConnection();
String sql = "SELECT ID, NOM, PRIX FROM PRODUITS";
try (PreparedStatement ps = conn.prepareStatement(sql);
ResultSet rs = ps.executeQuery()) {
while (rs.next()) {
Produit p = new Produit();
p.setId(rs.getLong("ID"));
p.setNom(rs.getString("NOM"));
p.setPrix(rs.getDouble("PRIX"));
produits.add(p);
}
System.out.println("Tous les produits r\u00E9cup\u00E9r\u00E9s : " +
produits.size());
return produits;
}
}
// M\u00E9thode main pour tester le DAO
public static void main(String[] args) {
// NOTE: Pour ex\u00E9cuter ce main, vous devez avoir une base de donn\u00E9es
MySQL
// et une table 'PRODUITS' cr\u00E9\u00E9e, par exemple:
// CREATE TABLE PRODUITS (ID BIGINT AUTO_INCREMENT PRIMARY KEY,
NOM VARCHAR(255), PRIX DOUBLE);
// Assurez-vous aussi que le driver JDBC est dans votre classpath (ex: via Maven/Gradle
ou manuel).
IProduitDao dao = new ProduitDaoImpl();
try {
// Test Save
Produit p1 = dao.save(new Produit(null, "Moniteur", 250.0));
Produit p2 = dao.save(new Produit(null, "Webcam HD", 50.0));
// Test Find All
List<Produit> allProduits = dao.findAll();
System.out.println("\n--- Tous les produits ---");
allProduits.forEach(System.out::println);
// Test Find By Name
List<Produit> searchResults = dao.findByNom("Monit");
System.out.println("\n--- Produits contenant 'Monit' ---");
searchResults.forEach(System.out::println);
} catch (SQLException e) {
e.printStackTrace();
}
}
}
IX. JPA, Hibernate et Spring Data
Ces technologies simplifient et abstraient davantage l'accès aux bases de données par rapport
à JDBC, en implémentant le concept d'ORM.
1. Mapping Objet Relationnel (ORM) :
o Résout le "fossé d'inadéquation" entre les objets Java et les tables
relationnelles.
o Les frameworks ORM (comme Hibernate) permettent de manipuler des objets
Java pour la persistance, sans écrire de SQL direct, améliorant productivité,
portabilité et efficacité.
2. JPA (Java Persistence API) :
o C'est une spécification (API standard) pour la persistance des entités Java.
o Définit des interfaces, classes et annotations pour l'ORM et l'interface
EntityManager pour gérer le cycle de vie des entités.
o Annotations JPA : Permettent le mapping direct dans les classes Java
(@Entity, @Table, @Id, @GeneratedValue, @Column, @OneToMany,
@ManyToOne, etc.).
o EntityManager : Gère le cycle de vie des entités persistantes. Méthodes clés :
persist() (sauvegarder), find() (charger par clé primaire), createQuery() (pour
requêtes JPQL/HQL), remove() (supprimer), merge() (mettre à jour).
o persistence.xml : Fichier de configuration crucial définissant les unités de
persistance, le fournisseur JPA, et les propriétés de connexion BD.
3. Hibernate :
o Implémentation concrète et la plus populaire de la spécification JPA.
o Traduit le JPQL/HQL en SQL spécifique à la base de données.
4. Spring Data JPA :
o Module du framework Spring qui simplifie drastiquement l'accès aux données
via JPA.
o Réduction du code boilerplate : Évite d'écrire la plupart des implémentations
de la couche DAO.
o Interfaces de Repository (JpaRepository) : Il suffit de créer une interface qui
étend JpaRepository<Entité, Type_ID> pour hériter des méthodes CRUD
prêtes à l'emploi.
o Méthodes "Dérivées" : Spring Data génère automatiquement
l'implémentation de méthodes basées sur leur nom (ex: findByNom(String
nom)).
o Requêtes Personnalisées (@Query) : L'annotation @Query permet de définir
des requêtes JPQL complexes directement dans l'interface du repository.
Exemple de Code Spring Data JPA (Java) :
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.query.Param;
import java.util.List;
// Assurez-vous que votre classe Produit est annotée avec @Entity
// et a un champ @Id pour JPA.
// Exemple d'Interface Repository Spring Data JPA
// Elle h\u00E9rite des op\u00E9rations CRUD de base (save, findById, findAll, delete)
// sans que nous n'ayons \u00E0 les impl\u00E9menter.
public interface ProduitRepository extends JpaRepository<Produit, Long> {
// M\u00E9thode "d\u00E9riv\u00E9e": Spring Data g\u00E9n\u00E8re
l'impl\u00E9mentation automatiquement
// \u00C9quivaut \u00E0 SELECT * FROM PRODUITS WHERE NOM LIKE ?
List<Produit> findByNomContaining(String nom);
// Requ\u00EAte personnalis\u00E9e avec JPQL (Java Persistence Query Language)
// Utile pour des requ\u00EAtes plus complexes
@Query("SELECT p FROM Produit p WHERE p.nom LIKE :nomPartiel AND p.prix >=
:prixMin")
List<Produit> rechercherParNomEtPrix(
@Param("nomPartiel") String nomPartiel,
@Param("prixMin") double prixMin
);
// Une autre m\u00E9thode d\u00E9riv\u00E9e pour trouver des produits par prix
List<Produit> findByPrixGreaterThan(double prix);
}
// Exemple de service qui utiliserait ce repository (avec injection de d\u00E9pendances)
/*
import org.springframework.stereotype.Service;
import org.springframework.beans.factory.annotation.Autowired;
import java.util.List;
@Service // Indique que c'est un composant Spring de la couche service
public class ProduitService {
private final ProduitRepository produitRepository; // D\u00E9pendance au repository
@Autowired // Spring injectera une instance de ProduitRepository
public ProduitService(ProduitRepository produitRepository) {
this.produitRepository = produitRepository;
}
public Produit ajouterProduit(Produit p) {
return produitRepository.save(p); // Utilise la m\u00E9thode 'save' h\u00E9rit\u00E9e
}
public List<Produit> chercherProduitsParNom(String nom) {
return produitRepository.findByNomContaining(nom); // Utilise la m\u00E9thode
d\u00E9riv\u00E9e
}
public List<Produit> chercherProduitsComplex(String nom, double prixMin) {
return produitRepository.rechercherParNomEtPrix("%" + nom + "%", prixMin); //
Utilise la requ\u00EAte personnalis\u00E9e
}
}
*/
X. Inversion de Contrôle (IoC) et Injection de Dépendances (DI)
Ces principes visent à créer des applications modulaires, flexibles et faciles à maintenir en
réduisant le couplage entre les composants.
1. Problème du Couplage Fort :
o Une classe A est fortement liée à B si elle dépend directement de son
implémentation concrète (ex: A { B b = new B(); }).
o Entraîne rigidité, coûts de maintenance élevés (recompilation, redéploiement)
et non-respect du principe "fermé à la modification, ouvert à l'extension".
2. Solution du Couplage Faible (via les Interfaces) :
o Une classe A dépend d'une interface IB, et non d'une implémentation concrète
de B.
o Permet à A de fonctionner avec n'importe quelle implémentation de IB sans
modification de A.
o Améliore la flexibilité, l'extensibilité et la testabilité.
3. IoC (Inversion de Contrôle) et DI (Injection de Dépendances) :
o IoC : Le framework (conteneur IoC, ex: Spring) prend le contrôle de la
création et du "câblage" des objets. Votre code déclare ce dont il a besoin, et le
framework le fournit.
o DI : La forme concrète de l'IoC où les dépendances d'un objet sont "injectées"
(fournies) à cet objet de l'extérieur.
o Avantages : Délégation des tâches techniques, séparation des préoccupations,
modularité, réutilisabilité, testabilité.
4. Injection de Dépendances avec Spring :
o XML (traditionnel) : Configuration des beans et de leurs dépendances dans
un fichier spring-ioc.xml.
o Annotations (moderne et préférée) :
▪ @Component : Marque une classe comme un composant Spring.
▪ @Autowired ou @Resource : Indiquent à Spring d'injecter
automatiquement les dépendances.
▪ @Transactional : Annotation de Spring AOP pour la gestion
automatique des transactions.
5. Maven :
o Outil de gestion de projet et d'automatisation des builds Java (compilation, test,
packaging).
o POM (Project Object Model) : Fichier pom.xml qui décrit le projet et ses
dépendances.
o Gestion des Dépendances : Télécharge automatiquement les bibliothèques
nécessaires depuis les dépôts.
6. Injection dans une Application Web :
o Spring IoC est initialisé au démarrage du serveur via le ContextLoaderListener
déclaré dans le web.xml. Ce listener charge le contexte Spring et effectue
l'injection des dépendances entre les composants de l'application.
Exemple de Code Spring IoC/DI (Java) :
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
// 1. Interface pour la couche DAO (couplage faible)
interface IDao {
double getValue();
}
// 2. Impl\u00E9mentation de la couche DAO
@Component("dao") // Marque cette classe comme un composant Spring, nomm\u00E9
"dao"
class DaoImpl implements IDao {
@Override
public double getValue() {
System.out.println("DAO : R\u00E9cup\u00E9ration d'une valeur depuis la BD
(simul\u00E9).");
return 10.0; // Valeur simul\u00E9e
}
}
// 3. Interface pour la couche M\u00E9tier
interface IMetier {
double calcul();
}
// 4. Impl\u00E9mentation de la couche M\u00E9tier
@Component("metier") // Marque cette classe comme un composant Spring, nomm\u00E9
"metier"
class MetierImpl implements IMetier {
// @Autowired : Spring va trouver un bean de type IDao et l'injecter ici.
// Cela remplace "private IDao dao = new DaoImpl();" (couplage fort)
@Autowired
private IDao dao; // La d\u00E9pendance 'dao' est inject\u00E9e par Spring
public MetierImpl() {
System.out.println("M\u00E9tier : Constructeur MetierImpl appel\u00E9.");
}
@Override
public double calcul() {
System.out.println("M\u00E9tier : Ex\u00E9cution du calcul...");
double nb = dao.getValue(); // Utilise la d\u00E9pendance inject\u00E9e
return 2 * nb;
}
}
// 5. Classe de pr\u00E9sentation / D\u00E9monstration
public class Presentation {
public static void main(String[] args) {
System.out.println("--- D\u00E9monstration de Spring IoC/DI ---");
// Cr\u00E9ation du contexte Spring (simule le conteneur IoC)
// Spring va scanner les packages sp\u00E9cifi\u00E9s pour trouver les @Component
ApplicationContext context = new AnnotationConfigApplicationContext(
"dao", "metier" // Packages \u00E0 scanner pour les composants Spring
);
System.out.println("\n--- R\u00E9cup\u00E9ration du bean 'metier' ---");
// R\u00E9cup\u00E9rer l'instance de MetierImpl g\u00E9r\u00E9e par Spring
IMetier metier = context.getBean(IMetier.class);
// Ex\u00E9cuter la m\u00E9thode calcul(), qui utilise la d\u00E9pendance 'dao'
inject\u00E9e
System.out.println("R\u00E9sultat du calcul : " + metier.calcul());
System.out.println("\n--- D\u00E9monstration du couplage faible ---");
// Si nous avions une autre impl\u00E9mentation de IDao (ex: DaoImplMock)
// il suffirait de changer la configuration Spring (ou l'annotation @Component)
// sans toucher au code de MetierImpl.
}
}
