Hoja de repaso: Introduction aux JavaBeans et JSP

📋 Plan du Cours

1. JavaBeans
2. Structure Bean
3. Sécurité Bean
4. JSP Syntaxe
5. Objets Implicites JSP
6. Directives JSP
7. Actions JSP
8. Balises JSP
9. Modèle MVC
10. JSTL

📖 1. JavaBeans

🔑 Notions clés & Définitions

• JavaBean : classe Java modulaire, réutilisable, encapsulant des données du monde réel, conçue pour la manipulation et la transmission d'informations dans une application Java EE (source : JAVA EE Chapitre 2).
• Propriétés : attributs privés d’un JavaBean, accessibles via des méthodes publiques getter et setter, suivant des règles de nommage (ex : getNom(), setNom()) (source : JAVA EE Chapitre 2).
• Serializable : interface que peut implémenter un JavaBean pour permettre sa persistance, c’est-à-dire sauvegarder son état, notamment lors de la sérialisation pour stockage ou transmission (source : JAVA EE Chapitre 2).
• Structure d’un JavaBean : doit être une classe publique, posséder un constructeur par défaut (public, sans paramètres), et ne doit pas avoir de champs publics. Elle peut définir des propriétés via des champs privés et des méthodes publiques getter/setter (source : JAVA EE Chapitre 2).
• Modèle MVC : dans l’architecture JEE, le JavaBean représente la partie Modèle, qui gère les données de l’application, séparée de la Vue (JSP) et du Contrôleur (Servlet) (source : JAVA EE Chapitre 2).

📝 Points essentiels

• Le JavaBean est une classe Java conçue pour représenter des données du monde réel, facilitant leur manipulation dans une architecture MVC.
• La structure doit respecter certaines règles : classe publique, constructeur par défaut, absence de champs publics, implémentation facultative de Serializable pour la persistance.
• Les propriétés sont définies par des champs privés accessibles via des méthodes getter et setter, suivant une convention de nommage strict.
• La sérialisation via l’interface Serializable permet de sauvegarder ou transmettre l’état d’un JavaBean, ce qui est essentiel pour la persistance dans une application web (source : JAVA EE Chapitre 2).
• Dans le modèle MVC, le JavaBean joue le rôle du Modèle, centralisant la gestion des données et facilitant leur réutilisation et leur modularité.

💡 À retenir

Le JavaBean est une classe Java standard, conçue pour représenter et manipuler des données dans une architecture MVC, en respectant des règles strictes d’encapsulation et de structure, avec une capacité de persistance via la sérialisation.

📖 2. Structure Bean

🔑 Notions clés & Définitions

• Classe publique : La structure d’un Bean doit être une classe déclarée publique pour permettre son accès depuis d’autres classes et composants dans l’application JEE, facilitant ainsi la réutilisation et l’intégration (source : JAVABEANS 5).

• Constructeur par défaut : Un Bean doit posséder au moins un constructeur sans paramètres, public. Si aucun constructeur n’est explicitement défini, Java en fournit un automatiquement. Cela garantit que le Bean peut être instancié facilement par le conteneur ou le framework (source : JAVABEANS 5).

• Implémentation Serializable : Le Bean peut implémenter l’interface Serializable pour permettre la persistance de son état, c’est-à-dire sa sauvegarde et sa restauration, notamment lors de sessions ou stockage (source : JAVABEANS 5).

• Champs privés et méthodes publiques getter/setter : La propriété d’un Bean est définie par des champs privés, accessibles uniquement via des méthodes publiques getter et setter, suivant des règles de nommage précises. Cela assure l’encapsulation et la sécurité des données (source : JAVABEANS 5).

• Absence de champs publics : Pour respecter le principe d’encapsulation, un Bean ne doit pas contenir de champs publics, ce qui évite toute modification directe de ses propriétés et favorise une gestion contrôlée via les méthodes d’accès (source : JAVABEANS 5).

📝 Points essentiels

• La classe Java d’un Bean doit être publique pour garantir son accessibilité dans toute l’application, conformément à JAVABEANS 5.
• La présence d’un constructeur par défaut est obligatoire pour permettre une instanciation automatique par le conteneur ou lors de la désérialisation. Java l’ajoute automatiquement si aucun constructeur n’est défini, mais il est conseillé de le déclarer explicitement.
• La persistance du Bean peut être assurée en implémentant l’interface Serializable, ce qui permet de sauvegarder son état dans un flux ou stockage, facilitant la gestion de sessions ou de stockage durable.
• La définition des propriétés doit se faire via des champs privés et des méthodes getter/setter publiques, respectant la convention de nommage (ex : getNom, setNom), pour assurer l’encapsulation et la conformité aux standards JavaBeans.
• L’absence de champs publics est une bonne pratique recommandée pour garantir la sécurité et la cohérence des données encapsulées dans le Bean.

