Ces deux interfaces modélisent une requête HTTP. Elles exposent donc des méthodes qui permettent d'accéder à l'ensemble des paramètres, en-têtes, et plus généralement au contenu d'une telle requête.

Plusieurs méthodes permettent d'accéder aux éléments de l'en-tête.

  • getHeaderNames(): retourne les noms des paramètres d'en-tête déclarés dans cette requête, sous forme d'une Enumeration.

  • getHeader(String), getIntHeader(String) et getDateHeader(String) : retournent la valeur du paramètre de l'en-tête dont on donne le nom, sous forme d'une String, d'un int ou d'une Date respectivement.

  • getHeaders() : retourne l'ensemble des noms des éléments de l'en-tête HTTP disponibles dans cette requête, sous forme d'une Enumeration.

  • getMethod() : retourne le nom de la méthode HTTP utilisée pour cette requête ( GET, POST, etc...).

  • getCharacterEncoding() : retourne l'encodage utilisé pour cette requête. Par défaut l'encodage utilisé par HTTP est ISO-8859-1, mais les autres encodages, notamment l'UTF-8 peut aussi être utilisé. Notons qu'il existe une méthode setCharacterEncoding() qui permet de forcer l'encodage. Elle doit obligatoirement être appelée avant tout accès au contenu de la requête HTTP.

  • getLocale() et getLocales() retournent le contenu de l'élément d'en-tête Accept-Language, qui indique la locale par défaut supportée par le navigateur. C'est à partir de ce paramètre qu'une application peut décider d'envoyer des pages en français ou en anglais par exemple.

  • getContentType() et getContentLength() permettent d'accèder au type MIME du contenu de la requête, et au nombre d'octets qui la composent.

  • getInputStream() retourne un flux binaire de type ServletInputStream sur la requête directement, qu'il est donc possible de traiter sans passer par toutes ces méthodes.

Les éléments de l'URL d'accès à la ressource que nous sommes en train de traiter sont exposés au travers de trois variables : contextPath, servletPath et pathInfo. Ces trois variables sont accessibles via leurs getters standards.

De plus, deux variables sont disponibles : requestURI et requestURL.

  • getRequestURI() : URI de la requête, c'est-à-dire ce qui se trouve entre le groupe {nom du protocole, nom du serveur, port} et les paramètres de la requête.

  • getRequestURL() : retourne l'URL complète de la requête. Notons que le type de retour est StringBuffer, ce qui permet de modifier cette URL facilement et efficacement.

  • getContextPath() : retourne le chemin sous lequel se trouve l'application web dans laquelle se trouve cette servlet. Il correspond à l'attribut path de l'élément Context du fichier context.xml de cette application web, dans le cas de Tomcat. Si la valeur de path vaut /, alors le contextPath est vide.

  • getServletPath() : retourne le chemin sous lequel se trouve cette ressource, sous le chemin de l'application web. Cette valeur correspond à l'élément servlet-mapping du fichier web.xml de cette application web. Si servlet-mapping vaut / alors servletPath est vide.

  • getPathInfo() : retourne ce qui reste à retourner. Dans le cas d'une servlet, pathInfo est vide. Dans le cas d'une ressource statique (une image, ou une page HTML), pathInfo correspond au nom de cette ressource.

Chacune de ces trois variables, si elle n'est pas vide, commence toujours par le caractère /.

Notons qu'une page JSP est une servlet, que son servletPath porte le nom de cette page et que son pathInfo est vide.

Notons enfin que l'on a toujours :

    requestURI = contextPath + servletPath + pathInfo
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