Affichage dynamique avec JSP et EL

1. Pourquoi abandonner les out.println() ?

Avant de plonger dans la syntaxe des JSP, il est essentiel de bien comprendre le problème que nous résolvons. Le mélange de code Java et de balises HTML dans un même fichier est considéré comme une mauvaise pratique professionnelle depuis de nombreuses années. Cela rend le code illisible, difficile à déboguer et impossible à confier à un intégrateur web qui ne connaît pas Java.

La vidéo suivante introduit parfaitement cette problématique et présente l'Expression Language (EL) comme la solution pour nettoyer nos vues.

2. JSP et Expression Language : les bases

Une JSP (JavaServer Page) est, à première vue, un fichier HTML. Sa puissance réside dans sa capacité à inclure des balises spéciales qui sont interprétées par le serveur pour générer du contenu dynamique. Lorsque vous accédez à une JSP pour la première fois, votre conteneur de servlets (Tomcat) la compile en une servlet Java. C'est cette servlet qui est ensuite exécutée pour chaque requête.

L'Expression Language (EL) est le mécanisme que nous utiliserons pour insérer des données dynamiques dans la JSP. Sa syntaxe est très simple : tout ce qui se trouve entre ${ et } est une expression qui sera évaluée par le serveur.

Voyons à quel point c'est plus simple que d'écrire du Java.

3. Connecter la Servlet à la JSP : le modèle MVC

Le véritable flux de travail d'une application web Java professionnelle suit le patron de conception Modèle-Vue-Contrôleur (MVC).

Dans ce modèle :

1. La Servlet (Contrôleur) reçoit la requête, traite la logique (par ex., vérifier un mot de passe, charger des produits depuis la base de données), puis stocke les résultats (le "modèle") comme attributs dans la requête ou la session.
2. Au lieu de générer du HTML, la servlet transfère (forward) la requête à une JSP (Vue).
3. La JSP utilise l'Expression Language (EL) pour lire les attributs de la requête/session et les afficher.

Comment l'EL accède-t-il aux données ?

Lorsque vous écrivez ${user.login}, l'EL effectue plusieurs actions intelligentes pour vous :

1. Recherche de l'attribut : Il cherche un attribut nommé user dans plusieurs "portées" (scopes), dans cet ordre : page, request, session, et application. Le premier qu'il trouve est utilisé. C'est pourquoi vous n'avez pas besoin de spécifier requestScope ou sessionScope la plupart du temps.
2. Appel du getter : Une fois l'objet user trouvé, l'EL ne tente pas d'accéder directement à la variable login. Au lieu de cela, il suit la convention JavaBean et appelle la méthode getLogin(). C'est une simplification très puissante.

La vidéo suivante illustre parfaitement ce mécanisme avec un objet connectedUser stocké en session.

4. Le guide de référence de l'Expression Language

L'EL est riche en fonctionnalités. Pour bien les maîtriser, il est utile d'avoir une ressource de référence. Le document suivant résume les concepts clés.

5. Fonctionnalités avancées et bonnes pratiques de l'EL

Logique conditionnelle simple

L'EL n'est pas un langage de programmation complet, mais il permet une logique de présentation simple. L'opérateur empty et l'opérateur ternaire ? : sont particulièrement utiles.

• empty variable renvoie true si variable est null, une chaîne vide, ou une collection/map vide.
• condition ? valeur_si_vrai : valeur_si_faux permet un affichage conditionnel.

Voyons comment les combiner pour, par exemple, afficher un nom d'utilisateur s'il existe, et ne rien afficher sinon.

Gestion robuste des erreurs

Un des plus grands avantages de l'EL est sa gestion des valeurs null. En Java, si vous faites user.getAddress().getCity() et que getAddress() renvoie null, votre application plante avec une NullPointerException. En EL, si vous écrivez ${user.address.city}, l'expression renverra simplement une chaîne vide. C'est un comportement beaucoup plus robuste pour une couche de présentation.

Le document suivant explique très bien cette caractéristique essentielle.

6. Application pratique : refactoriser notre système de connexion

Appliquons ce que nous avons appris en refactorisant la LoginServlet de la leçon précédente pour utiliser une JSP.

Ancien code dans doGet (mauvaise pratique) :

// ...
if (session != null && session.getAttribute("username") != null) {
    String username = (String) session.getAttribute("username");
    out.println("<h1>Bienvenue, " + username + "!</h1>");
    out.println("<a href='logout'>Se déconnecter</a>");
} else {
    response.sendRedirect("login.html");
}

Nouveau code dans doGet (bonne pratique MVC) :