💡 À retenir

Un Bean Java doit être une classe publique, avec un constructeur par défaut, et définir ses propriétés via des champs privés accessibles uniquement par des méthodes getter et setter publiques, tout en pouvant implémenter Serializable pour la persistance.

📖 3. Sécurité Bean

🔑 Notions clés & Définitions

• Persistance via sérialisation (Serializable) : La sérialisation est un processus qui consiste à convertir un objet Java en un flux de bytes pour le stocker ou le transmettre. AUTEUR (date) : permet à un Bean d’être sauvegardé ou transféré tout en conservant son état, facilitant la persistance des données.

• Encapsulation des données dans Bean : Technique consistant à rendre les champs d’un Bean privés et à fournir des méthodes publiques (getters/setters) pour accéder ou modifier ces données. AUTEUR (date) : assure la sécurité et l’intégrité des données en contrôlant leur accès.

• Contrôle d'accès : Pratique visant à limiter la visibilité et la modification des données d’un Bean uniquement via des méthodes publiques, évitant ainsi toute modification non autorisée ou accidentelle. AUTEUR (date) : renforce la sécurité en empêchant l’accès direct aux champs.

• Bonne pratique : ne pas exposer champs publics dans Bean : Recommandation de ne pas déclarer de champs en tant que publics pour éviter leur modification directe, favorisant l’utilisation de méthodes getter/setter pour un contrôle précis. AUTEUR (date) : garantit une meilleure gestion de la sécurité et de la cohérence des données.

📝 Points essentiels

• La sérialisation (interface Serializable) permet la persistance et la transmission des Beans, facilitant leur sauvegarde ou leur partage entre différentes sessions ou applications.
• L’encapsulation, en rendant les champs privés et en utilisant des getters/setters, permet de contrôler strictement l’accès aux données, évitant toute modification non contrôlée.
• La pratique recommandée est de ne pas exposer de champs publics dans un Bean, afin de préserver la sécurité et l’intégrité des données, conformément aux principes de programmation orientée objet.
• La sérialisation doit être explicitement implémentée si la persistance ou la transmission des Beans est nécessaire, en respectant la compatibilité des versions.

💡 À retenir

La sécurité et la persistance des Beans en Java EE reposent sur la sérialisation et l’encapsulation, qui garantissent la cohérence, la sécurité et la réutilisabilité des données dans une architecture MVC.

📖 4. JSP Syntaxe

🔑 Notions clés & Définitions

• Déclaration (<%! %>) : Balise utilisée pour déclarer des variables et méthodes Java dans une page JSP, permettant de définir du code qui sera partagé dans toute la page (source : "SYNTAXE DES JSP").
• Scriptlet (<% %>) : Balise permettant d’insérer du code Java directement dans la page JSP, exécuté lors du traitement de la requête (source : "SYNTAXE DES JSP").
• Expression (<%= %>) : Balise utilisée pour évaluer et afficher une valeur Java dans la sortie HTML, facilitant l’affichage dynamique (source : "SYNTAXE DES JSP").
• Directive (<%@ %>) : Instruction spéciale pour configurer la page JSP, comme définir la langue, inclure des dépendances ou importer des bibliothèques de balises (source : "SYNTAXE DES JSP").
• Actions JSP : Balises spécifiques permettant de réaliser des opérations comme l’inclusion, la redirection, ou la gestion de beans Java, pour contrôler le flux et manipuler le contenu dynamique (source : "SYNTAXE DES JSP").

📝 Points essentiels

