L’API Servlet est un jeu de classes Java qui permettent d’écrire des objets capables de recevoir des requêtes HTTP via un serveur web, de les traiter et d’y répondre. Pour des raisons de performance, une servlet a une vie différente de celle d’un objet classique. Là où il est possible d’instancier explicitement un objet Java, une servlet a une vie permanente et son cycle de vie est entièrement géré par un container. Elle peut être commandée dès l’allumage du serveur web, ou à la première requête qui la concerne. Une fois créée, elle n’est pas détruite, et reste disponible pour traiter les requêtes suivantes. Une servlet a donc une forme de persistance dans le temps, qui a des conséquences sur la façon dont on la programme.

Pour gérer cette forme de persistance, une servlet vit dans un environnement particulier. Elle vit dans un container de servlets, qui est capable de prendre en charge plusieurs servlets, et sait à laquelle transmettre une requête entrante. Un tel container possède certaines fonctionnalités propres à un serveur web, comme la possibilité d’écouter le port 80 et de décoder les requêtes HTTP. Il sait aussi démarrer une machine Java, instancier des servlets dedans, les initialiser en leur passant éventuellement des paramètres, les associer à des URL précises et leur passer les requêtes.

Le container de servlets que nous allons présenter, est le container de référence de l’API Servlet. Il s’agit de Tomcat, sa version 6.0.*. Ce container est aussi capable de gérer des JSP et des JSTL, que nous verrons plus loin. Tomcat est un outil logiciel entièrement écrit en Java. Il est donc disponible sur toute machine / architecture possédant une machine Java. Il possède toutes les fonctionnalités d’un serveur web, et est donc capable de gérer des sites web complets. Toutefois, il n’est pas aussi complet en termes de fonctionnalités que peut l’être Apache. Comme il se trouve que ces deux projets sont développés par la même association (ASF : Apache Software Foundation), Apache et Tomcat ont été construits pour dialoguer ensemble. L’architecture classique est donc la suivante : Apache gère les sites et leur contenu « statique », et fait suivre les requêtes « dynamiques » à Tomcat.

Les fonctionnalités de l’API Servlet et des JSP n’ont cessé de s’étendre ces dernières années, et ont conduit au développement de la notion d’ « applications web ». Nous verrons ce qu’est une application web, et comment cette notion peut simplifier grandement le travail des développeurs notamment dans la distribution de leurs applications.

Enfin, le tableau suivant nous donne les principales versions de Tomcat, et les versions de l'API Servlet que chacune de ces versions implémente.


Notons qu'à l'heure actuelle, la version 5 de Java est obsolète. La plupart de ces versions ne sont citées ici que pour des raisons historiques.

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