@Override
protected void doGet(HttpServletRequest request, HttpServletResponse response)
        throws ServletException, IOException {
    
    HttpSession session = request.getSession(false);

    if (session != null && session.getAttribute("username") != null) {
        // On ne génère plus de HTML ici.
        // On transfère simplement la requête à la JSP.
        request.getRequestDispatcher("/WEB-INF/dashboard.jsp").forward(request, response);
    } else {
        response.sendRedirect("login.html");
    }
}

Points clés :

• getRequestDispatcher(...) obtient un objet pour transférer la requête à une autre ressource sur le serveur (notre JSP).
• forward(request, response) transfère la requête et la réponse à la JSP. Les attributs que vous avez définis dans request et session sont conservés. C'est une opération interne au serveur, l'URL dans le navigateur du client ne change pas.
• Sécurité : En plaçant les JSP dans le dossier /WEB-INF/, elles ne sont pas accessibles directement par l'utilisateur via une URL, mais seulement via un forward depuis une servlet. C'est une bonne pratique de sécurité.

Le fichier /WEB-INF/dashboard.jsp :

<%@ page pageEncoding="UTF-8" contentType="text/html; charset=UTF-8" %>
<!DOCTYPE html>
<html>
<head>
    <title>Tableau de bord</title>
</head>
<body>
    <h1>Bienvenue, ${sessionScope.username}!</h1>
    <p>Ceci est votre tableau de bord personnel.</p>
    <p><a href="logout">Se déconnecter</a></p>
</body>
</html>

Points clés :

• <%@ page ... %> est une directive JSP. pageEncoding="UTF-8" est crucial pour la gestion des accents.
• ${sessionScope.username} accède directement à l'attribut username que nous avons stocké dans la session. Le code est propre, lisible et purement déclaratif.

Exercice

Il est temps de mettre cela en pratique. Vous allez créer une page qui affiche les détails d'un produit.

1. Créez une classe JavaBean Produit.java avec des attributs privés nom (String) et prix (double), ainsi que les getters publics correspondants (getNom() et getPrix()).
2. Créez une servlet ProduitServlet.java qui, dans sa méthode doGet, fait ce qui suit :
   • Crée une instance de votre classe Produit. Par exemple : Produit produit = new Produit("Souris Gamer", 49.99);
   • Stocke cet objet dans la portée de la requête : request.setAttribute("produitAffiche", produit);
   • Transfère la requête à une JSP : request.getRequestDispatcher("/WEB-INF/detailsProduit.jsp").forward(request, response);
3. Créez la page JSP /WEB-INF/detailsProduit.jsp :
   • Assurez-vous d'inclure la directive <%@ page pageEncoding="UTF-8" ... %>.
   • Dans le corps de la page, utilisez l'Expression Language pour afficher le nom et le prix du produit.
   • Le rendu final devrait ressembler à :

     <h1>Détails du produit</h1>
     <p>Nom : Souris Gamer</p>
     <p>Prix : 49.99 €</p>
     

   • (Bonus) Utilisez l'opérateur empty pour afficher un message "Produit non disponible" si l'attribut produitAffiche est null.

Cet exercice vous permettra de maîtriser le flux complet : création d'un modèle (JavaBean), préparation des données dans le contrôleur (Servlet) et affichage dans la vue (JSP avec EL).

Conclusion

Félicitations ! Vous venez de franchir une étape majeure pour devenir un développeur backend Java professionnel. Vous savez maintenant comment séparer la logique de la présentation, un principe fondamental d'une architecture logicielle saine.

Les points clés à retenir :

• Les JSP servent de vues dans l'architecture MVC, se concentrant sur la présentation (HTML).
• L'Expression Language (EL), avec sa syntaxe ${...}, est le moyen propre et moderne d'insérer des données dynamiques dans une JSP.
• L'EL accède aux attributs des portées (request, session...) et appelle implicitement les getters des JavaBeans (${produit.nom} appelle getNom()).
• Le flux standard est : la Servlet (contrôleur) prépare les données et les transfère (forward) à la JSP (vue) pour l'affichage.
• L'EL gère les valeurs null de manière robuste, évitant les NullPointerException dans la vue.

Dans la leçon d'aujourd'hui, nous n'avons affiché qu'un seul objet. Mais que faire si notre servlet prépare une liste de produits ? Comment faire une boucle en JSP ? C'est le sujet de notre prochaine leçon, où nous découvrirons la JSTL (JSP Standard Tag Library) et ses balises très utiles comme <c:forEach> et <c:if>.