• La syntaxe JSP se décompose en déclarations, scriptlets, expressions, directives et actions, chacune ayant un rôle précis dans la construction d’une page dynamique (source : "SYNTAXE DES JSP").
• La déclaration <%! %> sert à définir des variables ou méthodes Java accessibles dans toute la page, permettant de préparer du code réutilisable.
• Les scriptlets <% %> insèrent du code Java à exécuter lors du traitement, mais leur usage est déconseillé au profit des expressions et balises modernes.
• Les expressions <%= %> simplifient l’affichage de valeurs Java dans la sortie HTML, évitant de recourir à des println ou autres méthodes d’écriture.
• Les directives <%@ %> configurent la page JSP, notamment pour importer des bibliothèques ou définir le langage, facilitant la modularité et la gestion du code.
• Les actions JSP, telles que <jsp:include>, <jsp:useBean>, ou <jsp:forward>, permettent de manipuler le contenu, de gérer des objets Java ou de contrôler le flux d’exécution.

💡 À retenir

La syntaxe JSP repose sur des balises spécifiques qui permettent d’intégrer, de configurer et de contrôler dynamiquement le contenu HTML avec du code Java, tout en séparant la logique de présentation de la logique métier.

📖 5. Objets Implicites JSP

🔑 Notions clés & Définitions

• Objet request : Représente la requête HTTP entrante, permettant d’accéder aux paramètres, en-têtes et autres informations de la requête (JAVA EE, Chapitre 2).
• Objet response : Représente la réponse HTTP à envoyer au client, permettant d’écrire du contenu dans la réponse (JAVA EE, Chapitre 2).
• Objet session : Représente la session utilisateur, permettant de stocker et d’accéder à des données spécifiques à une session (JAVA EE, Chapitre 2).
• Objet application : Représente le contexte de l’application web en cours, facilitant le partage de données entre différentes sessions utilisateur (JAVA EE, Chapitre 2).
• Objet out : Flux de sortie de la page JSP, utilisé pour écrire directement dans la réponse HTTP (JAVA EE, Chapitre 2).
• Objet exception : Représente l’exception levée lors de l’exécution de la page JSP, permettant la gestion des erreurs (JAVA EE, Chapitre 2).

📝 Points essentiels

• Les objets request, response, session, et application sont automatiquement accessibles dans une page JSP sans déclaration préalable, facilitant la gestion des requêtes et des sessions (JAVA EE, Chapitre 2).
• L’objet request permet d’accéder aux paramètres de la requête, aux en-têtes HTTP, et autres informations relatives à la requête entrante.
• L’objet response sert à générer la réponse HTTP, notamment en écrivant du contenu via out.
• L’objet session est utilisé pour stocker des données persistantes durant la session utilisateur.
• L’objet application permet de partager des données globales à toute l’application web.
• Les objets out, page, config, et exception sont également implicites, avec des rôles spécifiques :
  • out : flux de sortie pour écrire dans la réponse.
  • page : référence à la page JSP en cours.
  • config : configuration de la servlet JSP.
  • exception : gestion des erreurs lors de l’exécution.

💡 À retenir

Les objets implicites JSP, tels que request, response, session, et application, sont accessibles automatiquement et simplifient la gestion des requêtes, sessions et contexte de l’application, permettant un développement plus efficace et modulable.

📖 6. Directives JSP

🔑 Notions clés & Définitions

• Directives de page : Instructions placées en haut d'une page JSP délimitée par <%@ %>, permettant de définir des attributs tels que la langue, les dépendances de classes, ou les paramètres d'inclusion (voir "Syntaxe des JSP").
• Directives d'inclusion : Instructions <%@ include %> qui permettent d’incorporer le contenu d’un fichier dans la page JSP, facilitant la réutilisation et la maintenance du code (voir "Syntaxe des JSP").
• Directives taglib : Instructions <%@ taglib %> utilisées pour importer des bibliothèques de balises personnalisées, permettant d’étendre les fonctionnalités de JSP avec des balises spécifiques fournies par des frameworks ou bibliothèques tierces (voir "Syntaxe des JSP").
• Instructions JSP : Ensemble de balises <% ... %>, <%= ... %>, et <%! ... %> pour insérer du code Java, déclarer des variables ou méthodes, et gérer la configuration de la page (voir "Syntaxe JSP").
• Objets implicites : Objets prédéfinis dans JSP comme request, response, session, application, accessibles automatiquement sans déclaration, pour manipuler la requête, la réponse, la session ou le contexte de l’application (voir "Objets Implicites JSP").

📝 Points essentiels

