Comme il a déjà été dit, l'interface Servlet est l'interface centrale de cette API. Toutes les instances de servlets implémentent cette interface, en général indirectement. Cette interface ne définit que cinq méthodes :

L'interface Servlet modélise un objet servlet encore très abstrait, et complètement détaché de ce que fait une servlet HTTP. En toute rigueur, une instance de Servlet est juste un objet qui vit dans un serveur, soumis à un cycle de vie très simple (création / service / destruction), qui a accès à des information de configuration et des méta-données sur lui-même.

  • init(SevletConfig) et destroy() appelée sur création et destruction de cette servlet.

  • service(ServletRequest req, ServletResponse res) : appelée lorsqu'une requête doit être traitée par une servlet. Cette méthode est générique, et est appelée par les méthodes doGet() et doPost() (entre autres).

  • getServletConfig() et getServletInfo() permettent de récupérer des informations sur la servlet.

La classe GenericServlet précise les choses : outre les implémentations des méthodes de l'interface Servlet, elle propose les méthodes suivantes.

  • init() et init(ServletConfig config) : ces méthodes permettent de gérer une partie du déroulement du cycle de vie. Nous verrons ce cycle de vie dans la suite.

  • getInitParameterNames() et getInitParameter(String name) : ces méthodes permettent de récupérer les paramètres d'initialisation de cette servlet, déclarés dans le web.xml.

  • log(String msg) et log(String message, Throwable t) : enfin ces méthodes permettent d'enregistrer des messages dans les fichiers journal du container. Ces méthodes n'ont que peu d'intérêt, on préfèrera en général utiliser des utilitaires comme Log4J ou slf4J.

Enfin la classe HttpServlet nous fait réellement entrer dans les servlets pour le web. Elle propose un jeu de méthodes pour chaque requête HTTP qui existe : doDelete(), doGet(), doHead(), doOption(), doPost(), doPut(), doGet() doTrace() et doLastModified(). Les implémentations de ces méthodes sont vides : elles ne remplissent aucune fonction. Simplement, elles sont appelées par le container de servlets sur requête d'un client, avec les bons paramètres, de type HttpServletRequest et HttpServletResponse. Pour programmer une servlet, il faut donc étendre cette classe, et fournir une implémentation qui convient à toute ou partie de ces méthodes. En général, ce sont les méthodes doGet() et doPost() qui sont étendues.

Le cycle de vie d'une servlet est entièrement contrôlé par le serveur d'application dans lequel vit cette servlet. Lorsqu'une requête arrive, qui doit être traitée par une servlet donnée, le serveur examine s'il possède déjà une instance de cette servlet.

Si ce n'est pas le cas, il en crée une, après avoir chargé la classe de cette servlet s'il ne l'a pas déjà fait. Une fois cette instance créée, il appelle la méthode init() de cette servlet, pour lui signaler qu'elle doit se préparer à traiter des requêtes. Une fois cette méthode exécutée, la servlet peut traiter des requêtes.

Cette méthode init() est appelée par le serveur d'application avec un objet de type ServletConfig en paramètre. C'est par cet objet qu'une servlet peut accéder à ses paramètres d'initialisation.

Les paramètres d'initialisation sont déclarés dans l'élément servlet du fichier web.xml, et sont lus dans la méthodes init(), via l'objet ServletConfig.



Si une servlet ne peut pas traiter de requête, alors elle doit jeter l'exception UnavailableException lors de l'exécution de sa méthode init().

Java servlet et JSP
Retour au blog Java le soir
Cours & Tutoriaux

Table des matières

Introduction
1. Position de l'API Servlet
2. Présentation
Présentation de Tomcat
1. Un peu d'histoire
2. Organisation des répertoires de Tomcat
2.1. Répertoire bin
2.2. Répertoire conf
2.3. Répertoire lib
2.4. Répertoire log
2.5. Répertoire temp
2.6. Répertoire webapp
2.7. Répertoire work
3. Lancement de Tomcat
3.1. Lancement par défaut
3.2. Accéder à l'administration de Tomcat
3.3. Plusieurs instances de Tomcat
4. Configuration de Tomcat
4.1. Introduction
4.2. Élément Server
4.3. Élément Service
4.4. Élément Connector
4.5. Élément Engine
4.6. Élément Host
4.7. Élément Context
4.8. Élément GlobalNamingResources
4.9. Élément Realm
4.10. Élément Valve
5. Définition et chargement des applications web
5.1. Introduction
5.2. Prise en compte des éléments Context
5.3. Chargement et mise à jour à chaud
6. Utilisation de Tomcat avec Apache
API Servlet
1. Introduction
2. Une première servlet
2.1. Le code
2.2. Création de l'application web
2.3. Déploiement dans Tomcat
3. Concepts, cycle de vie
3.1. Requête
3.2. Réponse
3.3. Session
3.4. Application web
3.5. Contexte d'exécution
3.6. Cycle de vie
3.7. Filtre
4. Présentation générale de l'API
4.1. Introduction
4.2. Interfaces disponibles
5. Notion de servlet
5.1. Interfaces servlet
5.2. Cycle de vie d'une servlet
5.3. Paramètres d'initialisation d'une servlet
6. Notion de requête
6.1. Accès aux paramètres d'une requête
6.2. Accès aux éléments de l'en-tête HTTP
6.3. Accès aux éléments de l'URL
6.4. Accès aux paramètres du client
6.5. Accès aux informations de sécurité
6.6. Accès à la session, au contexte et aux informations d'initialisation
7. Notion de réponse
7.1. Contrôle du buffer de sortie
7.2. Contrôle de la réponse HTTP
8. Notion de session HTTP
9. Redirection ou inclusion d'une ressource
10. Listeners
10.1. Introduction
10.2. Événements de l'API Servlet
10.3. Ajout ou retrait d'un attribut
10.4. Création et destruction d'un contexte
10.5. Notification d'un objet attaché à un contexte
10.6. Déclaration d'un listener dans une application web
11. Connexion à une base
11.1. Introduction
11.2. Connexion manuelle
11.3. Connexion par utilisation de source de données
Filtrage
1. Filtrage de servlets
2. Mise en place d'un filtre
2.1. Écriture d'un filtre
2.2. Déclaration du filtrage
3. Filtrage d'une requête
4. Filtrage d'une réponse
4.1. Fonctionnement de ce filtrage
Java Server Pages
1. Introduction
2. Un premier exemple
2.1. Une première JSP statique
2.2. Une première JSP dynamique
2.3. Fonctionnement interne des JSP
3. JSP scriplet
3.1. Les expressions
3.2. Les déclarations
3.3. Variables prédéfinies
3.4. Scriplet de directives
4. Utilisation de beans
4.1. Introduction
4.2. Déclaration d'un bean existant
4.3. Création d'un nouveau bean
4.4. Utilisation des propriétés d'un bean
5. Inclure un contenu externe dans une JSP
5.1. Introduction
5.2. Inclusion au lancement de l'application
5.3. Inclusion au traitement de la requête
6. Utilisation de bibliothèques de tags
6.1. Introduction
6.2. Bibliothèque core
7. Internationalisation
7.1. Notion de bundle
7.2. Internationalisation de pages JSP
Projet exemple
1. Présentation du projet