Applications Web
avec les servlets
Remarques préliminaires
Ce document est consacré à la mise en œuvre de la technique des servlets dans un contexte de logiciels Open Source ou en version gratuite.
Système d’exploitation utilisé: Microsoft Windows NT4 Workstation
Logiciels utilisés :
Apache 1.3
Tomcat 4.1
JBuilder 6 Foundation (Sun JDK 1.3)
MySQL 3.23
Ce document n’a pas la prétention d’être exhaustif, loin s’en faut. Son objectif est de permettre d’acquérir les compétences de base dans l’écriture de classes serveur en java.
Les exemples qui y figurent ont été testés dans l’environnement logiciel cité ci-dessus. Ils devraient fonctionner sans modification dans les environnements Windows 2000, ainsi que sous Linux.
Ces exemples cités sont centrés sur la programmation de l’API Servlet, sans aucunement se soucier des exigences d’une conception technique sérieuse (faible couplage,…).
De même, le projet exemple qui est attaché à ce document se focalise uniquement sur la technique de programmation des servlets, en ignorant toute démarche (UML) de spécification et conception. Il est évident qu’un projet réel, par exemple dans un contexte de synthèse, devrait largement faire appel aux classes issues de la conception technique, telles que classes ihm, contrôleurs, accès aux données…
Présentation
Applications Web
Les applications liées au Web mettent en relation des clients Web (navigateurs) avec des données et des applications situées sur un ou des serveur(s) au travers de protocoles standards d'Internet. Le développement de ces applications s'est accompagné d'une évolution des architectures informatiques.
Dans les années 1990, c'est le règne des applications client-serveur.
Ce type d'applications possède 2 niveaux:
le client, avec une interface utilisateur complexe et une bonne part du traitement applicatif, qui accède au travers d'un réseau, via des échanges de type SQL, à un
serveur distant gérant la base de données.
Dans une application client-serveur typique, un programme s'exécutant sur une machine dite serveur propose ses services au travers d'un réseau. Sur une autre machine dite client, s'exécute un programme qui émet des requêtes vers des machines serveur, afin d'utiliser les
services proposés via une connexion sur le réseau.
288925128905requête
réponse
client
serveur
réseau (local, étendu, ...)
00requête
réponse
client
serveur
réseau (local, étendu, ...)
Un programme serveur peut gérer, en général, plusieurs requêtes à la fois provenant de clients différents ou identiques. Un programme client peut, en général, utiliser plusieurs connexions vers des serveurs différents ou identiques en même temps.
Ces deux machines logiques (car le programme client peut fonctionner sur la même machine physique que le programme serveur) utilisent un ensemble de protocoles pour communiquer entre elles. Ces protocoles sont un ensemble de règles à respecter de part et d'autre pour pouvoir communiquer correctement selon les informations à échanger.
Les architectures mises en place actuellement sont multi-niveaux (multi-tiers en anglais). Le plus couramment, elles possèdent 3 niveaux (3-tiers), avec dans le cas du web:
niveau 1: un niveau présentation, comportant des postes clients légers standardisés (navigateur) et le serveur Web (protocole HTTP)
niveau 2: un niveau serveur intermédiaire, comportant un serveur d'applications qui supporte la logique applicative (scripts, programmes)
niveau 3: un niveau serveur de données, supportant un SGBD
10604527940réponse
client
serveur
réseau
internet / intranet
Serveur Web
Environnt d'exécution de scripts/ programs serveur
Serveur de bases de données
niveau 1
niveau 2
niveau 3
requête
00réponse
client
serveur
réseau
internet / intranet
Serveur Web
Environnt d'exécution de scripts/ programs serveur
Serveur de bases de données
niveau 1
niveau 2
niveau 3
requête
La grande différence entre site Web et application Web réside dans le fait que l'état interne du serveur évolue dans le second cas.
Typiquement, une application Web se déroule de la façon suivante:
le navigateur installé sur le poste client récupère les données saisies par l'utilisateur
le navigateur envoie une requête au serveur Web
le serveur Web récupère les informations utilisateur, et active le programme demandé sur le serveur d'applications
le serveur d'applications exécute le programme demandé (par exemple en accédant à une base de données), assemble des données et les renvoie au serveur Web
le serveur Web renvoie les données résultantes au navigateur du client.
Dans ce cours, nous mettrons en oeuvre des serveurs d'applications Java, en exploitant une partie de l'architecture d'entreprise préconisée par Sun (J2EE : Java 2 Enterprise Edition): les servlets (classes java serveur), et jdbc (connexion aux bases de données).
Le protocole HTTP
La plupart des clients Web utilisent le protocole HTTP pour communiquer avec un serveur. Ce protocole définit le type de requête qu'un client peut envoyer au serveur, et la réponse que celui-ci peut envoyer en retour. Chaque requête mentionne une URL, qui est une chaîne de caractères identifiant une ressource (composant ou objet statique tel qu'une page HTML ou un fichier image).
Requêtes HTTP
Une requête HTTP comporte une méthode de requête, une URL de requête, des champs d'en-tête et un corps. Parmi les méthodes de requête définies dans HTTP 1.1 les suivantes
GET - extrait du serveur la ressource identifiée par l'URL de requête.
HEAD - retourne les champs d'en-tête identifié par l'URL de requête.
POST - envoie au serveur les données assemblées d'une page (pas de limite de longueur).
sont supportées par le protocole HTTP 1.0.
Réponses HTTP
Une réponse HTTP comporte un code de retour, des champs d'en-tête, et un corps. Le code de retour et les champs d'en-tête sont envoyés avant le corps. Les valeurs de codes de retour sont regroupées par plages:
100-199: information
200-299: succès
300-399: redirection
400-499: erreur client
500-599: erreur serveur
Ainsi, parmi les codes de retour d'erreurs,
404 - indique que la ressource demandée est indisponible.
401 - indique que la requête nécessite une authentification HTTP.
500 - indique une erreur interne au serveur qui l'empêche de satisfaire la requête.
503 - indique que le serveur HTTP est temporairement surchargé, et incapable de
satisfaire la requête.
Le type de contenus MIME (Multipurpose Internet Mail Extension) s'exprime par une syntaxe type/sous-type. Par exemple
text/html, text/plain, application/octet-stream
Les Servlets
Introduction
Une servlet est un composant logiciel écrit en java et installé sur un serveur (server-applet). Ce composant s'exécute dans un serveur d'applications spécifique à la technologie java, un conteneur de servlets; classiquement celui-ci est hébergé sur un serveur web.
Une servlet peut servir à
créer des pages HTML dynamiques
effectuer des traitements applicatifs sur le serveur avant d'envoyer la réponse à un client
écrire une application java dont l'interface homme/machine apparaît dans un navigateur (avec ses limitations)
Sur le plan technique, une servlet est une classe java utilisée sur un serveur d'applications fonctionnant avec des clients sur un mode d'échange requête-réponse. Les servlets peuvent a priori prendre en compte n'importe quel type de requête; le plus fréquemment, elles permettent d'étendre les possibilités de serveurs Web, et dans ce cas, des classes spécifiques prennent en compte le protocole HTTP.
D'autre part, les Java Server Pages (JSP) offrent, au même titre que les techniques ASP ou PHP, la possibilité de mélanger HTML et langages de programmation serveur: une JSP permet donc d'inclure des instructions en java dans une page HTML; ces instructions seront exécutées au sein d'une servlet sur le serveur avant l'envoi de la réponse au client.
Certains moteurs de servlets sont gratuits (dont celui fourni par Sun), et fonctionnent sous plusieurs systèmes d'exploitation (Windows, Linux, ...). Dans notre cas, nous utiliserons un moteur de servlet Tomcat , éventuellement couplé à un serveur HTTP Apache.
Remarque
Une seule servlet gère les requêtes de plusieurs clients; un thread est généré à chaque requête client.
L'API servlet
La programmation des servlets se fait à l'aide de l'API servlet: les classes et interfaces nécessaires sont regroupées dans 2 packages javax.servlet, et javax.servlet. Le premier package javax.servlet est générique, c'est-à-dire indépendant de tout protocole, tandis que le deuxième package javax.servlet.http est spécifique au protocole HTTP, et supporte la notion de session (voir plus loin).
Toute servlet doit implémenter l'interface javax.servlet.Servlet. Parmi les méthodes de celle-ci, citons
void init (ServletConfig config) : cette méthode n'est appelée qu'une seule fois lors du chargement en mémoire de la servlet par le moteur de servlets.
void service (ServletRequest req, ServletResponse res) : cette méthode est appelée automatiquement par le moteur de servlets à chaque requête de client, et correspond au service que rend la servlet; elle possède 2 paramètres correspondant d'une part à la requête issue du client, d'autre part à la réponse fournie par le serveur.
void destroy() : cette méthode n'est appelée qu'une seule fois lors de la destruction de la servlet, et permet de libérer des ressources allouées par init() .
La classe abstraite javax.servlet.GenericServlet implémente l'interface Servlet.
Afin de prendre en compte le protocole HTTP, une sous-classe de javax.servlet.GenericServlet a été incluse dans le package javax.servlet.http: il s'agit de la classe abstraite javax.servlet.http.HttpServlet . Cette classe redéfinit la méthode service() de la classe mère: selon la méthode HTTP utilisée par le client, elle redirige la requête vers une des 2 méthodes
void doGet (HttpServletRequest req, HttpServletResponse res) , si le client a émis une requête de type GET
void doPost (HttpServletRequest req, HttpServletResponse res) , si le client a émis une requête de type POST.
Dans ces 2 méthodes, les paramètres de types HttpServletRequest et HttpServletResponse correspondent à la requête du client et à la réponse du serveur.
Pour créer une servlet HTTP, il suffit de définir une classe fille de javax.servlet.http.HttpServlet, et de redéfinir au moins une des méthodes doGet() et doPost() . Une servlet minimale se présente donc comme suit:
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
public class ServletMinimale extends HttpServlet
{
public void doGet(HttpServletRequest req,
HttpServletResponse res)
throws ServletException, IOException
{
PrintWriter out = res.getWriter();
}
}
la variable req sert à lire les en-têtes HTTP, par exemple des cookies, et les données du formulaire HTML soumises par le client.
la variable rep permet de manipuler le code de retour de la réponse HTTP, et les en-têtes (type de contenu, cookies)
la variable out désigne l'instance de flux de sortie à destination du navigateur du client
Une simple servlet générant du texte
Voici le code d'une servlet générant du texte:
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
public class BonjourMonde extends HttpServlet
{
public void doGet(HttpServletRequest req,
HttpServletResponse res)
throws ServletException, IOException
{
PrintWriter out = res.getWriter();
out.println("Bonjour Monde!");
}
}
Par défaut, le type MIME de la réponse est en texte.
Mise en place de l'environnement de développement
Organisation du développement
A chaque application Web destinée à fonctionner sous Tomcat 4.1 correspond un sous-répertoire de CATALINA_HOME/webapps . Dans ce sous-répertoire apparaissent
des documents statiques (pages html, images, sons, ...)
des servlets
des JSP
des classes utilitaires
des applets côté client, beans, …
des méta-informations de description des éléments ci-dessus (fichiers XML). Le paramétrage correspondant est décrit au paragraphe déploiement.
Compilation
Les packages de l'API servlet ne font pas partie du jdk standard. Il faut donc récupérer le fichier .jar de ces packages et les rendre accessibles lors de la compilation. Pour cela, il faut modifier les propriétés de projet de JBuilder6, en ajoutant une nouvelle bibliothèque dont le fichier classe est servlet.jar. De même, de façon à bénéficier de l’aide en ligne sur le package servlet, il faut récupérer les fichiers de documentation sur l’API servlet, constituer un fichier jar par
cd
jar cvf servletAPI_docs.jar *.*
puis modifier les propriétés de projet en conséquence
Ces manipulations devraient permettre de compiler une servlet simple (voir un peu plus loin).
Pour pouvoir mettre au point localement une servlet sous Tomcat, il est nécessaire d’ajouter au projet une librairie supplémentaire concernant les packages de Tomcat 4.1.12 (composée des fichiers .jar situés sous le CATALINA_HOME). Dans ce cas, la classe cible est org.apache.catalina.startup.Catalina.
L’utilisation du driver jdbc pour MySQL nécessite également la modification des propriétés de projet pour inclure le fichier .jar dans la bibliothèque correspondante.
Déploiement
Les servlets sont exécutées par le conteneur de servlets au sein d'une "application Web".
Pour un environnement de développement composé de JBuilder 6 Foundation et Tomcat 4.1.12, ce paramétrage peut se faire manuellement en définissant ou modifiant quelques fichiers xml.
Il importe de préciser que le principe du déploiement décrit ci-dessous n'est envisageable que dans le contexte de l'apprentissage du développement de servlets: en entreprise, sur des applications en production, les répertoires cibles de l'application Web sont protégés, et c'est l'administrateur Web qui octroie les droits en fonctions des profils et de l'état d'avancement de l'application. Ces tâches de gestion de versions et de déploiement sont prises en charges par des environnements de développement plus sophistiqués, tels que JBuilder Professionnel ou Entreprise.
Soit à développer une application Web appelée monAppliWeb, contenant par exemple une servlet nommée BonjourMonde.
dans le répertoire CATALINA_HOME/webapps
créer un répertoire monAppliWeb
sous ce répertoire créer un répertoire WEB-INF
dans le répertoire CATALINA_HOME/webapps/monAppliWeb/WEB-INF, créer un fichier web.xml de contenu
Application Web monAppliWeb
Exemple de servlets et pages JSP sous Tomcat .
BonjourMondeBonjourMonde
sous le répertoire WEB-INF créer un répertoire classes
recopier BonjourMonde.class dans ce répertoire
Sous JB6, dans les propriétés de projet, modifiez le chemin de sortie à CATALINA_HOME/webapps/monAppli/WEB-INF/classes, de façon à éviter d'y recopier systématiquement le fichier .class
Dans le répertoire de CATALINA_HOME/conf
éditer server.xml
sous le contexte , créer un contexte pour l'application monAppliWeb
éditer web.xml
enlever le commentaire entourant l'élément servlet-mapping relatif à l'invoker de servlet
invoker/servlet/*
Arrêter/redémarrer Tomcat.
On invoque la servlet BonjourMonde dans un navigateur sur le serveur en entrant l'URL:
http://localhost:8080/monAppliWeb/servlet/BonjourMonde
2889251460500
Mise au point
debugger une servlet sous JB6 Foundation
Le debugger n'est utilisable au sein d'une servlet qu'en mode local. Il suffit de naviguer entre la fenêtre du navigateur et l'environnement JB6. Comme les flux sont bufferisés, il peut être utile d'insérer une instruction du type
out.flush( );
avant l'instruction sur laquelle le point d'arrêt est positionné afin de voir l'état en cours de l'affichage dans le navigateur.
0000
Recommandations
Quelques recommandations simples
jeter un oeil au code HTML généré
retourner des pages d'erreur au client
exploiter les fichiers logs du serveur
arrêter et redémarrer le serveur (si reloadable="true" n'a pas été mentionné pour l'application Web).
Premières servlets
Une simple servlet générant du HTML
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
public class BonjourWWW extends HttpServlet
{
public void doGet(HttpServletRequest req,
HttpServletResponse res)
throws ServletException, IOException
{
res.setContentType("text/html");
PrintWriter out = res.getWriter();
String docType =
"\n";
out.println(docType +
"\n" +
"Bonjour WWW\n" +
"\n" +
"
Bonjour Monde du WWW!
\n" +
"");
}
}
La méthode setContentType() permet de définir le type de contenu MIME de la réponse.
Une servlet dans un package
Si la servlet fait partie d’un paquet
package monPaquet;
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
public class BonjourWWW2 extends HttpServlet
{
public void doGet(HttpServletRequest req,
HttpServletResponse res)
throws ServletException, IOException
{
res.setContentType("text/html");
PrintWriter out = res.getWriter();
String docType =
"\n";
out.println(docType +
"\n" +
"Bonjour WWW\n" +
"\n" +
"
Bonjour WWW
\n" +
"servlet en paquetage\n" +
"");
}
}
Cette servlet s'invoque par l'URL:
http://localhost:8080/monAppliWeb/servlet/monPaquet.BonjourWWW2
Utilisation d'une classe utilitaire
Pour la plupart des cas, l'écriture d'une partie de la page HTML peut être déléguée à une classe utilitaire:
package dg;
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
public class Utils
{
public static final String DOCTYPE =
"";
public static void ecritDebut(PrintWriter p,String titre)
{
p.println(DOCTYPE + "\n" +
"\n" +
"" + titre + "\n ");
}
public static void ecritFin(PrintWriter p)
{
p.println("");
}
}
L'utilisation de ce package dans la servlet:
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
import dg.Utils;
public class BonjourWWW3 extends HttpServlet
{
public void doGet(HttpServletRequest req,
HttpServletResponse res)
throws ServletException, IOException
{
res.setContentType("text/html");
PrintWriter out = res.getWriter();
dg.Utils.ecritDebut(out,"Servlet et classe utilitaire");
out.println("
Hello WWW
\n");
dg.Utils.ecritFin(out);
}
}
Passer des paramètres d'initialisation à une servlet
L'interface javax.servlet.Servlet comporte des méthodes qui permettent de contrôler le cycle de vie d'une servlet; en particulier,
void init() étant appelée une seule fois au chargement initial de la servlet, c'est l'endroit idéal pour passer des paramètres d'initialisation à une servlet, établir des connexions réseaux, ouvrir une base de données, ...
void destroy() étant appelée au déchargement de la servlet ou à l'arrêt du moteur de servlet, c'est l'endroit idéal pour clôturer des connexions réseaux, ou fermer une base de données, ...
La méthode init() possède 2 signatures
public void init(ServletConfig conf) throws ServletException
Dans cette méthode, il est impératif d'appeler la méthode init de la classe mère, par
super.init(conf);
Le paramètre de cette méthode init(), de type ServletConfig, possède lui-même une méthode getInitParameter(), qui permet de récupérer des paramètres nécessaires au fonctionnement de la servlet; ces paramètres d'initialisation sont définis dans le fichier web.xml de l'application Web.
public void init() throws ServletException
Cette méthode ne permet pas d'accéder aux paramètres d'initialisation de la servlet, et l'appel à la méthode init() de la classe mère ne doit pas être effectué.
Voici une servlet qui récupère 2 paramètres
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
import dg.Utils;
public class InitParamServlet extends HttpServlet
{
private String m_strMessage;
private int m_nCpt = 1;
public void init(ServletConfig conf) throws ServletException
{
// impératif d'appeler super.init()
super.init(conf);
m_strMessage = conf.getInitParameter("titre");
if (m_strMessage == null)
{
m_strMessage = "Titre par défaut";
}
try
{
String strCptr = conf.getInitParameter("compteur");
m_nCpt = Integer.parseInt(strCptr);
}
catch(NumberFormatException nfe){}
}
public void doGet(HttpServletRequest req,
HttpServletResponse res)
throws ServletException, IOException
{
res.setContentType("text/html");
PrintWriter out = res.getWriter();
dg.Utils.ecritDebut(out,m_strMessage);
out.println("Cette servlet récupère 2 paramètres ");
out.println("d'initialisationdans le fichier web.xml ");
out.println("premier paramètre: titre");
out.println(m_strMessage+" ");
out.println("deuxième paramètre: compteur");
out.println(m_nCpt);
out.println(" ");
for(int i=0; i");
}
dg.Utils.ecritFin(out);
}
}
Les 2 paramètres sont l'un de type String, l'autre de type int. Comme ces paramètres sont saisis manuellement dans le fichier web.xml, il est nécessaire de gérer une exception sur le parsing d'entier pour le second paramètre.
Voici le fichier web.xml correspondant
Application Web monAppliWeb
Exemple de servlets et pages JSP sous Tomcat .
S4InitParamServlettitreHarry Pottercompteur7
Le résultat :
1460511112500
Redirection vers une autre URL
La méthode sendRedirect() de la classe HttpServletResponse permet de rediriger le client vers une autre URL. L’exemple consacré au suivi de session en illustre l’utilisation.
Formulaires et servlets
Récupérer les valeurs de paramètres d'un formulaire
Soit le formulaire
Formulaire a trois parametres
formulaire appelant une servlet
Les données de ce formulaire peuvent être récupérées par la méthode getParameter() de l'objet de type HttpServletRequest; cette méthode attend explicitement le nom du paramètre du formulaire, tel que "prenom", "age", ...
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
import dg.Utils;
public class Param1 extends HttpServlet
{
public void doGet(HttpServletRequest req,
HttpServletResponse res)
throws ServletException, IOException
{
res.setContentType("text/html");
PrintWriter out = res.getWriter();
dg.Utils.ecritDebut(out,"paramètres reçus par la servlet");
out.println("
\n" +
"
Nom: "
+ req.getParameter("nom") + "\n" +
"
Prénom: "
+ req.getParameter("prenom") + "\n" +
"
Age: "
+ req.getParameter("age") + "\n" +
"
\n");
dg.Utils.ecritFin(out);
}
}
1460552641500
Conformément au principe de la méthode GET, les paramètres sont transmis sur l'URL.
Si dans le formulaire ci-dessus, on invoque la servlet par la méthode POST, par la ligne
et la servlet activée
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
import java.util.*;
import dg.Utils;
public class Param3 extends HttpServlet
{
public void doGet(HttpServletRequest req,
HttpServletResponse res)
throws ServletException, IOException
{
res.setContentType("text/html");
PrintWriter out = res.getWriter();
dg.Utils.ecritDebut(out,"tous les paramètres reçus :");
out.println("
\n");
dg.Utils.ecritFin(out);
}
public void doPost(HttpServletRequest req,
HttpServletResponse res)
throws ServletException, IOException {
doGet(req, res);
}
}
La méthode getParameterNames() de la requête retourne une Enumeration dont chaque élément, transtypé en String, est le nom d'un paramètre du formulaire.
La méthode getParameterValues( ) de la requête, à laquelle il faut passer le nom du paramètre du formulaire, retourne un tableau de String contenant la ou les valeurs du paramètre du formulaire.
Le résultat affiché est
0000
Interface avec les bases de données
L’accès aux bases de données dans une servlet se fait à l’aide de l’API jdbc. L’utilisation de cette API est décrite par exemple dans le support de N. Lepeltier et J.C. Corre qui y est consacré.
Soit, sous MySQL, une base de données commerce qui possède une table produit:
14605698500
Voici une servlet qui en affiche le contenu
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
import java.sql.*;
import dg.Utils;
public class Servlet2 extends HttpServlet
{
public void doPost(HttpServletRequest req,
HttpServletResponse res)
throws ServletException, java.io.IOException
{
doGet(req,res);
}
public void doGet(HttpServletRequest req,
HttpServletResponse res)
throws ServletException, java.io.IOException
{
Connection con = null;
Statement stmt = null;
ResultSet result;
String url = "jdbc:mysql://localhost:3306/commerce";
res.setContentType("text/html");
PrintWriter out = res.getWriter();
dg.Utils.ecritDebut(out,"Servlet2 et accès MySQL");
out.println("Servlet2: ");
try
{
Class.forName("org.gjt.mm.mysql.Driver");
}
catch (Exception e)
{
out.println("
Pb de chargement du pilote jdbc !");
dg.Utils.ecritFin(out);
return;
}
try
{
con = DriverManager.getConnection(url,"guevar","");
stmt = con.createStatement();
}
catch (Exception e)
{
out.println("
Pb de connexion !");
dg.Utils.ecritFin(out);
return;
}
out.println("
");
out.println("
n°
Produit
Prix
");
try
{
/* System.out.println("connection successful!");*/
result = stmt.executeQuery("SELECT * FROM produit");
while( result.next() )
{
out.println("
");
out.println("
"+result.getInt(1)+"
");
out.println("
"+result.getString(2)+"
");
out.println("
"+result.getFloat(3)+"
");
}
}
catch (SQLException e)
{
out.println("
Pb de requete!");
dg.Utils.ecritFin(out);
return;
}
finally
{
out.println("
Pb fermeture de la connexion!");
}
}
public void doPost(HttpServletRequest req,
HttpServletResponse res)
throws ServletException, java.io.IOException
{
doGet(req,res);
}
public void doGet(HttpServletRequest req,
HttpServletResponse res)
throws ServletException, java.io.IOException
{
ResultSet result;
res.setContentType("text/html");
PrintWriter out = res.getWriter();
dg.Utils.ecritDebut(out,"Servlet3 et accès MySQL");
out.println("Servlet3: ");
if (m_con == null)
{
out.println("
Pas de connexion établie!");
dg.Utils.ecritFin(out);
return;
}
else try
{
m_stmt = m_con.createStatement();
}
catch (Exception e)
{
out.println("
Pas de statement établi!");
dg.Utils.ecritFin(out);
return;
}
out.println("ouverture connexion dans init() ");
out.println("fermeture connexion dans destroy()");
out.println("
");
out.println("
n°
Produit
Prix
");
try
{
/* System.out.println("connection successful!");*/
result = m_stmt.executeQuery("SELECT * FROM produit");
while( result.next() )
{
out.println("
");
out.println("
"+result.getInt(1)+"
");
out.println("
"+result.getString(2)+"
");
out.println("
"+result.getFloat(3)+"
");
}
}
catch (SQLException e)
{
out.println("
Pb de requete!");
dg.Utils.ecritFin(out);
return;
}
finally
{
out.println("
");
dg.Utils.ecritFin(out);
}
}
}
1460560579000
Le résultat affiché :
Les cookies
Les cookies consistent en un nombre limité d’informations en mode texte, envoyés par le serveur et mémorisés sur le poste client par le navigateur. Ces informations sont renvoyées par le client lorsqu’il demande la même URL au serveur. Cette mémorisation d’informations permet d’atteindre la persistance de données alors que le protocole HTTP lui-même est sans mémoire (mode non connecté) : par exemple :
identifier l’utilisateur sur un site de e-commerce
lui éviter la répétition de saisies (nom, mot de passe, …)
tenir compte des préférences de l’utilisateur
La durée de vie d’un cookie est réglable. La taille d’un cookie est limitée (4ko). Par contre, il ne convient pas pour mémoriser des données sensibles, telles que numéro de carte bancaire, …
Déposer un cookie
Vu sous l’angle de la programmation, un cookie est un ensemble de couples (nom, valeur), tous les deux exprimés sous forme de String.
Le constructeur de Cookie permet de définir un couple (nom, valeur). La méthode addCookie() de la classe HttpServletResponse permet d’attacher ce cookie à la réponse. La méthode setMaxAge() de la classe Cookie permet de fixer sa durée de vie.
La servlet suivante positionne 6 cookies: trois sont valides sur la session en cours du navigateur, les trois autres sont valides 1 heure. Le lien qui s’affiche dans le navigateur permet de voir les cookies actifs (voir servlet suivante).
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
import dg.Utils;
public class ServletCookie1 extends HttpServlet
{
public void doGet(HttpServletRequest req,
HttpServletResponse res)
throws ServletException, IOException
{
for(int i=0; i<3; i++)
{
// par défaut maxAge is -1, dans ca cas, le cookie est
// valide uniquement pour la session en cours du
// navigateur
Cookie cookie = new Cookie("Cookie_de_Session_" + i,
"valeur_S_" + i);
res.addCookie(cookie);
cookie = new Cookie("Cookie_Persistant_" + i,
"valeur_P_" + i);
// le cookie est valide 1 heure, même si l'utilisateur
// quitte le navigateur, redémarre l'ordinateur, ...
cookie.setMaxAge(3600);
res.addCookie(cookie);
}
res.setContentType("text/html");
PrintWriter out = res.getWriter();
dg.Utils.ecritDebut(out,"Servlet et Cookies");
out.println(
"Il y a 6 cookies associées à cette page.\n" +
"pour les voir, cliquez ici\n" +
"\n" +
"ServletCookie2 .\n" +
"
\n" +
"Si vous quittez le navigateur et activez la servlet"+
"/monAppliWeb/servlet/ServletCookie2, vous verrez "+
"les cookies persistants\n");
dg.Utils.ecritFin(out);
}
}
Récupérer un cookie
La méthode getCookies() de la classe HttpServletRequest permet de récupérer un tableau de cookies. Pour chacune d’elles, les méthodes getName() et getValue() permettent de retrouver respectivement le nom et la valeur.
La servlet suivante affiche les cookies actifs
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
import dg.Utils;
public class ServletCookie2 extends HttpServlet
{
public void doGet(HttpServletRequest req,
HttpServletResponse res)
throws ServletException, IOException
{
res.setContentType("text/html");
PrintWriter out = res.getWriter();
dg.Utils.ecritDebut(out,"Cookies actifs");
out.println("
\n" +
"
\n" +
"
nom du Cookie\n" +
"
valeur du Cookie");
Cookie[] cookies = req.getCookies();
if (cookies != null)
{
Cookie cookie;
for(int i=0; i\n" +
"
" + cookie.getName() + "\n" +
"
" + cookie.getValue());
}
}
out.println("
");
dg.Utils.ecritFin(out);
}
}
Le résultat affiché
Après avoir quitté puis relancé le navigateur le résultat d’appel de la même URL est le suivant
La gestion des sessions
Pour pallier l’aspect déconnecté du protocole HTTP, il faut mettre en place un mécanisme qui permette de mémoriser des informations contextuelles tout au long de la session de l’utilisateur. Pour y parvenir, trois techniques classiques sont disponibles :
l’utilisation de cookies (voir paragraphe précédent)
la réécriture d’URL, dans laquelle le client ajoute des paramètres liés à la session sur l’URL, comme
Acheter
les inconvénients de cette technique sont en particulier la limitation du volume des données et leur visibilité, qui nuit à la sécurité
l’utilisation de champs de formulaire cachés, comme
cette technique est plus sûre que la précédente, car il est possible d’utiliser la méthode POST pour renvoyer les valeurs des champs cachés
Les servlets permettent en outre de gérer des sessions à l’aide de :
l’interface spécifique HttpSession
Il est possible d’associer un objet session à chaque requête. Cet objet session sert de conteneur pour des informations persistantes, chacune étant accessible par son nom. La durée de vie de cet objet session est réglable. Si le client autorise les cookies, les informations de session sont mémorisées sous cette forme.
La méthode getSession() de la classe HttpServletRequest retourne une instance de HttpSession qui représente la session courante associée à cette requête, ou en crée une si la requête ne possède pas de session.
Pour la classe HttpSession, la méthode setAttribute() permet de lier à la session l’objet dont le nom est spécifié .
Attacher des objets à la session
Soit le formulaire
qui active la servlet suivante
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
import dg.Utils;
public class ServletSession1 extends HttpServlet
{
private HttpSession m_session;
public void doGet(HttpServletRequest req,
HttpServletResponse res)
throws ServletException, IOException
{
m_session = req.getSession(true);
res.setContentType("text/html");
PrintWriter out = res.getWriter();
m_session.setAttribute("nom",req.getParameter("nom"));
try
{
m_session.setAttribute("age",new
Integer(req.getParameter("age")));
}
catch(NumberFormatException e)
{
res.sendRedirect(res.encodeURL("/monAppliWeb/Form4.html"));
}
dg.Utils.ecritDebut(out,"Suivi de session dans les servlets");
out.println(
"Cette servlet a lié 2 objets à la session: " +
" un String pour le nom de l'utilisateur " +
" un Integer pour l'age de l'utilisateur " +
"Pour les voir, cliquez ici\n" +
"\n" +
"ServletSession2 .\n" +
"
\n" +
"Si vous quittez le navigateur et activez la servlet"+
"/monAppliWeb/servlet/ServletSession2, vous verrez "+
"que la servlet ne récupère rien de la session\n");
dg.Utils.ecritFin(out);
}
}
Cette servlet lie deux objets à la session: un String et un Integer.
L’instruction res.sendRedirect(res.encodeURL("/monAppliWeb/Form4.html")) illustre une redirection sur le formulaire de saisie au cas où l’utilisateur entre des données non numériques dans le second champ (cette erreur de saisie plus judicieusement gérée par un script client).
Récupérer des objets de la session
La méthode getAttribute() permet de récupérer l’objet lié à la session dont le nom est spécifié. La méthode getAttributeNames() retourne une Enumeration d'objets String contenant le nom de tous les objets liés à cette session. La méthode removeAttribute() retire de la session l’objet dont le nom est spécifié. La méthode invalidate() invalide la session, en déliant tout objet qui y était associé.
Dans l’exemple ci-dessus, le lien qui s’affiche dans le navigateur permet d’activer une seconde servlet, qui récupère les deux objets ci-dessus de la session :
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
import dg.Utils;
public class ServletSession2 extends HttpServlet
{
private HttpSession m_session;
public void doGet(HttpServletRequest req,
HttpServletResponse res)
throws ServletException, IOException
{
String strNom;
Integer Age;
m_session = req.getSession(true);
res.setContentType("text/html");
PrintWriter out = res.getWriter();
dg.Utils.ecritDebut(out,"tentative de récupération " +
"de 2 objets de la session ");
strNom=(String)m_session.getAttribute("nom");
if (strNom != null)
{
out.println("Voici ce que la servlet "
"a récupéré de la session: ");
out.println("\tle nom : " +strNom+" ");
}
else
{
out.println("La servlet n'a rien récupéré de la session");
}
Age=(Integer)m_session.getAttribute("age");
if (Age != null)
{
out.println("\tl'age : " +Age.intValue()+" ");
}
dg.Utils.ecritFin(out);
}
}
Cette servlet provoque l’affichage
Si l’utilisateur quitte le navigateur et active ensuite la servlet /monAppliWeb/servlet/ServletSession2 , l’affichage devient
Annexe : classes servlets en bref
Classe abstraite GenericServlet
(Package javax.servlet)
java.lang.Object
|
+--javax.servlet.GenericServlet
sous-classe directe : HttpServlet
implémente Servlet, ServletConfig, java.io.Serializable
Cette classe abstraite définit une servlet générique, indépendante de tout protocole. Pour utiliser une servlet dans un contexte web, utilisant le protocole HTTP, il faut utiliser une classe dérivant de HttpServlet . Pour écrire une servlet générique, il faut rédéfinir la méthode abstraite service() .
Constructeur
GenericServlet()
Ne fait rien.
Quelques méthodes
void
destroy()
Cette méthode est appelée par le conteneur de servlets pour indiquer à la servlet qu’elle va être déchargée de la mémoire.
Java.lang.String
getInitParameter(java.lang.String name)
Retourne un String contenant la valeur du paramètre d’initialisation name, ou null si le paramètre n’existe pas.
Java.util.
Enumeration
getInitParameterNames()
Retourne les noms des paramètres d’initialisation de la servlet sous forme d’une énumération d’objets String, ou une énumération vide si la servlet n’a pas de paramètres d’initialisation.
ServletConfig
getServletConfig()
Retourne un objet de type ServletConfig , qui contient des informations d'initialisation et de démarrage pour cette servlet.
java.lang.String
getServletInfo()
Retourne de l'information sur la servlet, comme l'auteur, la version, le copyright.
void
init()
Appelée par le conteneur de servlets pour indiquer à la servlet qu'elle est chargée par le moteur de servlets. Ne nécessite pas d'appeler super.init(config).
void
init(ServletConfig config)
Appelée par le conteneur de servlets pour indiquer à la servlet qu'elle est chargée par le moteur de servlets.
abstract void
service(ServletRequest req, ServletResponse res)
Appelée par le conteneur de servlets pour permettre à la servlet de répondre à une requête.
Interface Servlet
(Package javax.servlet)
Classes implémentant cette interface: GenericServlet
Cette interface définit les méthodes que toute servlet doit implémenter.
Elle définit des méthodes pour initialiser une servlet (init()), effectuer un traitement (service()), effectuer un traitement au déchargement de la servlet par le conteneur (destroy()).
Méthodes
void
destroy()
Appelée par le conteneur de servlets pour indiquer à la servlet qu'elle va être déchargée du moteur de servlets.
ServletConfig
GetServletConfig()
Retourne un objet de type ServletConfig , qui contient des informations d'initialisation et de démarrage pour cette servlet.
java.lang.String
GetServletInfo()
Retourne de l'information sur la servlet, comme l'auteur, la version, le copyright.
void
init(ServletConfig config)
Appelée par le conteneur de servlets pour indiquer à la servlet qu'elle est chargée par le moteur de servlets.
void
service(ServletRequest req, ServletResponse res)
Appelée par le conteneur de servlets pour permettre à la servlet de répondre à une requête.
Interface ServletConfig
(Package javax.servlet)
Classes implémentant cette interface: GenericServlet
Cette interface permet à un moteur de servlets de passer de l'information à une servlet lors de l'initialisation de celle-ci.
Quelques méthodes
java.lang.String
getInitParameter(java.lang.String name)
Retourne un String contenant la veleur du paramètre d'initialisation name, ou null si le paramètre n'existe pas.
java.util.
Enumeration
getInitParameterNames()
Retourne les noms des paramètres d'initialisation de la servlet sous forme d'une Enumeration d'objets String, ou une Enumeration vide si la servlet n'a pas de paramètres d'initialisation.
Interface ServletRequest
(Package javax.servlet )
Sous-interfaces: HttpServletRequest
Permet de définir un objet requête client utilisé par la servlet dans laquelle celle-ci peut puiser des informations sur la requête client.
Quelques méthodes
java.lang.String
getContentType()
Retourne le type MIME du corps de la requête client, ou null si ce type est inconnu.
java.lang.String
getParameter(java.lang.String name)
Retourne la valeur d'un paramètre de la requête client (transmis par POST ou GET) sous forme d'un objet String, ou null si le paramètre n'existe pas.
java.util.
Enumeration
getParameterNames()
Retourne une Enumeration d'objets String contenant le nom des paramètres (transmis par POST ou GET) contenus dans la requête client.
java.lang.
String[]
getParameterValues(java.lang.String name)
Retourne un tableau d'objets String contenant toutes les valeurs que possède le paramètre name (transmis par POST ou GET), ou null si le paramètre n'existe pas.
java.lang.String
getProtocol()
Retourne le nom et la version du protocole utilisé par la requête, sous la forme protocole/versionMajeure.versionMineure, par exemple: HTTP/1.1.
java.lang.String
getRemoteAddr()
Retourne l'adresse IP du client qui a émis la requête.
java.lang.String
getRemoteHost()
Retourne le nom de l'hôte du client qui a émis la requête.
java.lang.String
getServerName()
Retourne le nom de l'hôte du serveur qui a reçu la requête.
int
getServerPort()
Retourne le numéro de port sur lequel est parvenue la requête.
Interface ServletResponse
(Package javax.servlet)
Sous-interfaces: HttpServletResponse
Sert à définir un objet réponse pour permettre à la servlet d'envoyer sa réponse au client. Pour envoyer des caractères au client, il faut utiliser un objet de type PrintWriter fourni par un appel à getWriter().
Quelques méthodes
void
flushBuffer()
Force le vidage du contenu du buffer sur le client.
java.io.
PrintWriter
getWriter()
Retourne un objet PrintWriter pour envoyer des caractères (texte) au client.
void
setContentType(java.lang.String type)
Définit le type de contenu de la réponse à envoyer au client.
Classe abstraite HttpServlet
(Package javax.servlet.http)
java.lang.Object
|
+--javax.servlet.GenericServlet
|
+--javax.servlet.http.HttpServlet
Il faut créer une classe fille de cette classe abstraite afin de créer une servlet HTTP utilisable dans un site Web. Une classe dérivée de HttpServlet doit redéfinir au moins une des méthodes suivantes (dans les cas simples):
doGet(), si la servlet supporte les requêtes HTTP de type GET
doPost(), pour les requêtes HTTP de type POST
getServletInfo(), si la servlet doit pouvoir fournir des informations sur elle-même
...
Comme les servlets sont exécutées sur des moteurs multithreads, il importe de prendre garde le cas échéant à la gestion de requêtes concurrentes et veiller à synchroniser l'accès à des ressouces partagées.
Constructeur
HttpServlet()
Ne fait rien.
Quelques méthodes
protected void
doGet(HttpServletRequest req, HttpServletResponse res)
Appelée par le serveur pour permettre à la servlet de gérer une requête de type GET .
protected void
doPost(HttpServletRequest req, HttpServletResponse res)
Appelée par le serveur pour permettre à la servlet de gérer une requête de type POST .
Interface HttpServletRequest
(Package javax.servlet.http)
Interface fille de ServletRequest permettant de fournir des informations de la requête client à une servlet HTTP.
Quelques méthodes
Cookie[]
GetCookies()
Retourne un tableau contenant tous les objets de type Cookie que le client a envoyés avec la requête.
long
GetDateHeader(java.lang.String name)
Retourne la valeur de l'entête de requête passée en paramètre sous forme d'une valeur long représentant un objet Date.
java.lang.String
GetHeader(java.lang.String name)
Retourne la valeur de l'entête de requête passée en paramètre sous forme d'un objet String.
java.util.
Enumeration
getHeaderNames()
Retourne une Enumeration de tous les noms d'entête que contient la requête.
java.util.
Enumeration
getHeaders(java.lang.String name)
Retourne toutes les valeurs de l'entête de requête passée en paramètre sous forme d'une Enumeration d'objets String .
int
getIntHeader(java.lang.String name)
Retourne la valeur de l'entête de requête passée en paramètre sous forme d'un entier int
java.lang.String
getMethod()
Retourne le nom de la méthode HTTP par laquelle la requête a été transmise: GET, POST, ...
java.lang.String
getPathInfo()
Retourne des informations sur l'URL de la servlet que le client a sollicitée en faisant sa requête.
java.lang.String
getPathTranslated()
Retourne la partie chemin de l'URL de la servlet que le client a sollicitée.
java.lang.String
getQueryString()
Retourne la partie requête (derrière le chemin) de l'URL de la servlet que le client a sollicitée.
java.lang.String
getRemoteUser()
Retourne le login de l'utilisateur faisant la requête s'il a été authentifié, ou null s'il ne l'a pas été.
java.lang.String
getRequestedSessionId()
Retourne l'ID de session ID spécifié par le client.
java.lang.String
getRequestURI()
Retourne l'URI (partie entre le nom du protocole et la requête) de l'URL de la servlet que le client a sollicitée.
java.lang.String
getServletPath()
Retourne le chemin et nom de la servlet de l’URL que le client a sollicitée, sauf la partie requête.
HttpSession
getSession()
Retourne la session courante associée à cette requête, ou en crée une si la requête ne possède pas de session.
HttpSession
getSession(boolean create)
Retourne la session courante associée à cette requête, ou en crée une si la requête ne possède pas de session et si le booléen create est à true.
Interface HttpServletResponse
(Package javax.servlet.http)
Interface fille de ServletResponse fournissant des fonctionnalités spécifiques au protocole HTTP lors de l'envoi de la réponse, par exemple en permettant l'accès aux entêtes HTTP et aux cookies.
Quelques constantes
static int
SC_BAD_REQUEST
Status code (400) syntaxe de la requête client incorrecte.
static int
SC_CONFLICT
Status code (409) conflit de ressources sur le serveur.
static int
SC_CONTINUE
Status code (100) le client peut continuer.
static int
SC_FORBIDDEN
Status code (403) le serveur refuse de satisfaire la requête.
static int
SC_GONE
Status code (410) la ressource mentionnée par la requête n'est plus disponible sur le serveur , et aucune adresse de redirection n'est connue.
static int
SC_MOVED_PERMANENTLY
Status code (301) la ressource mentionnée par la requête a été déplacée définitivement.
static int
SC_MOVED_TEMPORARILY
Status code (302) la ressource mentionnée par la requête a été déplacée temporairement.
static int
SC_NOT_FOUND
Status code (404) la ressource mentionnée par la requête n'est pas disponible.
static int
SC_OK
Status code (200) la requête s'est terminée normalement.
static int
SC_REQUEST_TIMEOUT
Status code (408) le client n'a pas fourni la requête dans le laps de temps attendu par le serveur.
static int
SC_UNAUTHORIZED
Status code (401) la requête nécessite une authentification HTTP.
Quelques méthodes
void
addCookie(Cookie cookie)
Ajoute un cookie à la réponse.
void
addDateHeader(java.lang.String name, long date)
Ajoute un entête à la réponse selon le nom et la date précisés.
void
addHeader(java.lang.String name, java.lang.String value)
Ajoute un entête à la réponse selon le nom et la valeur précisés.
void
addIntHeader(java.lang.String name, int value)
Ajoute un entête à la réponse selon le nom et l'entier précisés.
Boolean
containsHeader(java.lang.String name)
Fournit un booléen indiquant si l'entête du nom spécifié a déjà été affecté.
java.lang.String
encodeRedirectURL(java.lang.String url)
Encode l'URL mentionnée pour l'utiliser dans une méthode sendRedirect ou, si l'encodage est superflu, retourne l'URL inchangée.
java.lang.String
encodeURL(java.lang.String url)
Encode l'URL mentionnée en y incluant l'ID de session ou, si l'encodage est superflu, retourne l'URL inchangée.
void
sendError(int sc)
Envoie une erreur au client spécifiant le le status code mentionné, et vide le buffer.
void
sendRedirect(java.lang.String location)
Envoie un message de redirection temporaire au client qui utilisera l'URL mentionnée.
void
setDateHeader(java.lang.String name, long date)
Positionne un entête de réponse avec le nom et la date spécifiés.
void
setHeader(java.lang.String name, java.lang.String value)
Positionne un entête de réponse avec le nom et la valeur spécifiés.
void
setIntHeader(java.lang.String name, int value)
Positionne un entête de réponse avec le nom et la valeur entière spécifiés.
void
setStatus(int sc)
Positionne le code d'erreur pour la réponse.
Classe Cookie
(Package javax.servlet.http)
java.lang.Object
|
+--javax.servlet.http.Cookie
Cette classe permet de créer un cookie, information envoyée par la servlet vers le navigateur du client, sauvée par celui-ci, puis renvoyée vers le serveur ultérieurement. Un cookie permet d'identifier de façon unique un client et d'y mémoriser localement , si le client l'autorise, quelques informations spécifiques.
Constructeur
Cookie(java.lang.String name,java.lang.String value)
Construit un cookie de nom et valeur spécifiés.
Quelques méthodes
int
getMaxAge()
Retourne la durée de vie maximale du cookie, en secondes. Par défaut, -1 indique que le cookie vit jusqu'à l'arrêt du navigateur client.
java.lang.String
getName()
Retourne le nom du cookie.
java.lang.String
getValue()
Retourne la valeur du cookie.
void
setMaxAge(int expiry)
Fixe la durée de vie maximale du cookie, en secondes.
void
setValue(java.lang.String newValue)
Assigne une nouvelle valeur au cookie après sa création.
Interface HttpSession
(Package javax.servlet.http)
Cette interface permet de conserver l'identification d'un utilisateur lors de sa navigation sur plusieurs pages d'un site Web, et de mémoriser de l'information sur cet utilisateur. Une session possède une validité spécifiée dans le temps, et peut s'étaler sur plus d'une connexion au serveur, ou plusieurs requêtes de l'utilisateur.
Quelques méthodes
java.lang.Object
getAttribute(java.lang.String name)
Retourne l'objet lié au nom spécifié dans la session, ou null si aucun objet n'est lié à ce nom.
java.util.
Enumeration
getAttributeNames()
Retourne une Enumeration d'objets String contenant le nom de tous les objets liés à cette session.
long
getCreationTime()
Retourne l'instant de création de la session, mesuré en millisesondes depuis le 01 janvier 1970 GMT.
java.lang.String
getId()
Retourne l'identifiant unique assigné à cette session.
long
getLastAccessedTime()
Retourne le dernier instant où le client a envoyé une requête associée à cette session, mesuré en millisesondes depuis le 01 janvier 1970 GMT.
int
getMaxInactiveInterval()
Retourne, en secondes, l'intervalle de temps maximum durant lequel le conteneur de servlet maintiendra la session ouverte entre deux accès client.
void
invalidate()
Invalide la session, en déliant tout objet qui y était associé.
void
removeAttribute(java.lang.String name)
Retire (délie) de la session l'objet dont le nom est spécifié.
void
setAttribute(java.lang.String name, java.lang.Object value)
Lie à la session l'objet dont le nom est spécifié.
void
setMaxInactiveInterval(int interval)
Fixe la durée entre requêtes client, en secondes, au delà de laquelle le conteneur de servlet invalidera la session.
Annexe : Installation
Installation sous Windows
Installation d'Apache 1.3
Double-cliquez sur apache_1.3.27-win32-x86-no_src.exe
Renseignez les trois champs obligatoires
Choisissez le mode de démarrage de Apache en tant que service.
Le répertoire par défaut d'installation d'Apache est c:\Program Files\Apache Group\Apache.
Redémarrez Windows
Vérification
Activez un navigateur, puis entrez l'URL http://localhost: vous devez voir apparaître une page commençant par une phrase du genre "Si vous lisez cette page, c'est que les propriétaires de ce domaine viennent d'installer le serveur web Apache avec succès. ..."
Une alternative simple d’installation consiste à utiliser le package EasyPHP 1 .6, qui intègre d’office Apache et MySQL.
Installation du JDK 1.3
Installez par exemple le jdk 1.3.0_02
Définissez la variable d'environnement JAVA_HOME pour qu'elle pointe sur le répertoire d'installation du jdk
sous Windows NT 4.0
démarrer paramètres
panneau de configuration
système
onglet environnement
JAVA_HOME : c:\jdk1.3.0_02
modifiez ensuite la variable PATH pour lui ajouter %JAVA_HOME%\bin.
Vérification
Dans une fenêtre d'invite de commandes, entrez la commande
java -version
La première ligne des résultats qui s'affichent à l'écran doit être "java version "1.3.0_02", c'est-à-dire refléter la version correcte du jdk installé.
L’installation du JDK est automatiquement effectuée dans le cas où vous installez Jbuilder 6 Foundation. Par contre, si vous souhaitez lancer les commandes java à partir d’une console, il faut positionner la variable d’environnement comme décrit ci-dessus.
Installation de Tomcat 4.1
Choisissez une version d'installation de Tomcat qui permette de travailler avec tout jdk installé (>= 1.2): la version jakarta-tomcat-4.1.12.exe le permet.
Double-cliquez sur jakarta-tomcat-4.1.12.exe.
La première boîte de dialogue doit indiquer le jdk que vous avez installé, et qui sera pris en compte par Tomcat.
Dans les options d'installation, si vous êtes sous NT/2000, cochez NT service, qui permettra à Tomcat de démarrer comme un service de NT.
Laissez le port par défaut à 8080. Entrez les coordonnées (user name, password) de l'administrateur.
Le répertoire par défaut d'installation de Tomcat est "c:\Program Files\Apache Group\Tomcat 4.1"
Le service Tomcat doit démarrer.
Si nécessaire, définissez la variable d’environnement utilisateur CATALINA_HOME comme le répertoire d’installation de Tomcat, soit ici "c:\Program Files\Apache Group\Tomcat 4.1"
Vérifications
Tomcat intègre un serveur HTTP. Activez un navigateur, puis entrez l'URL http://localhost:8080 : vous devez voir apparaître la page d'accueil de Tomcat 4.1.12
Changez le raccourci de Tomcat administration : dans le groupe de programmes Apache Tomcat 4.1, éditer les propriétés de Tomcat Administration et remplacer le champ cible par:
"c:\Program Files\Plus!\Microsoft Internet\IEXPLORE.EXE" http://127.0.0.1:8080/admin. Vérifiez que vous accédez bien à l'administration du serveur.