• Les directives de page <%@ %> doivent être placées en début de fichier et permettent de définir des paramètres globaux comme la langue (contentType), la dépendance à des classes ou bibliothèques, ou des paramètres spécifiques à la page (voir "Syntaxe des JSP").
• La directive d'inclusion <%@ include file="..." %> insère le contenu d’un fichier dans la page lors de la compilation, ce qui favorise la modularité et la maintenance du code JSP (voir "Syntaxe des JSP").
• La directive de taglib <%@ taglib prefix="..." uri="..." %> permet d'importer des bibliothèques de balises, telles que JSTL, pour simplifier la gestion de la logique de présentation et réduire l’utilisation de scriptlets (voir "Syntaxe des JSP").
• Les directives facilitent la configuration de la page, la réutilisation de composants, et l’extension des fonctionnalités via des bibliothèques de balises, rendant le développement plus efficace et modulaire (voir "Les directives JSP").
• La syntaxe <%@ ... %> est essentielle pour définir les paramètres de la page, les dépendances, ou importer des bibliothèques, et doit être utilisée en début de fichier pour une bonne organisation du code JSP.

💡 À retenir

Les directives JSP sont des instructions essentielles pour configurer, modulariser et étendre une page JSP, permettant une gestion efficace des dépendances et une meilleure organisation du code.

📖 7. Actions JSP

🔑 Notions clés & Définitions

• jsp:forward (balise JSP) : balise permettant de rediriger la requête en cours vers une autre ressource (page, servlet).
• jsp:include : balise JSP utilisée pour inclure dynamiquement le contenu d'une autre ressource dans la page en cours, facilitant la modularité.
• Actions de contrôle de flux (if, else, switch) : balises JSP permettant d'exécuter conditionnellement des blocs de code selon des expressions booléennes ou des valeurs, pour gérer la logique de flux.
• Actions de répétition (forEach) : balise JSP permettant d'itérer sur une collection ou un tableau, pour répéter un traitement pour chaque élément.
• Balises <%! %> (déclaration) : balises pour déclarer des variables ou méthodes Java dans une page JSP, délimitant la section de déclaration.
• <% %> (scriptlet) : balise permettant d’insérer du code Java directement dans la page JSP pour exécuter des opérations ou manipuler des données.

📝 Points essentiels

• Les actions JSP sont des balises spéciales qui contrôlent le flux d'exécution, la redirection, l'inclusion de contenu, et la répétition de traitements dans une page JSP.
• <jsp:forward> et <jsp:include> sont essentielles pour la gestion de la navigation et la modularité, en permettant respectivement de rediriger la requête ou d'inclure du contenu externe.
• Les actions conditionnelles (if, else, switch) permettent d'exécuter ou d’ignorer certains blocs selon des conditions, facilitant la logique métier dans la présentation.
• La boucle <c:forEach> (de JSTL) ou <jsp:forEach> permet de parcourir des collections, rendant le traitement dynamique et réutilisable.
• La déclaration <%! %> et le scriptlet <% %> offrent la possibilité d’insérer du code Java dans la page, mais leur usage est généralement déconseillé au profit des balises JSTL ou EL pour une meilleure lisibilité et maintenabilité.

💡 À retenir

Les actions JSP offrent un moyen simple et efficace de contrôler la logique d'exécution, la navigation, et la répétition dans une page JSP, tout en favorisant la modularité et la clarté du code.

📖 8. Balises JSP

🔑 Notions clés & Définitions

• jsp:include (voir section 8) : balise permettant d'inclure dynamiquement le contenu d'une autre ressource (page, servlet, etc.) dans la page JSP courante, facilitant la modularité et la réutilisation de composants.
• jsp:useBean (voir section 8) : balise utilisée pour déclarer et instancier un bean Java dans une page JSP, permettant de manipuler des objets Java dans la vue.
• jsp:setProperty (voir section 8) : balise permettant de définir ou de modifier les propriétés d’un bean Java déclaré avec jsp:useBean, en lui passant des valeurs ou en les extrayant de la requête.
• jsp:getProperty (voir section 8) : balise utilisée pour accéder à une propriété spécifique d’un bean Java, afin de l’afficher ou de l’utiliser dans la page JSP.
• jsp:forward (voir section 8) : balise permettant de rediriger la requête vers une autre ressource (page, servlet), en transférant le traitement sans que l’utilisateur ne voie la transition.
• jsp:plugin (voir section 8) : balise pour insérer des plugins Java (ex : applets, applets Java) dans une page JSP, assurant leur compatibilité avec différents navigateurs.

📝 Points essentiels

• La balise <jsp:include> permet d’intégrer du contenu externe de façon dynamique, ce qui favorise la modularité et la maintenance du code.
• <jsp:useBean> facilite la gestion des objets Java dans la vue, en instanciant ou en réutilisant un bean selon le contexte, suivant la pratique du modèle MVC.
• <jsp:setProperty> et <jsp:getProperty> offrent un mécanisme simple pour manipuler les propriétés des beans, permettant de passer des données entre la logique métier et la vue.
• La balise <jsp:forward> est essentielle pour déléguer le rendu à une autre ressource, évitant la duplication de code et simplifiant la navigation.
• <jsp:plugin> est principalement utilisé pour l’intégration de composants Java dans la page, notamment pour assurer la compatibilité avec différents navigateurs.

💡 À retenir

Les balises JSP fournissent un ensemble d’outils pour inclure, manipuler et rediriger du contenu dynamique, facilitant la séparation des responsabilités dans une architecture MVC. Leur utilisation permet de rendre le développement web en Java plus modulaire, maintenable et efficace.

📖 9. Modèle MVC

🔑 Notions clés & Définitions

• Servlet (Contrôleur) : Composant qui reçoit la requête HTTP, traite la logique métier, et délègue la vue à une JSP via le RequestDispatcher.
• JSP (Vue) : Page web dynamique qui affiche le résultat du traitement, intégrant du code Java pour la présentation.
• RequestDispatcher : Objet fourni par le conteneur web permettant d'inclure ou de transférer le traitement d'une requête vers une autre ressource (ex : une JSP).
• ServletContext : Contexte d’application accessible depuis une servlet, permettant de stocker et récupérer des attributs de portée application, notamment pour obtenir un RequestDispatcher.
• Modèle (JavaBeans) : Classe Java représentant des données du monde réel, modulaire et réutilisable, encapsulant des propriétés accessibles via getters/setters, et pouvant être persisté grâce à Serializable (voir section 1).

📝 Points essentiels

• Le modèle MVC en Java EE repose sur la séparation claire des responsabilités : la servlet (contrôleur) gère la réception et le traitement de la requête, le modèle (JavaBeans) stocke et manipule les données, et la JSP (vue) affiche le résultat.
• La bonne pratique consiste à faire traiter la logique métier par la servlet, puis à déléguer la génération de la présentation à une JSP, ce qui facilite la maintenance et la réutilisation du code (voir JAVABEANS).
• Le RequestDispatcher permet à la servlet de transférer le traitement à une JSP en utilisant la méthode forward(), assurant ainsi une séparation efficace entre traitement et affichage.
• Le ServletContext fournit un accès global à l’application, notamment pour récupérer un RequestDispatcher via getRequestDispatcher(), permettant de gérer la délégation de traitement.
• La structure du Modèle (JavaBeans) doit respecter certains critères : classe publique, constructeur par défaut, propriétés encapsulées avec getters/setters, et éventuellement Serializable pour la persistance (voir JavaBeans).

💡 À retenir

Le modèle MVC en Java EE découpe le traitement d'une requête en une étape de traitement par la servlet, puis en une étape de rendu par la JSP, en utilisant le RequestDispatcher et le contexte d’application pour une architecture claire, modulaire et maintenable.

📖 10. JSTL

🔑 Notions clés & Définitions

• JSTL (Java Server Pages Standard Tag Library) : bibliothèque de balises standard intégrée aux JSP, conçue pour simplifier le développement web en Java en fournissant un ensemble de balises prédéfinies pour effectuer des opérations courantes (JAVA EE (Chapitre 2)).
• Composants principaux : regroupement de balises de base, contrôle de flux, boucle, condition, formatage, et fonctions, répartis dans cinq bibliothèques distinctes (core, fmt, sql, x, fn) (****JSTL (source)).
• Bibliothèques de tags : chaque bibliothèque offre des fonctionnalités spécifiques, par exemple, c.tld (Core Tags) pour opérations courantes, fmt.tld pour formatage internationalisé, sql.tld pour requêtes SQL, x.tld pour manipulation XML, fn.tld pour fonctions supplémentaires (****JSTL (source)).
• Utilisation : nécessite l’ajout du fichier jar correspondant dans le projet et l’inclusion d’une directive taglib dans la page JSP pour importer la bibliothèque souhaitée (**JSTL (source)).
• Objectifs : réduire la complexité du code Java dans les JSP, améliorer la lisibilité et la maintenabilité des pages web, et permettre aux webdesigners de créer des pages dynamiques sans maîtriser le Java avancé (**JSTL (source)).

📝 Points essentiels

• La JSTL vise à simplifier le travail des développeurs en leur fournissant des balises XML proches des langages de webdesigners, évitant ainsi l’utilisation excessive de scriptlets Java dans les JSP (**JSTL (source)).
• Elle permet de réduire la quantité de code Java dans les pages JSP, ce qui facilite la maintenance et la compréhension du code, tout en favorisant la réutilisation grâce à des balises et fragments modulaires (**JSTL (source)).
• La bibliothèque est composée de cinq groupes de balises, chacun dédié à une fonctionnalité précise : opérations de base, formatage, SQL, XML, et fonctions, offrant une grande flexibilité pour le développement web en Java (**JSTL (source)).
• Pour utiliser la JSTL, il faut ajouter le fichier jar dans le projet et déclarer la bibliothèque dans la JSP via la directive <%@ taglib %>, en précisant l’URI et le prefixe associé (**JSTL (source)).
• Les actions de base incluent la gestion de variables (<c:set>), conditions (<c:if>, <c:choose>), boucles (<c:forEach>), et gestion des erreurs, permettant une programmation déclarative et plus intuitive (**JSTL (source)).

💡 À retenir

La JSTL est une bibliothèque de balises standard qui facilite la création de pages JSP dynamiques en réduisant la dépendance au code Java, tout en améliorant la lisibilité et la modularité du développement web en Java EE.

📊 Tableaux de Synthèse

Aspect	JavaBeans	Structure Bean	Sécurité Bean	JSP Syntaxe	Modèle MVC & JSTL
Définition	Classe Java réutilisable, encapsulant des données	Classe publique, avec constructeur par défaut, champs privés	Encapsulation, sérialisation, contrôle d’accès	Syntaxe pour insérer du code Java dans JSP	Architecture séparant Modèle, Vue, Contrôleur et balises JSTL
Règles principales	Serializable, propriétés via getter/setter	Classe publique, constructeur par défaut, champs privés	Champs privés, pas de champs publics, sérialisation	Déclaration (<%! %>), Scriptlet (<% %>), Expression (<%= %>)	Facilite la gestion dynamique via balises et tags JSTL
Rôle dans architecture MVC	Modèle, gestion des données	Définition des propriétés et structure du Bean	Sécurise et persiste les données	Facilite la logique dynamique dans la vue	Sépare la logique métier de la présentation

⚠️ Pièges & Confusions Fréquentes

1. Confondre JavaBean et POJO : JavaBean doit suivre des règles strictes (constructeur par défaut, getter/setter, Serializable).
2. Oublier d’implémenter Serializable pour la persistance si nécessaire.
3. Définir des champs publics dans un Bean, ce qui viole le principe d’encapsulation.
4. Ne pas respecter la convention de nommage des getter/setter (ex : getNom, setNom).
5. Utiliser des scriptlets (<% %>) à outrance, au lieu d’utiliser JSTL ou EL pour la clarté.
6. Confondre déclaration (<%! %>) et scriptlet (<% %>) dans JSP.
7. Omettre la déclaration de la balise directive <%@ page %> pour importer les taglibs JSTL.
8. Ne pas maîtriser la différence entre balises JSP, actions, et balises JSTL.

✅ Checklist Examen

1. Connaître la définition précise d’un JavaBean selon JAVA EE Chapitre 2.
2. Savoir que la classe JavaBean doit être publique et posséder un constructeur par défaut.
3. Maîtriser la règle d’encapsulation : champs privés, getter/setter publics, respect du nommage.
4. Savoir que l’interface Serializable permet la persistance et la transmission des Beans.
5. Connaître le rôle du JavaBean dans le modèle MVC comme Modèle.
6. Identifier la structure d’un Bean : classe publique, champs privés, méthodes getter/setter.
7. Comprendre que la sérialisation facilite la sauvegarde et la restauration de l’état d’un Bean.
8. Savoir que la sécurité du Bean repose sur l’encapsulation et la sérialisation.
9. Maîtriser la syntaxe JSP : déclaration (<%! %>), scriptlet (<% %>), expression (<%= %>).
10. Connaître la différence entre balises JSP, actions, et balises JSTL.
11. Savoir que le modèle MVC sépare la logique métier de la présentation.
12. Vérifier la maîtrise des balises JSTL pour la gestion dynamique dans JSP.