Servlets - Guide rapide
Que sont les servlets?
Les servlets Java sont des programmes qui s'exécutent sur un serveur Web ou d'application et agissent comme une couche intermédiaire entre une demande provenant d'un navigateur Web ou d'un autre client HTTP et des bases de données ou des applications sur le serveur HTTP.
À l'aide des servlets, vous pouvez collecter les entrées des utilisateurs via des formulaires de page Web, présenter des enregistrements d'une base de données ou d'une autre source et créer des pages Web de manière dynamique.
Les servlets Java ont souvent le même objectif que les programmes mis en œuvre à l'aide de l'interface de passerelle commune (CGI). Mais les servlets offrent plusieurs avantages par rapport au CGI.
Les performances sont nettement meilleures.
Les servlets s'exécutent dans l'espace d'adressage d'un serveur Web. Il n'est pas nécessaire de créer un processus distinct pour traiter chaque demande client.
Les servlets sont indépendants de la plate-forme car ils sont écrits en Java.
Le gestionnaire de sécurité Java sur le serveur applique un ensemble de restrictions pour protéger les ressources sur une machine serveur. Les servlets sont donc fiables.
La fonctionnalité complète des bibliothèques de classes Java est disponible pour un servlet. Il peut communiquer avec des applets, des bases de données ou d'autres logiciels via les sockets et les mécanismes RMI que vous avez déjà vus.
Architecture des servlets
Le diagramme suivant montre la position des servlets dans une application Web.
Tâches des servlets
Les servlets exécutent les tâches principales suivantes -
Lisez les données explicites envoyées par les clients (navigateurs). Cela inclut un formulaire HTML sur une page Web ou il peut également provenir d'une applet ou d'un programme client HTTP personnalisé.
Lisez les données de requête HTTP implicites envoyées par les clients (navigateurs). Cela inclut les cookies, les types de médias et les schémas de compression que le navigateur comprend, etc.
Traitez les données et générez les résultats. Ce processus peut nécessiter de parler à une base de données, d'exécuter un appel RMI ou CORBA, d'appeler un service Web ou de calculer directement la réponse.
Envoyez les données explicites (c'est-à-dire le document) aux clients (navigateurs). Ce document peut être envoyé dans une variété de formats, y compris le texte (HTML ou XML), binaire (images GIF), Excel, etc.
Envoyez la réponse HTTP implicite aux clients (navigateurs). Cela comprend le fait d'indiquer aux navigateurs ou à d'autres clients le type de document renvoyé (par exemple, HTML), la configuration des cookies et des paramètres de mise en cache, et d'autres tâches similaires.
Servlets Packages
Les servlets Java sont des classes Java exécutées par un serveur Web doté d'un interpréteur prenant en charge la spécification Java Servlet.
Les servlets peuvent être créés à l'aide du javax.servlet et javax.servlet.http packages, qui font partie intégrante de l'édition d'entreprise de Java, une version étendue de la bibliothèque de classes Java qui prend en charge les projets de développement à grande échelle.
Ces classes implémentent les spécifications Java Servlet et JSP. Au moment de la rédaction de ce didacticiel, les versions sont Java Servlet 2.5 et JSP 2.1.
Les servlets Java ont été créés et compilés comme n'importe quelle autre classe Java. Après avoir installé les packages de servlet et les avoir ajoutés au Classpath de votre ordinateur, vous pouvez compiler des servlets avec le compilateur Java du JDK ou tout autre compilateur actuel.
Quelle est la prochaine?
Je vous guiderais étape par étape pour configurer votre environnement pour commencer avec les servlets. Alors attachez votre ceinture pour un bon entraînement avec des servlets. Je suis sûr que vous apprécierez beaucoup ce tutoriel.
Un environnement de développement est l'endroit où vous développez votre servlet, les testez et enfin les exécutez.
Comme tout autre programme Java, vous devez compiler un servlet à l'aide du compilateur Java javac et après la compilation de l'application servlet, elle serait déployée dans un environnement configuré pour tester et exécuter.
Cette configuration d'environnement de développement implique les étapes suivantes -
Configuration du kit de développement Java
Cette étape implique le téléchargement d'une implémentation du kit de développement logiciel Java (SDK) et la configuration appropriée de la variable d'environnement PATH.
Vous pouvez télécharger le SDK à partir du site Java d'Oracle - Téléchargements Java SE .
Une fois que vous avez téléchargé votre implémentation Java, suivez les instructions données pour installer et configurer la configuration. Enfin, définissez les variables d'environnement PATH et JAVA_HOME pour faire référence au répertoire qui contient java et javac, généralement rép_install_java / bin et rép_install_java respectivement.
Si vous exécutez Windows et avez installé le SDK dans C: \ jdk1.8.0_65, vous placez la ligne suivante dans votre fichier C: \ autoexec.bat.
set PATH = C:\jdk1.8.0_65\bin;%PATH%
set JAVA_HOME = C:\jdk1.8.0_65
Alternativement, sous Windows NT / 2000 / XP, vous pouvez également cliquer avec le bouton droit de la souris sur Poste de travail, sélectionner Propriétés, puis Avancé, puis Variables d'environnement. Ensuite, vous mettriez à jour la valeur PATH et appuyez sur le bouton OK.
Sous Unix (Solaris, Linux, etc.), si le SDK est installé dans /usr/local/jdk1.8.0_65 et que vous utilisez le shell C, vous mettriez ce qui suit dans votre fichier .cshrc.
setenv PATH /usr/local/jdk1.8.0_65/bin:$PATH
setenv JAVA_HOME /usr/local/jdk1.8.0_65
Sinon, si vous utilisez un environnement de développement intégré (IDE) comme Borland JBuilder, Eclipse, IntelliJ IDEA ou Sun ONE Studio, compilez et exécutez un programme simple pour confirmer que l'EDI sait où vous avez installé Java.
Configuration du serveur Web - Tomcat
Un certain nombre de serveurs Web prenant en charge les servlets sont disponibles sur le marché. Certains serveurs Web sont téléchargeables gratuitement et Tomcat est l'un d'entre eux.
Apache Tomcat est une implémentation logicielle open source des technologies Java Servlet et Java Server Pages et peut agir comme un serveur autonome pour tester les servlets et peut être intégré au serveur Web Apache. Voici les étapes pour configurer Tomcat sur votre machine -
Téléchargez la dernière version de Tomcat sur https://tomcat.apache.org/.
Une fois que vous avez téléchargé l'installation, décompressez la distribution binaire dans un emplacement pratique. Par exemple dans C: \ apache-tomcat-8.0.28 sous Windows, ou /usr/local/apache-tomcat-8.0.289 sous Linux / Unix et créez la variable d'environnement CATALINA_HOME pointant vers ces emplacements.
Tomcat peut être démarré en exécutant les commandes suivantes sur la machine Windows -
%CATALINA_HOME%\bin\startup.bat
or
C:\apache-tomcat-8.0.28\bin\startup.bat
Tomcat peut être démarré en exécutant les commandes suivantes sur une machine Unix (Solaris, Linux, etc.) -
$CATALINA_HOME/bin/startup.sh
or
/usr/local/apache-tomcat-8.0.28/bin/startup.sh
Après le démarrage, les applications Web par défaut incluses avec Tomcat seront disponibles en visitant http://localhost:8080/. Si tout va bien, il devrait afficher le résultat suivant -
Vous trouverez plus d'informations sur la configuration et l'exécution de Tomcat dans la documentation incluse ici, ainsi que sur le site Web de Tomcat - http://tomcat.apache.org
Tomcat peut être arrêté en exécutant les commandes suivantes sur la machine Windows -
C:\apache-tomcat-8.0.28\bin\shutdown
Tomcat peut être arrêté en exécutant les commandes suivantes sur une machine Unix (Solaris, Linux, etc.) -
/usr/local/apache-tomcat-8.0.28/bin/shutdown.sh
Configuration du CLASSPATH
Étant donné que les servlets ne font pas partie de Java Platform, Standard Edition, vous devez identifier les classes de servlet auprès du compilateur.
Si vous utilisez Windows, vous devez placer les lignes suivantes dans votre fichier C: \ autoexec.bat.
set CATALINA = C:\apache-tomcat-8.0.28
set CLASSPATH = %CATALINA%\common\lib\servlet-api.jar;%CLASSPATH%
Alternativement, sous Windows NT / 2000 / XP, vous pouvez aller dans Poste de travail -> Propriétés -> Avancé -> Variables d'environnement. Ensuite, vous mettriez à jour la valeur CLASSPATH et appuyez sur le bouton OK.
Sous Unix (Solaris, Linux, etc.), si vous utilisez le shell C, vous mettriez les lignes suivantes dans votre fichier .cshrc.
setenv CATALINA = /usr/local/apache-tomcat-8.0.28
setenv CLASSPATH $CATALINA/common/lib/servlet-api.jar:$CLASSPATH
NOTE - En supposant que votre répertoire de développement est C: \ ServletDevel (Windows) ou / usr / ServletDevel (Unix), vous devrez également ajouter ces répertoires dans CLASSPATH de la même manière que vous avez ajouté ci-dessus.
Un cycle de vie de servlet peut être défini comme l'ensemble du processus depuis sa création jusqu'à sa destruction. Voici les chemins suivis par un servlet.
Le servlet est initialisé en appelant le init() méthode.
Le servlet appelle service() méthode pour traiter la demande d'un client.
Le servlet se termine en appelant le destroy() méthode.
Enfin, le servlet est récupéré par le garbage collector de la JVM.
Parlons maintenant des méthodes du cycle de vie en détail.
La méthode init ()
La méthode init n'est appelée qu'une seule fois. Il n'est appelé que lorsque le servlet est créé, et n'est pas appelé par la suite pour les demandes des utilisateurs. Ainsi, il est utilisé pour les initialisations ponctuelles, tout comme avec la méthode init des applets.
Le servlet est normalement créé lorsqu'un utilisateur appelle pour la première fois une URL correspondant au servlet, mais vous pouvez également spécifier que le servlet soit chargé lors du premier démarrage du serveur.
Lorsqu'un utilisateur appelle un servlet, une seule instance de chaque servlet est créée, chaque requête utilisateur entraînant un nouveau thread qui est transféré à doGet ou doPost selon le cas. La méthode init () crée ou charge simplement des données qui seront utilisées tout au long de la vie du servlet.
La définition de la méthode init ressemble à ceci -
public void init() throws ServletException {
// Initialization code...
}
La méthode service ()
La méthode service () est la principale méthode pour effectuer la tâche réelle. Le conteneur de servlet (c'est-à-dire le serveur Web) appelle la méthode service () pour gérer les demandes provenant du client (navigateurs) et pour écrire la réponse formatée au client.
Chaque fois que le serveur reçoit une demande de servlet, le serveur génère un nouveau thread et appelle le service. La méthode service () vérifie le type de requête HTTP (GET, POST, PUT, DELETE, etc.) et appelle les méthodes doGet, doPost, doPut, doDelete, etc. selon le cas.
Voici la signature de cette méthode -
public void service(ServletRequest request, ServletResponse response)
throws ServletException, IOException {
}
La méthode service () est appelée par le conteneur et la méthode de service appelle les méthodes doGet, doPost, doPut, doDelete, etc. selon le cas. Vous n'avez donc rien à voir avec la méthode service () mais vous remplacez doGet () ou doPost () en fonction du type de demande que vous recevez du client.
DoGet () et doPost () sont les méthodes les plus fréquemment utilisées dans chaque demande de service. Voici la signature de ces deux méthodes.
La méthode doGet ()
Une requête GET résulte d'une requête normale pour une URL ou d'un formulaire HTML pour lequel aucune METHODE n'est spécifiée et elle doit être gérée par la méthode doGet ().
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
// Servlet code
}
La méthode doPost ()
Une requête POST résulte d'un formulaire HTML qui répertorie spécifiquement POST comme METHODE et doit être gérée par la méthode doPost ().
public void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
// Servlet code
}
La méthode destroy ()
La méthode destroy () n'est appelée qu'une seule fois à la fin du cycle de vie d'un servlet. Cette méthode donne à votre servlet une chance de fermer les connexions à la base de données, d'arrêter les threads d'arrière-plan, d'écrire des listes de cookies ou de décomptes d'accès sur le disque et d'effectuer d'autres activités de nettoyage.
Après l'appel de la méthode destroy (), l'objet servlet est marqué pour le garbage collection. La définition de la méthode destroy ressemble à ceci -
public void destroy() {
// Finalization code...
}
Diagramme d'architecture
La figure suivante illustre un scénario de cycle de vie de servlet typique.
Tout d'abord, les requêtes HTTP arrivant sur le serveur sont déléguées au conteneur de servlet.
Le conteneur de servlet charge le servlet avant d'appeler la méthode service ().
Ensuite, le conteneur de servlet gère plusieurs demandes en engendrant plusieurs threads, chaque thread exécutant la méthode service () d'une seule instance du servlet.
Les servlets sont des classes Java qui traitent les requêtes HTTP et implémentent le javax.servlet.Servletinterface. Les développeurs d'applications Web écrivent généralement des servlets qui étendent javax.servlet.http.HttpServlet, une classe abstraite qui implémente l'interface Servlet et est spécialement conçue pour gérer les requêtes HTTP.
Exemple de code
Voici l'exemple de structure de code source d'un exemple de servlet pour afficher Hello World -
// Import required java libraries
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
// Extend HttpServlet class
public class HelloWorld extends HttpServlet {
private String message;
public void init() throws ServletException {
// Do required initialization
message = "Hello World";
}
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
// Set response content type
response.setContentType("text/html");
// Actual logic goes here.
PrintWriter out = response.getWriter();
out.println("<h1>" + message + "</h1>");
}
public void destroy() {
// do nothing.
}
}
Compiler un servlet
Créons un fichier avec le nom HelloWorld.java avec le code ci-dessus. Placez ce fichier dans C: \ ServletDevel (sous Windows) ou dans / usr / ServletDevel (sous Unix). Cet emplacement de chemin doit être ajouté à CLASSPATH avant de continuer.
En supposant que votre environnement est correctement configuré, entrez ServletDevel répertoire et compilez HelloWorld.java comme suit -
$ javac HelloWorld.java
Si le servlet dépend d'autres bibliothèques, vous devez également inclure ces fichiers JAR sur votre CLASSPATH. J'ai inclus uniquement le fichier JAR servlet-api.jar car je n'utilise aucune autre bibliothèque dans le programme Hello World.
Cette ligne de commande utilise le compilateur javac intégré fourni avec le kit de développement logiciel Java Sun Microsystems (JDK). Pour que cette commande fonctionne correctement, vous devez inclure l'emplacement du SDK Java que vous utilisez dans la variable d'environnement PATH.
Si tout se passe bien, la compilation ci-dessus produirait HelloWorld.classfichier dans le même répertoire. La section suivante explique comment un servlet compilé serait déployé en production.
Déploiement de servlet
Par défaut, une application de servlet se trouve dans le chemin <Tomcat-installationdirectory> / webapps / ROOT et le fichier de classe résiderait dans <Tomcat-installationdirectory> / webapps / ROOT / WEB-INF / classes.
Si vous avez un nom de classe complet de com.myorg.MyServlet, alors cette classe de servlet doit être située dans WEB-INF / classes / com / myorg / MyServlet.class.
Pour l'instant, copions HelloWorld.class dans <Tomcat-installationdirectory> / webapps / ROOT / WEB-INF / classes et créons les entrées suivantes dans web.xml fichier situé dans <Tomcat-installation-directory> / webapps / ROOT / WEB-INF /
<servlet>
<servlet-name>HelloWorld</servlet-name>
<servlet-class>HelloWorld</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>HelloWorld</servlet-name>
<url-pattern>/HelloWorld</url-pattern>
</servlet-mapping>
Au-dessus des entrées à créer dans les balises <web-app> ... </web-app> disponibles dans le fichier web.xml. Il peut y avoir plusieurs entrées dans ce tableau déjà disponibles, mais peu importe.
Vous avez presque terminé, commençons maintenant le serveur tomcat en utilisant <Tomcat-installationdirectory> \ bin \ startup.bat (sous Windows) ou <Tomcat-installationdirectory> /bin/startup.sh (sous Linux / Solaris etc.) et enfin tapez http://localhost:8080/HelloWorlddans la zone d'adresse du navigateur. Si tout se passe bien, vous obtiendrez le résultat suivant
Vous devez avoir rencontré de nombreuses situations où vous devez transmettre certaines informations de votre navigateur au serveur Web et, finalement, à votre programme backend. Le navigateur utilise deux méthodes pour transmettre ces informations au serveur Web. Ces méthodes sont la méthode GET et la méthode POST.
GET, méthode
La méthode GET envoie les informations utilisateur codées ajoutées à la demande de page. La page et les informations encodées sont séparées par le? (point d'interrogation) comme suit -
http://www.test.com/hello?key1 = value1&key2 = value2
La méthode GET est la méthode par défaut pour transmettre des informations du navigateur au serveur Web et elle produit une longue chaîne qui apparaît dans la zone Emplacement: de votre navigateur. N'utilisez jamais la méthode GET si vous avez un mot de passe ou d'autres informations sensibles à transmettre au serveur. La méthode GET a une limitation de taille: seuls 1024 caractères peuvent être utilisés dans une chaîne de requête.
Ces informations sont transmises à l'aide de l'en-tête QUERY_STRING et seront accessibles via la variable d'environnement QUERY_STRING et Servlet gère ce type de requêtes à l'aide de doGet() méthode.
Méthode POST
Une méthode généralement plus fiable pour transmettre des informations à un programme backend est la méthode POST. Cela regroupe les informations exactement de la même manière que la méthode GET, mais au lieu de les envoyer sous forme de chaîne de texte après un? (point d'interrogation) dans l'URL, il l'envoie sous forme de message séparé. Ce message arrive au programme backend sous la forme de l'entrée standard que vous pouvez analyser et utiliser pour votre traitement. Servlet gère ce type de requêtes en utilisantdoPost() méthode.
Lecture des données de formulaire à l'aide du servlet
Les servlets gèrent automatiquement l'analyse des données de formulaire à l'aide des méthodes suivantes en fonction de la situation -
getParameter() - Vous appelez la méthode request.getParameter () pour obtenir la valeur d'un paramètre de formulaire.
getParameterValues() - Appelez cette méthode si le paramètre apparaît plus d'une fois et renvoie plusieurs valeurs, par exemple une case à cocher.
getParameterNames() - Appelez cette méthode si vous voulez une liste complète de tous les paramètres de la demande en cours.
Exemple de méthode GET utilisant une URL
Voici une URL simple qui transmettra deux valeurs au programme HelloForm en utilisant la méthode GET.
http://localhost:8080/HelloForm?first_name = ZARA&last_name = ALICi-dessous est le HelloForm.javaprogramme de servlet pour gérer les entrées fournies par le navigateur Web. Nous allons utilisergetParameter() méthode qui permet d'accéder très facilement aux informations transmises -
// Import required java libraries
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
// Extend HttpServlet class
public class HelloForm extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
// Set response content type
response.setContentType("text/html");
PrintWriter out = response.getWriter();
String title = "Using GET Method to Read Form Data";
String docType =
"<!doctype html public \"-//w3c//dtd html 4.0 " + "transitional//en\">\n";
out.println(docType +
"<html>\n" +
"<head><title>" + title + "</title></head>\n" +
"<body bgcolor = \"#f0f0f0\">\n" +
"<h1 align = \"center\">" + title + "</h1>\n" +
"<ul>\n" +
" <li><b>First Name</b>: "
+ request.getParameter("first_name") + "\n" +
" <li><b>Last Name</b>: "
+ request.getParameter("last_name") + "\n" +
"</ul>\n" +
"</body>" +
"</html>"
);
}
}
En supposant que votre environnement est correctement configuré, compilez HelloForm.java comme suit -
$ javac HelloForm.java
Si tout se passe bien, la compilation ci-dessus produirait HelloForm.classfichier. Ensuite, vous devrez copier ce fichier de classe dans <Tomcat-installationdirectory> / webapps / ROOT / WEB-INF / classes et créer les entrées suivantes dansweb.xml fichier situé dans <Tomcat-installation-directory> / webapps / ROOT / WEB-INF /
<servlet>
<servlet-name>HelloForm</servlet-name>
<servlet-class>HelloForm</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>HelloForm</servlet-name>
<url-pattern>/HelloForm</url-pattern>
</servlet-mapping>
Tapez maintenant http: // localhost: 8080 / HelloForm? First_name = ZARA & last_name = ALI dans la case Location: de votre navigateur et assurez-vous que vous avez déjà démarré le serveur tomcat, avant de lancer la commande ci-dessus dans le navigateur. Cela générerait le résultat suivant -
Using GET Method to Read Form Data
- First Name: ZARA
- Last Name: ALI
Exemple de méthode GET utilisant le formulaire
Voici un exemple simple qui transmet deux valeurs à l'aide du formulaire HTML et du bouton d'envoi. Nous allons utiliser le même Servlet HelloForm pour gérer cette entrée.
<html>
<body>
<form action = "HelloForm" method = "GET">
First Name: <input type = "text" name = "first_name">
<br />
Last Name: <input type = "text" name = "last_name" />
<input type = "submit" value = "Submit" />
</form>
</body>
</html>
Conservez ce HTML dans un fichier Hello.htm et placez-le dans le répertoire <Tomcat-installationdirectory> / webapps / ROOT. Lorsque vous accéderez à http: // localhost: 8080 / Hello.htm , voici la sortie réelle du formulaire ci-dessus.
Essayez d'entrer le prénom et le nom, puis cliquez sur le bouton Soumettre pour voir le résultat sur votre machine locale sur laquelle tomcat est en cours d'exécution. Sur la base de l'entrée fournie, il générera un résultat similaire à celui mentionné dans l'exemple ci-dessus.
Exemple de méthode POST utilisant le formulaire
Faisons peu de modifications dans la servlet ci-dessus, afin qu'elle puisse gérer les méthodes GET ainsi que POST. Ci-dessousHelloForm.java programme de servlet pour gérer les entrées fournies par le navigateur Web à l'aide des méthodes GET ou POST.
// Import required java libraries
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
// Extend HttpServlet class
public class HelloForm extends HttpServlet {
// Method to handle GET method request.
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
// Set response content type
response.setContentType("text/html");
PrintWriter out = response.getWriter();
String title = "Using GET Method to Read Form Data";
String docType =
"<!doctype html public \"-//w3c//dtd html 4.0 " +
"transitional//en\">\n";
out.println(docType +
"<html>\n" +
"<head><title>" + title + "</title></head>\n" +
"<body bgcolor = \"#f0f0f0\">\n" +
"<h1 align = \"center\">" + title + "</h1>\n" +
"<ul>\n" +
" <li><b>First Name</b>: "
+ request.getParameter("first_name") + "\n" +
" <li><b>Last Name</b>: "
+ request.getParameter("last_name") + "\n" +
"</ul>\n" +
"</body>"
"</html>"
);
}
// Method to handle POST method request.
public void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
doGet(request, response);
}
}
Maintenant, compilez et déployez le servlet ci-dessus et testez-le en utilisant Hello.htm avec la méthode POST comme suit -
<html>
<body>
<form action = "HelloForm" method = "POST">
First Name: <input type = "text" name = "first_name">
<br />
Last Name: <input type = "text" name = "last_name" />
<input type = "submit" value = "Submit" />
</form>
</body>
</html>
Voici la sortie réelle du formulaire ci-dessus, essayez d'entrer le prénom et le nom, puis cliquez sur le bouton Soumettre pour voir le résultat sur votre ordinateur local sur lequel tomcat est en cours d'exécution.
Sur la base de l'entrée fournie, cela générerait un résultat similaire à celui mentionné dans les exemples ci-dessus.
Transmission des données de case à cocher au programme de servlet
Les cases à cocher sont utilisées lorsque plusieurs options doivent être sélectionnées.
Voici un exemple de code HTML, CheckBox.htm, pour un formulaire avec deux cases à cocher
<html>
<body>
<form action = "CheckBox" method = "POST" target = "_blank">
<input type = "checkbox" name = "maths" checked = "checked" /> Maths
<input type = "checkbox" name = "physics" /> Physics
<input type = "checkbox" name = "chemistry" checked = "checked" />
Chemistry
<input type = "submit" value = "Select Subject" />
</form>
</body>
</html>
Le résultat de ce code est la forme suivante
Ci-dessous, le programme de servlet CheckBox.java pour gérer les entrées données par le navigateur Web pour le bouton de la case à cocher.
// Import required java libraries
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
// Extend HttpServlet class
public class CheckBox extends HttpServlet {
// Method to handle GET method request.
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
// Set response content type
response.setContentType("text/html");
PrintWriter out = response.getWriter();
String title = "Reading Checkbox Data";
String docType =
"<!doctype html public \"-//w3c//dtd html 4.0 " + "transitional//en\">\n";
out.println(docType +
"<html>\n" +
"<head><title>" + title + "</title></head>\n" +
"<body bgcolor = \"#f0f0f0\">\n" +
"<h1 align = \"center\">" + title + "</h1>\n" +
"<ul>\n" +
" <li><b>Maths Flag : </b>: "
+ request.getParameter("maths") + "\n" +
" <li><b>Physics Flag: </b>: "
+ request.getParameter("physics") + "\n" +
" <li><b>Chemistry Flag: </b>: "
+ request.getParameter("chemistry") + "\n" +
"</ul>\n" +
"</body>"
"</html>"
);
}
// Method to handle POST method request.
public void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
doGet(request, response);
}
}
Pour l'exemple ci-dessus, il afficherait le résultat suivant -
Reading Checkbox Data
- Maths Flag : : on
- Physics Flag: : null
- Chemistry Flag: : on
Lecture de tous les paramètres du formulaire
Voici l'exemple générique qui utilise getParameterNames()méthode de HttpServletRequest pour lire tous les paramètres de formulaire disponibles. Cette méthode retourne une énumération qui contient les noms des paramètres dans un ordre non spécifié
Une fois que nous avons une énumération, nous pouvons boucler l'énumération de manière standard en utilisant la méthode hasMoreElements () pour déterminer quand arrêter et en utilisant la méthode nextElement () pour obtenir chaque nom de paramètre.
// Import required java libraries
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
import java.util.*;
// Extend HttpServlet class
public class ReadParams extends HttpServlet {
// Method to handle GET method request.
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
// Set response content type
response.setContentType("text/html");
PrintWriter out = response.getWriter();
String title = "Reading All Form Parameters";
String docType =
"<!doctype html public \"-//w3c//dtd html 4.0 " + "transitional//en\">\n";
out.println(docType +
"<html>\n" +
"<head><title>" + title + "</title></head>\n" +
"<body bgcolor = \"#f0f0f0\">\n" +
"<h1 align = \"center\">" + title + "</h1>\n" +
"<table width = \"100%\" border = \"1\" align = \"center\">\n" +
"<tr bgcolor = \"#949494\">\n" +
"<th>Param Name</th>"
"<th>Param Value(s)</th>\n"+
"</tr>\n"
);
Enumeration paramNames = request.getParameterNames();
while(paramNames.hasMoreElements()) {
String paramName = (String)paramNames.nextElement();
out.print("<tr><td>" + paramName + "</td>\n<td>");
String[] paramValues = request.getParameterValues(paramName);
// Read single valued data
if (paramValues.length == 1) {
String paramValue = paramValues[0];
if (paramValue.length() == 0)
out.println("<i>No Value</i>");
else
out.println(paramValue);
} else {
// Read multiple valued data
out.println("<ul>");
for(int i = 0; i < paramValues.length; i++) {
out.println("<li>" + paramValues[i]);
}
out.println("</ul>");
}
}
out.println("</tr>\n</table>\n</body></html>");
}
// Method to handle POST method request.
public void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
doGet(request, response);
}
}
Maintenant, essayez le servlet ci-dessus avec la forme suivante -
<html>
<body>
<form action = "ReadParams" method = "POST" target = "_blank">
<input type = "checkbox" name = "maths" checked = "checked" /> Maths
<input type = "checkbox" name = "physics" /> Physics
<input type = "checkbox" name = "chemistry" checked = "checked" /> Chem
<input type = "submit" value = "Select Subject" />
</form>
</body>
</html>
Maintenant, appeler le servlet en utilisant le formulaire ci-dessus générerait le résultat suivant -
Reading All Form Parameters
Param Name
Param Value(s)
maths
on
chemistry
on
Vous pouvez essayer le servlet ci-dessus pour lire les données de tout autre formulaire ayant d'autres objets comme une zone de texte, un bouton radio ou une zone de liste déroulante, etc.
Lorsqu'un navigateur demande une page Web, il envoie beaucoup d'informations au serveur Web qui ne peuvent pas être lues directement car ces informations voyagent dans le cadre de l'en-tête de la requête HTTP. Vous pouvez consulter le protocole HTTP pour plus d'informations à ce sujet.
Voici les informations d'en-tête importantes provenant du navigateur et que vous utiliseriez très fréquemment dans la programmation Web -
Sr.No. | En-tête et description |
---|---|
1 | Accept Cet en-tête spécifie les types MIME que le navigateur ou d'autres clients peuvent gérer. Valeurs deimage/png ou image/jpeg sont les deux possibilités les plus courantes. |
2 | Accept-Charset Cet en-tête spécifie les jeux de caractères que le navigateur peut utiliser pour afficher les informations. Par exemple ISO-8859-1. |
3 | Accept-Encoding Cet en-tête spécifie les types d'encodages que le navigateur sait gérer. Valeurs degzip ou compress sont les deux possibilités les plus courantes. |
4 | Accept-Language Cet en-tête spécifie les langues préférées du client au cas où le servlet peut produire des résultats dans plusieurs langues. Par exemple en, en-us, ru, etc. |
5 | Authorization Cet en-tête est utilisé par les clients pour s'identifier lorsqu'ils accèdent à des pages Web protégées par mot de passe. |
6 | Connection Cet en-tête indique si le client peut gérer les connexions HTTP persistantes. Les connexions persistantes permettent au client ou à un autre navigateur de récupérer plusieurs fichiers avec une seule demande. Une valeur deKeep-Alive signifie que des connexions persistantes doivent être utilisées. |
sept | Content-Length Cet en-tête ne s'applique qu'aux requêtes POST et donne la taille des données POST en octets. |
8 | Cookie Cet en-tête renvoie les cookies aux serveurs qui les ont précédemment envoyés au navigateur. |
9 | Host Cet en-tête spécifie l'hôte et le port comme indiqué dans l'URL d'origine. |
dix | If-Modified-Since Cet en-tête indique que le client veut la page uniquement si elle a été modifiée après la date spécifiée. Le serveur envoie un code, 304 ce qui signifieNot Modified en-tête si aucun résultat plus récent n'est disponible. |
11 | If-Unmodified-Since Cet en-tête est l'inverse de If-Modified-Since; il spécifie que l'opération ne doit réussir que si le document est plus ancien que la date spécifiée. |
12 | Referer Cet en-tête indique l'URL de la page Web de référence. Par exemple, si vous êtes sur la page Web 1 et que vous cliquez sur un lien vers la page Web 2, l'URL de la page Web 1 est incluse dans l'en-tête Referrer lorsque le navigateur demande la page Web 2. |
13 | User-Agent Cet en-tête identifie le navigateur ou un autre client effectuant la demande et peut être utilisé pour renvoyer différents contenus à différents types de navigateurs. |
Méthodes pour lire l'en-tête HTTP
Les méthodes suivantes peuvent être utilisées pour lire l'en-tête HTTP dans votre programme de servlet. Ces méthodes sont disponibles avec l' objet HttpServletRequest
Sr.No. | Méthode et description |
---|---|
1 | Cookie[] getCookies() Renvoie un tableau contenant tous les objets Cookie que le client a envoyés avec cette demande. |
2 | Enumeration getAttributeNames() Renvoie une énumération contenant les noms des attributs disponibles pour cette demande. |
3 | Enumeration getHeaderNames() Renvoie une énumération de tous les noms d'en-tête que contient cette demande. |
4 | Enumeration getParameterNames() Renvoie une énumération d'objets String contenant les noms des paramètres contenus dans cette requête |
5 | HttpSession getSession() Renvoie la session actuelle associée à cette demande, ou si la demande n'a pas de session, en crée une. |
6 | HttpSession getSession(boolean create) Renvoie la HttpSession actuelle associée à cette demande ou, s'il n'y a pas de session en cours et que la valeur de create est true, renvoie une nouvelle session. |
sept | Locale getLocale() Renvoie les paramètres régionaux préférés dans lesquels le client acceptera le contenu, en fonction de l'en-tête Accept-Language. |
8 | Object getAttribute(String name) Renvoie la valeur de l'attribut nommé en tant qu'objet, ou null si aucun attribut du nom donné n'existe. |
9 | ServletInputStream getInputStream() Récupère le corps de la demande sous forme de données binaires à l'aide d'un ServletInputStream. |
dix | String getAuthType() Renvoie le nom du schéma d'authentification utilisé pour protéger le servlet, par exemple «BASIC» ou «SSL», ou null si le JSP n'était pas protégé. |
11 | String getCharacterEncoding() Renvoie le nom du codage de caractères utilisé dans le corps de cette requête. |
12 | String getContentType() Renvoie le type MIME du corps de la requête, ou null si le type n'est pas connu. |
13 | String getContextPath() Renvoie la partie de l'URI de la demande qui indique le contexte de la demande. |
14 | String getHeader(String name) Renvoie la valeur de l'en-tête de demande spécifié sous forme de chaîne. |
15 | String getMethod() Renvoie le nom de la méthode HTTP avec laquelle cette demande a été effectuée, par exemple GET, POST ou PUT. |
16 | String getParameter(String name) Renvoie la valeur d'un paramètre de demande sous forme de chaîne, ou null si le paramètre n'existe pas. |
17 | String getPathInfo() Renvoie toute information de chemin supplémentaire associée à l'URL que le client a envoyée lors de cette demande |
18 | String getProtocol() Renvoie le nom et la version du protocole de la demande. |
19 | String getQueryString() Renvoie la chaîne de requête contenue dans l'URL de la requête après le chemin. |
20 | String getRemoteAddr() Renvoie l'adresse IP (Internet Protocol) du client qui a envoyé la demande. |
21 | String getRemoteHost() Renvoie le nom complet du client qui a envoyé la demande. |
22 | String getRemoteUser() Renvoie le login de l'utilisateur qui fait cette demande, si l'utilisateur a été authentifié, ou null si l'utilisateur n'a pas été authentifié. |
23 | String getRequestURI() Renvoie la partie de l'URL de cette requête depuis le nom du protocole jusqu'à la chaîne de requête dans la première ligne de la requête HTTP. |
24 | String getRequestedSessionId() Renvoie l'ID de session spécifié par le client. |
25 | String getServletPath() Renvoie la partie de l'URL de cette requête qui appelle la JSP. |
26 | String[] getParameterValues(String name) Renvoie un tableau d'objets String contenant toutes les valeurs du paramètre de demande donné, ou null si le paramètre n'existe pas. |
27 | boolean isSecure() Renvoie une valeur booléenne indiquant si cette demande a été effectuée à l'aide d'un canal sécurisé, tel que HTTPS. |
28 | int getContentLength() Renvoie la longueur, en octets, du corps de la requête et mis à disposition par le flux d'entrée, ou -1 si la longueur n'est pas connue. |
29 | int getIntHeader(String name) Renvoie la valeur de l'en-tête de demande spécifié sous la forme d'un entier. |
30 | int getServerPort() Renvoie le numéro de port sur lequel cette demande a été reçue. |
Exemple de demande d'en-tête HTTP
Voici l'exemple qui utilise getHeaderNames()méthode de HttpServletRequest pour lire les informations d'en-tête HTTP. Cette méthode renvoie une énumération qui contient les informations d'en-tête associées à la requête HTTP actuelle.
Une fois que nous avons une énumération, nous pouvons boucler l'énumération de manière standard, en utilisant la méthode hasMoreElements () pour déterminer quand arrêter et en utilisant la méthode nextElement () pour obtenir chaque nom de paramètre
// Import required java libraries
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
import java.util.*;
// Extend HttpServlet class
public class DisplayHeader extends HttpServlet {
// Method to handle GET method request.
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
// Set response content type
response.setContentType("text/html");
PrintWriter out = response.getWriter();
String title = "HTTP Header Request Example";
String docType =
"<!doctype html public \"-//w3c//dtd html 4.0 " + "transitional//en\">\n";
out.println(docType +
"<html>\n" +
"<head><title>" + title + "</title></head>\n"+
"<body bgcolor = \"#f0f0f0\">\n" +
"<h1 align = \"center\">" + title + "</h1>\n" +
"<table width = \"100%\" border = \"1\" align = \"center\">\n" +
"<tr bgcolor = \"#949494\">\n" +
"<th>Header Name</th><th>Header Value(s)</th>\n"+
"</tr>\n"
);
Enumeration headerNames = request.getHeaderNames();
while(headerNames.hasMoreElements()) {
String paramName = (String)headerNames.nextElement();
out.print("<tr><td>" + paramName + "</td>\n");
String paramValue = request.getHeader(paramName);
out.println("<td> " + paramValue + "</td></tr>\n");
}
out.println("</table>\n</body></html>");
}
// Method to handle POST method request.
public void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
doGet(request, response);
}
}
Maintenant, appeler le servlet ci-dessus générerait le résultat suivant -
HTTP Header Request Example
Header Name
Header Value(s)
accept
*/*
accept-language
en-us
user-agent
Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.1; Trident/4.0; InfoPath.2; MS-RTC LM 8)
accept-encoding
gzip, deflate
host
localhost:8080
connection
Keep-Alive
cache-control
no-cache
Comme indiqué dans le chapitre précédent, lorsqu'un serveur Web répond à une requête HTTP, la réponse se compose généralement d'une ligne d'état, de certains en-têtes de réponse, d'une ligne vide et du document. Une réponse typique ressemble à ceci -
HTTP/1.1 200 OK
Content-Type: text/html
Header2: ...
...
HeaderN: ...
(Blank Line)
<!doctype ...>
<html>
<head>...</head>
<body>
...
</body>
</html>
La ligne d'état se compose de la version HTTP (HTTP / 1.1 dans l'exemple), d'un code d'état (200 dans l'exemple) et d'un message très court correspondant au code d'état (OK dans l'exemple).
Voici un résumé des en-têtes de réponse HTTP 1.1 les plus utiles qui retournent au navigateur du côté du serveur Web et que vous les utiliseriez très fréquemment dans la programmation Web -
Sr.No. | En-tête et description |
---|---|
1 | Allow Cet en-tête spécifie les méthodes de requête (GET, POST, etc.) que le serveur prend en charge. |
2 | Cache-Control Cet en-tête spécifie les circonstances dans lesquelles le document de réponse peut être mis en cache en toute sécurité. Il peut avoir des valeurspublic, private ou no-cache etc. Public signifie que le document peut être mis en cache, Private signifie que le document est destiné à un seul utilisateur et ne peut être stocké que dans des caches privés (non partagés) et nocache signifie que le document ne doit jamais être mis en cache. |
3 | Connection Cet en-tête indique au navigateur s'il doit utiliser ou non persistante dans les connexions HTTP. Une valeur declose indique au navigateur de ne pas utiliser de connexions HTTP persistantes et keepalive signifie utiliser des connexions persistantes. |
4 | Content-Disposition Cet en-tête vous permet de demander au navigateur de demander à l'utilisateur d'enregistrer la réponse sur le disque dans un fichier du nom donné. |
5 | Content-Encoding Cet en-tête spécifie la manière dont la page a été codée lors de la transmission. |
6 | Content-Language Cet en-tête indique la langue dans laquelle le document est rédigé. Par exemple en, en-us, ru, etc. |
sept | Content-Length Cet en-tête indique le nombre d'octets dans la réponse. Ces informations ne sont nécessaires que si le navigateur utilise une connexion HTTP persistante (keep-alive). |
8 | Content-Type Cet en-tête donne le type MIME (Multipurpose Internet Mail Extension) du document de réponse. |
9 | Expires Cet en-tête spécifie l'heure à laquelle le contenu doit être considéré comme obsolète et donc ne plus être mis en cache. |
dix | Last-Modified Cet en-tête indique quand le document a été modifié pour la dernière fois. Le client peut alors mettre en cache le document et fournir une date par unIf-Modified-Since en-tête de demande dans les demandes ultérieures. |
11 | Location Cet en-tête doit être inclus avec toutes les réponses qui ont un code d'état dans les 300. Cela informe le navigateur de l'adresse du document. Le navigateur se reconnecte automatiquement à cet emplacement et récupère le nouveau document. |
12 | Refresh Cet en-tête spécifie à quel moment le navigateur doit demander une page mise à jour. Vous pouvez spécifier la durée en nombre de secondes après laquelle une page sera actualisée. |
13 | Retry-After Cet en-tête peut être utilisé en conjonction avec une réponse 503 (Service non disponible) pour indiquer au client à quel moment il peut répéter sa demande. |
14 | Set-Cookie Cet en-tête spécifie un cookie associé à la page. |
Méthodes pour définir l'en-tête de réponse HTTP
Les méthodes suivantes peuvent être utilisées pour définir l'en-tête de réponse HTTP dans votre programme de servlet. Ces méthodes sont disponibles avec l' objet HttpServletResponse .
Sr.No. | Méthode et description |
---|---|
1 | String encodeRedirectURL(String url) Encode l'URL spécifiée à utiliser dans la méthode sendRedirect ou, si l'encodage n'est pas nécessaire, renvoie l'URL inchangée. |
2 | String encodeURL(String url) Encode l'URL spécifiée en y incluant l'ID de session ou, si l'encodage n'est pas nécessaire, renvoie l'URL inchangée. |
3 | boolean containsHeader(String name) Renvoie une valeur booléenne indiquant si l'en-tête de réponse nommé a déjà été défini. |
4 | boolean isCommitted() Renvoie une valeur booléenne indiquant si la réponse a été validée. |
5 | void addCookie(Cookie cookie) Ajoute le cookie spécifié à la réponse. |
6 | void addDateHeader(String name, long date) Ajoute un en-tête de réponse avec le nom et la valeur de date donnés. |
sept | void addHeader(String name, String value) Ajoute un en-tête de réponse avec le nom et la valeur donnés. |
8 | void addIntHeader(String name, int value) Ajoute un en-tête de réponse avec le nom et la valeur entière donnés. |
9 | void flushBuffer() Force tout contenu de la mémoire tampon à être écrit sur le client. |
dix | void reset() Efface toutes les données qui existent dans la mémoire tampon ainsi que le code d'état et les en-têtes. |
11 | void resetBuffer() Efface le contenu du tampon sous-jacent dans la réponse sans effacer les en-têtes ou le code d'état. |
12 | void sendError(int sc) Envoie une réponse d'erreur au client en utilisant le code d'état spécifié et en effaçant la mémoire tampon. |
13 | void sendError(int sc, String msg) Envoie une réponse d'erreur au client en utilisant l'état spécifié. |
14 | void sendRedirect(String location) Envoie une réponse de redirection temporaire au client en utilisant l'URL d'emplacement de redirection spécifiée. |
15 | void setBufferSize(int size) Définit la taille de tampon préférée pour le corps de la réponse. |
16 | void setCharacterEncoding(String charset) Définit le codage de caractères (jeu de caractères MIME) de la réponse envoyée au client, par exemple, sur UTF-8. |
17 | void setContentLength(int len) Définit la longueur du corps du contenu dans la réponse Dans les servlets HTTP, cette méthode définit l'en-tête HTTP Content-Length. |
18 | void setContentType(String type) Définit le type de contenu de la réponse envoyée au client, si la réponse n'a pas encore été validée. |
19 | void setDateHeader(String name, long date) Définit un en-tête de réponse avec le nom et la valeur de date donnés. |
20 | void setHeader(String name, String value) Définit un en-tête de réponse avec le nom et la valeur donnés. |
21 | void setIntHeader(String name, int value) Définit un en-tête de réponse avec le nom et la valeur entière donnés |
22 | void setLocale(Locale loc) Définit les paramètres régionaux de la réponse, si la réponse n'a pas encore été validée. |
23 | void setStatus(int sc) Définit le code d'état de cette réponse |
Exemple de réponse d'en-tête HTTP
Vous avez déjà vu la méthode setContentType () fonctionner dans les exemples précédents et l'exemple suivant utiliserait également la même méthode, en plus nous utiliserions setIntHeader() méthode à définir Refresh entête.
// Import required java libraries
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
import java.util.*;
// Extend HttpServlet class
public class Refresh extends HttpServlet {
// Method to handle GET method request.
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
// Set refresh, autoload time as 5 seconds
response.setIntHeader("Refresh", 5);
// Set response content type
response.setContentType("text/html");
// Get current time
Calendar calendar = new GregorianCalendar();
String am_pm;
int hour = calendar.get(Calendar.HOUR);
int minute = calendar.get(Calendar.MINUTE);
int second = calendar.get(Calendar.SECOND);
if(calendar.get(Calendar.AM_PM) == 0)
am_pm = "AM";
else
am_pm = "PM";
String CT = hour+":"+ minute +":"+ second +" "+ am_pm;
PrintWriter out = response.getWriter();
String title = "Auto Refresh Header Setting";
String docType =
"<!doctype html public \"-//w3c//dtd html 4.0 " + "transitional//en\">\n";
out.println(docType +
"<html>\n" +
"<head><title>" + title + "</title></head>\n"+
"<body bgcolor = \"#f0f0f0\">\n" +
"<h1 align = \"center\">" + title + "</h1>\n" +
"<p>Current Time is: " + CT + "</p>\n"
);
}
// Method to handle POST method request.
public void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
doGet(request, response);
}
}
Maintenant, appeler le servlet ci-dessus afficherait l'heure système actuelle toutes les 5 secondes comme suit. Exécutez simplement le servlet et attendez de voir le résultat -
Auto Refresh Header Setting
Current Time is: 9:44:50 PM
Le format de la requête HTTP et des messages de réponse HTTP sont similaires et auront la structure suivante -
Une ligne d'état initial + CRLF (retour chariot + saut de ligne c'est-à-dire nouvelle ligne)
Zéro ou plusieurs lignes d'en-tête + CRLF
Une ligne vide, c'est-à-dire un CRLF
Un corps de message facultatif comme un fichier, des données de requête ou une sortie de requête.
Par exemple, un en-tête de réponse de serveur se présente comme suit -
HTTP/1.1 200 OK
Content-Type: text/html
Header2: ...
...
HeaderN: ...
(Blank Line)
<!doctype ...>
<html>
<head>...</head>
<body>
...
</body>
</html>
La ligne d'état se compose de la version HTTP (HTTP / 1.1 dans l'exemple), d'un code d'état (200 dans l'exemple) et d'un message très court correspondant au code d'état (OK dans l'exemple).
Voici une liste des codes d'état HTTP et des messages associés qui peuvent être renvoyés par le serveur Web -
Code | Message | La description |
---|---|---|
100 | Continuer | Seule une partie de la demande a été reçue par le serveur, mais tant qu'elle n'a pas été rejetée, le client doit continuer avec la demande |
101 | Protocoles de commutation | Le serveur change de protocole. |
200 | D'accord | La demande est OK |
201 | Établi | La demande est terminée et une nouvelle ressource est créée |
202 | Accepté | La demande est acceptée pour le traitement, mais le traitement n'est pas terminé. |
203 | Informations ne faisant pas autorité | |
204 | Pas de contenu | |
205 | Réinitialiser le contenu | |
206 | Contenu partiel | |
300 | Choix multiples | Une liste de liens. L'utilisateur peut sélectionner un lien et accéder à cet emplacement. Maximum cinq adresses |
301 | Déplacé définitivement | La page demandée a été déplacée vers une nouvelle URL |
302 | A trouvé | La page demandée a été déplacée temporairement vers une nouvelle URL |
303 | Voir autre | La page demandée se trouve sous une URL différente |
304 | Non modifié | |
305 | Utiliser un proxy | |
306 | Inutilisé | Ce code était utilisé dans une version précédente. Il n'est plus utilisé, mais le code est réservé |
307 | Redirection temporaire | La page demandée a été déplacée temporairement vers une nouvelle URL. |
400 | Mauvaise Demande | Le serveur n'a pas compris la demande |
401 | Non autorisé | La page demandée a besoin d'un nom d'utilisateur et d'un mot de passe |
402 | Paiement Requis | Vous ne pouvez pas encore utiliser ce code |
403 | Interdit | L'accès à la page demandée est interdit |
404 | Pas trouvé | Le serveur ne trouve pas la page demandée. |
405 | Méthode Non Autorisée | La méthode spécifiée dans la demande n'est pas autorisée. |
406 | Pas acceptable | Le serveur ne peut générer qu'une réponse non acceptée par le client. |
407 | Authentification proxy requise | Vous devez vous authentifier auprès d'un serveur proxy avant que cette demande puisse être servie. |
408 | Délai d'expiration de la demande | La demande a pris plus de temps que le serveur était prêt à attendre. |
409 | Conflit | La demande n'a pas pu être exécutée en raison d'un conflit. |
410 | Disparu | La page demandée n'est plus disponible. |
411 | Longueur requise | Le "Content-Length" n'est pas défini. Le serveur n'acceptera pas la demande sans elle. |
412 | La condition préalable a échoué | La condition préalable donnée dans la requête évaluée à false par le serveur. |
413 | Demande d'entité trop grande | Le serveur n'acceptera pas la demande, car l'entité de demande est trop volumineuse. |
414 | Request-url trop long | Le serveur n'acceptera pas la demande, car l'URL est trop longue. Se produit lorsque vous convertissez une requête «post» en une requête «get» avec des informations de requête longues. |
415 | Type de support non pris en charge | Le serveur n'acceptera pas la demande, car le type de média n'est pas pris en charge. |
417 | L'attente a échoué | |
500 | Erreur Interne du Serveur | La demande n'a pas été complétée. Le serveur a rencontré une condition inattendue. |
501 | Pas mis en œuvre | La demande n'a pas été complétée. Le serveur ne prenait pas en charge la fonctionnalité requise. |
502 | Mauvaise passerelle | La demande n'a pas été complétée. Le serveur a reçu une réponse non valide du serveur en amont. |
503 | Service indisponible | La demande n'a pas été complétée. Le serveur est temporairement en surcharge ou en panne. |
504 | Délai d'expiration de la passerelle | La passerelle a expiré. |
505 | Version HTTP non prise en charge | Le serveur ne prend pas en charge la version "protocole http". |
Méthodes pour définir le code d'état HTTP
Les méthodes suivantes peuvent être utilisées pour définir le code d'état HTTP dans votre programme de servlet. Ces méthodes sont disponibles avec l' objet HttpServletResponse .
Sr.No. | Méthode et description |
---|---|
1 | public void setStatus ( int statusCode ) Cette méthode définit un code d'état arbitraire. La méthode setStatus prend un int (le code d'état) comme argument. Si votre réponse comprend un code d'état spécial et un document, assurez-vous d'appeler setStatus avant de renvoyer réellement tout le contenu avec PrintWriter . |
2 | public void sendRedirect(String url) Cette méthode génère une réponse 302 avec un en- tête Location donnant l'URL du nouveau document |
3 | public void sendError(int code, String message) Cette méthode envoie un code d'état (généralement 404) avec un court message qui est automatiquement mis en forme dans un document HTML et envoyé au client. |
Exemple de code d'état HTTP
Voici l'exemple qui enverrait un code d'erreur 407 au navigateur client et le navigateur vous montrerait "Besoin d'authentification !!!" message.
// Import required java libraries
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
import java.util.*;
// Extend HttpServlet class
public class showError extends HttpServlet {
// Method to handle GET method request.
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
// Set error code and reason.
response.sendError(407, "Need authentication!!!" );
}
// Method to handle POST method request.
public void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
doGet(request, response);
}
}
Maintenant, appeler le servlet ci-dessus afficherait le résultat suivant -
HTTP Status 407 - Need authentication!!!
type Status report
messageNeed authentication!!!
descriptionThe client must first authenticate itself with the proxy (Need authentication!!!).
Apache Tomcat/5.5.29
Les filtres de servlet sont des classes Java qui peuvent être utilisées dans la programmation de servlet aux fins suivantes:
Pour intercepter les demandes d'un client avant qu'il n'accède à une ressource en back-end.
Pour manipuler les réponses du serveur avant qu'elles ne soient renvoyées au client.
Il existe différents types de filtres suggérés par les spécifications -
- Filtres d'authentification.
- Filtres de compression de données.
- Filtres de cryptage.
- Filtres qui déclenchent des événements d'accès aux ressources.
- Filtres de conversion d'image.
- Filtres de journalisation et d'audit.
- Filtres de chaîne de TYPE MIME.
- Filtres de tokenisation.
- Filtres XSL / T qui transforment le contenu XML.
Les filtres sont déployés dans le fichier descripteur de déploiement web.xml puis mappez vers les noms de servlet ou les modèles d'URL dans le descripteur de déploiement de votre application.
Lorsque le conteneur Web démarre votre application Web, il crée une instance de chaque filtre que vous avez déclaré dans le descripteur de déploiement. Les filtres s'exécutent dans l'ordre dans lequel ils sont déclarés dans le descripteur de déploiement.
Méthodes de filtrage des servlets
Un filtre est simplement une classe Java qui implémente l'interface javax.servlet.Filter. L'interface javax.servlet.Filter définit trois méthodes -
Sr.No. | Méthode et description |
---|---|
1 | public void doFilter (ServletRequest, ServletResponse, FilterChain) Cette méthode est appelée par le conteneur à chaque fois qu'une paire demande / réponse est passée dans la chaîne en raison d'une demande client pour une ressource à la fin de la chaîne. |
2 | public void init(FilterConfig filterConfig) Cette méthode est appelée par le conteneur Web pour indiquer à un filtre qu'il est mis en service. |
3 | public void destroy() Cette méthode est appelée par le conteneur Web pour indiquer à un filtre qu'il est mis hors service. |
Filtre de servlet - Exemple
Voici l'exemple de filtre de servlet qui imprimerait l'adresse IP du client et l'heure actuelle. Cet exemple vous donnerait une compréhension de base du filtre de servlet, mais vous pouvez écrire des applications de filtre plus sophistiquées en utilisant le même concept -
// Import required java libraries
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
import java.util.*;
// Implements Filter class
public class LogFilter implements Filter {
public void init(FilterConfig config) throws ServletException {
// Get init parameter
String testParam = config.getInitParameter("test-param");
//Print the init parameter
System.out.println("Test Param: " + testParam);
}
public void doFilter(ServletRequest request, ServletResponse response,
FilterChain chain) throws java.io.IOException, ServletException {
// Get the IP address of client machine.
String ipAddress = request.getRemoteAddr();
// Log the IP address and current timestamp.
System.out.println("IP "+ ipAddress + ", Time " + new Date().toString());
// Pass request back down the filter chain
chain.doFilter(request,response);
}
public void destroy( ) {
/* Called before the Filter instance is removed from service by the web container*/
}
}
Compiler LogFilter.java de manière habituelle et placez votre fichier de classe dans <Tomcat-installationdirectory> / webapps / ROOT / WEB-INF / classes
Mappage de filtre de servlet dans Web.xml
Les filtres sont définis puis mappés à une URL ou un servlet, de la même manière que le servlet est défini puis mappé à un modèle d'URL. Créez l'entrée suivante pour la balise de filtre dans le fichier descripteur de déploiementweb.xml
<filter>
<filter-name>LogFilter</filter-name>
<filter-class>LogFilter</filter-class>
<init-param>
<param-name>test-param</param-name>
<param-value>Initialization Paramter</param-value>
</init-param>
</filter>
<filter-mapping>
<filter-name>LogFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
Le filtre ci-dessus s'appliquerait à toutes les servlets car nous avons spécifié /*dans notre configuration. Vous pouvez spécifier un chemin de servlet particulier si vous souhaitez appliquer le filtre à quelques servlets uniquement.
Maintenant, essayez d'appeler n'importe quel servlet de la manière habituelle et vous verrez le journal généré dans le journal de votre serveur Web. Vous pouvez utiliser l'enregistreur Log4J pour enregistrer le journal ci-dessus dans un fichier séparé.
Utilisation de plusieurs filtres
Votre application Web peut définir plusieurs filtres différents dans un but précis. Considérez, vous définissez deux filtres AuthenFilter et LogFilter . Le reste du processus resterait comme expliqué ci-dessus, sauf que vous devez créer un mappage différent comme mentionné ci-dessous -
<filter>
<filter-name>LogFilter</filter-name>
<filter-class>LogFilter</filter-class>
<init-param>
<param-name>test-param</param-name>
<param-value>Initialization Paramter</param-value>
</init-param>
</filter>
<filter>
<filter-name>AuthenFilter</filter-name>
<filter-class>AuthenFilter</filter-class>
<init-param>
<param-name>test-param</param-name>
<param-value>Initialization Paramter</param-value>
</init-param>
</filter>
<filter-mapping>
<filter-name>LogFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
<filter-mapping>
<filter-name>AuthenFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
Ordre des applications des filtres
L'ordre des éléments de mappage de filtre dans web.xml détermine l'ordre dans lequel le conteneur Web applique le filtre au servlet. Pour inverser l'ordre du filtre, il vous suffit d'inverser les éléments de mappage de filtre dans le fichier web.xml.
Par exemple, l'exemple ci-dessus appliquerait d'abord LogFilter, puis AuthenFilter à n'importe quel servlet, mais l'exemple suivant inverserait l'ordre -
<filter-mapping>
<filter-name>AuthenFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
<filter-mapping>
<filter-name>LogFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
Lorsqu'un servlet lève une exception, le conteneur Web recherche les configurations dans web.xml qui utilisent l'élément de type exception pour une correspondance avec le type d'exception levé.
Vous devrez utiliser le error-page élément dans web.xml pour spécifier l'appel des servlets en réponse à certains exceptions ou HTTP status codes.
Configuration web.xml
Considérez, vous avez un servlet ErrorHandler qui serait appelé chaque fois qu'il y a une exception ou une erreur définie. Voici l'entrée créée dans web.xml.
<!-- servlet definition -->
<servlet>
<servlet-name>ErrorHandler</servlet-name>
<servlet-class>ErrorHandler</servlet-class>
</servlet>
<!-- servlet mappings -->
<servlet-mapping>
<servlet-name>ErrorHandler</servlet-name>
<url-pattern>/ErrorHandler</url-pattern>
</servlet-mapping>
<!-- error-code related error pages -->
<error-page>
<error-code>404</error-code>
<location>/ErrorHandler</location>
</error-page>
<error-page>
<error-code>403</error-code>
<location>/ErrorHandler</location>
</error-page>
<!-- exception-type related error pages -->
<error-page>
<exception-type>
javax.servlet.ServletException
</exception-type >
<location>/ErrorHandler</location>
</error-page>
<error-page>
<exception-type>java.io.IOException</exception-type >
<location>/ErrorHandler</location>
</error-page>
Si vous voulez avoir un gestionnaire d'erreurs générique pour toutes les exceptions, vous devez définir la page d'erreur suivante au lieu de définir des éléments de page d'erreur séparés pour chaque exception -
<error-page>
<exception-type>java.lang.Throwable</exception-type >
<location>/ErrorHandler</location>
</error-page>
Voici les points à noter sur le fichier web.xml ci-dessus pour la gestion des exceptions -
Le servlet ErrorHandler est défini de la manière habituelle comme n'importe quel autre servlet et configuré dans web.xml.
S'il y a une erreur avec le code d'état 404 (non trouvé) ou 403 (interdit), le servlet ErrorHandler est appelé.
Si l'application Web lève ServletException ou IOException, le conteneur Web appelle le servlet / ErrorHandler.
Vous pouvez définir différents gestionnaires d'erreurs pour gérer différents types d'erreurs ou d'exceptions. L'exemple ci-dessus est très générique et j'espère qu'il servira à vous expliquer le concept de base.
Attributs de demande - Erreurs / exceptions
Voici la liste des attributs de requête auxquels un servlet de gestion des erreurs peut accéder pour analyser la nature de l'erreur / exception.
Sr.No. | Attribut et description |
---|---|
1 | javax.servlet.error.status_code Cet attribut donne un code d'état qui peut être stocké et analysé après stockage dans un type de données java.lang.Integer. |
2 | javax.servlet.error.exception_type Cet attribut donne des informations sur le type d'exception qui peut être stocké et analysé après stockage dans un type de données java.lang.Class. |
3 | javax.servlet.error.message Cet attribut donne des informations de message d'erreur exact qui peuvent être stockées et analysées après stockage dans un type de données java.lang.String. |
4 | javax.servlet.error.request_uri Cet attribut donne des informations sur l'URL appelant le servlet et il peut être stocké et analysé après stockage dans un type de données java.lang.String. |
5 | javax.servlet.error.exception Cet attribut donne des informations sur l'exception déclenchée, qui peuvent être stockées et analysées. |
6 | javax.servlet.error.servlet_name Cet attribut donne le nom du servlet qui peut être stocké et analysé après stockage dans un type de données java.lang.String. |
Exemple de servlet de gestionnaire d'erreurs
Cet exemple vous donnera une compréhension de base de la gestion des exceptions dans Servlet, mais vous pouvez écrire des applications de filtrage plus sophistiquées en utilisant le même concept -
// Import required java libraries
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
import java.util.*;
// Extend HttpServlet class
public class ErrorHandler extends HttpServlet {
// Method to handle GET method request.
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
// Analyze the servlet exception
Throwable throwable = (Throwable)
request.getAttribute("javax.servlet.error.exception");
Integer statusCode = (Integer)
request.getAttribute("javax.servlet.error.status_code");
String servletName = (String)
request.getAttribute("javax.servlet.error.servlet_name");
if (servletName == null) {
servletName = "Unknown";
}
String requestUri = (String)
request.getAttribute("javax.servlet.error.request_uri");
if (requestUri == null) {
requestUri = "Unknown";
}
// Set response content type
response.setContentType("text/html");
PrintWriter out = response.getWriter();
String title = "Error/Exception Information";
String docType =
"<!doctype html public \"-//w3c//dtd html 4.0 " +
"transitional//en\">\n";
out.println(docType +
"<html>\n" +
"<head><title>" + title + "</title></head>\n" +
"<body bgcolor = \"#f0f0f0\">\n");
if (throwable == null && statusCode == null) {
out.println("<h2>Error information is missing</h2>");
out.println("Please return to the <a href=\"" +
response.encodeURL("http://localhost:8080/") +
"\">Home Page</a>.");
} else if (statusCode != null) {
out.println("The status code : " + statusCode);
} else {
out.println("<h2>Error information</h2>");
out.println("Servlet Name : " + servletName + "</br></br>");
out.println("Exception Type : " + throwable.getClass( ).getName( ) + "</br></br>");
out.println("The request URI: " + requestUri + "<br><br>");
out.println("The exception message: " + throwable.getMessage( ));
}
out.println("</body>");
out.println("</html>");
}
// Method to handle POST method request.
public void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
doGet(request, response);
}
}
Compiler ErrorHandler.java de manière habituelle et mettez votre fichier de classe dans
Ajoutons la configuration suivante dans web.xml pour gérer les exceptions -
<servlet>
<servlet-name>ErrorHandler</servlet-name>
<servlet-class>ErrorHandler</servlet-class>
</servlet>
<!-- servlet mappings -->
<servlet-mapping>
<servlet-name>ErrorHandler</servlet-name>
<url-pattern>/ErrorHandler</url-pattern>
</servlet-mapping>
<error-page>
<error-code>404</error-code>
<location>/ErrorHandler</location>
</error-page>
<error-page>
<exception-type>java.lang.Throwable</exception-type >
<location>/ErrorHandler</location>
</error-page>
Maintenant, essayez d'utiliser un servlet qui lève une exception ou saisit une URL incorrecte, cela déclencherait l'appel de Web Container ErrorHandlerservlet et afficher un message approprié tel que programmé. Par exemple, si vous saisissez une URL incorrecte, le résultat suivant s'affiche:
The status code : 404
Le code ci-dessus peut ne pas fonctionner avec certains navigateurs Web. Alors essayez avec Mozilla et Safari et cela devrait fonctionner.
Les cookies sont des fichiers texte stockés sur l'ordinateur client et ils sont conservés à diverses fins de suivi des informations. Les servlets Java prennent en charge de manière transparente les cookies HTTP.
Il y a trois étapes pour identifier les utilisateurs qui reviennent -
Le script serveur envoie un ensemble de cookies au navigateur. Par exemple, le nom, l'âge ou le numéro d'identification, etc.
Le navigateur stocke ces informations sur la machine locale pour une utilisation future.
La prochaine fois que le navigateur envoie une demande au serveur Web, il envoie ces informations sur les cookies au serveur et le serveur utilise ces informations pour identifier l'utilisateur.
Ce chapitre vous apprendra comment définir ou réinitialiser les cookies, comment y accéder et comment les supprimer.
L'anatomie d'un cookie
Les cookies sont généralement définis dans un en-tête HTTP (bien que JavaScript puisse également définir un cookie directement sur un navigateur). Un servlet qui définit un cookie peut envoyer des en-têtes qui ressemblent à ceci -
HTTP/1.1 200 OK
Date: Fri, 04 Feb 2000 21:03:38 GMT
Server: Apache/1.3.9 (UNIX) PHP/4.0b3
Set-Cookie: name = xyz; expires = Friday, 04-Feb-07 22:03:38 GMT;
path = /; domain = tutorialspoint.com
Connection: close
Content-Type: text/html
Comme vous pouvez le voir, l'en-tête Set-Cookie contient une paire de valeur de nom, une date GMT, un chemin et un domaine. Le nom et la valeur seront encodés en URL. Le champ expire est une instruction au navigateur pour "oublier" le cookie après l'heure et la date données.
Si le navigateur est configuré pour stocker des cookies, il conservera alors ces informations jusqu'à la date d'expiration. Si l'utilisateur pointe le navigateur vers une page qui correspond au chemin et au domaine du cookie, il renverra le cookie au serveur. Les en-têtes du navigateur peuvent ressembler à ceci -
GET / HTTP/1.0
Connection: Keep-Alive
User-Agent: Mozilla/4.6 (X11; I; Linux 2.2.6-15apmac ppc)
Host: zink.demon.co.uk:1126
Accept: image/gif, */*
Accept-Encoding: gzip
Accept-Language: en
Accept-Charset: iso-8859-1,*,utf-8
Cookie: name = xyz
Un servlet aura alors accès au cookie via la méthode de requête request.getCookies () qui retourne un tableau d' objets Cookie .
Méthodes de cookies de servlet
Voici la liste des méthodes utiles que vous pouvez utiliser lors de la manipulation des cookies dans le servlet.
Sr.No. | Méthode et description |
---|---|
1 | public void setDomain(String pattern) Cette méthode définit le domaine auquel s'applique le cookie, par exemple tutorialspoint.com. |
2 | public String getDomain() Cette méthode obtient le domaine auquel s'applique le cookie, par exemple tutorialspoint.com. |
3 | public void setMaxAge(int expiry) Cette méthode définit la durée (en secondes) qui doit s'écouler avant l'expiration du cookie. Si vous ne définissez pas cela, le cookie ne durera que pour la session en cours. |
4 | public int getMaxAge() Cette méthode renvoie l'âge maximum du cookie, spécifié en secondes. Par défaut, -1 indique que le cookie persistera jusqu'à l'arrêt du navigateur. |
5 | public String getName() Cette méthode renvoie le nom du cookie. Le nom ne peut pas être modifié après la création. |
6 | public void setValue(String newValue) Cette méthode définit la valeur associée au cookie |
sept | public String getValue() Cette méthode obtient la valeur associée au cookie. |
8 | public void setPath(String uri) Cette méthode définit le chemin auquel ce cookie s'applique. Si vous ne spécifiez pas de chemin, le cookie est renvoyé pour toutes les URL dans le même répertoire que la page actuelle ainsi que pour tous les sous-répertoires. |
9 | public String getPath() Cette méthode obtient le chemin auquel ce cookie s'applique. |
dix | public void setSecure(boolean flag) Cette méthode définit la valeur booléenne indiquant si le cookie doit être envoyé uniquement via des connexions cryptées (c'est-à-dire SSL). |
11 | public void setComment(String purpose) Cette méthode spécifie un commentaire qui décrit le but d'un cookie. Le commentaire est utile si le navigateur présente le cookie à l'utilisateur. |
12 | public String getComment() Cette méthode retourne le commentaire décrivant le but de ce cookie, ou null si le cookie n'a pas de commentaire. |
Définition de cookies avec Servlet
La configuration des cookies avec servlet implique trois étapes -
(1) Creating a Cookie object - Vous appelez le constructeur Cookie avec un nom de cookie et une valeur de cookie, qui sont tous deux des chaînes.
Cookie cookie = new Cookie("key","value");
Gardez à l'esprit que ni le nom ni la valeur ne doivent contenir d'espace blanc ou l'un des caractères suivants -
[ ] ( ) = , " / ? @ : ;
(2) Setting the maximum age- Vous utilisez setMaxAge pour spécifier la durée (en secondes) du cookie doit être valide. La suite mettrait en place un cookie pendant 24 heures.
cookie.setMaxAge(60 * 60 * 24);
(3) Sending the Cookie into the HTTP response headers - Vous utilisez response.addCookie pour ajouter des cookies dans l'en-tête de réponse HTTP comme suit -
response.addCookie(cookie);
Exemple
Modifions notre exemple de formulaire pour définir les cookies pour le prénom et le nom.
// Import required java libraries
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
// Extend HttpServlet class
public class HelloForm extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
// Create cookies for first and last names.
Cookie firstName = new Cookie("first_name", request.getParameter("first_name"));
Cookie lastName = new Cookie("last_name", request.getParameter("last_name"));
// Set expiry date after 24 Hrs for both the cookies.
firstName.setMaxAge(60*60*24);
lastName.setMaxAge(60*60*24);
// Add both the cookies in the response header.
response.addCookie( firstName );
response.addCookie( lastName );
// Set response content type
response.setContentType("text/html");
PrintWriter out = response.getWriter();
String title = "Setting Cookies Example";
String docType =
"<!doctype html public \"-//w3c//dtd html 4.0 " + "transitional//en\">\n";
out.println(docType +
"<html>\n" +
"<head>
<title>" + title + "</title>
</head>\n" +
"<body bgcolor = \"#f0f0f0\">\n" +
"<h1 align = \"center\">" + title + "</h1>\n" +
"<ul>\n" +
" <li><b>First Name</b>: "
+ request.getParameter("first_name") + "\n" +
" <li><b>Last Name</b>: "
+ request.getParameter("last_name") + "\n" +
"</ul>\n" +
"</body>
</html>"
);
}
}
Compilez le servlet ci-dessus HelloForm et créez l'entrée appropriée dans le fichier web.xml et essayez enfin de suivre la page HTML pour appeler le servlet.
<html>
<body>
<form action = "HelloForm" method = "GET">
First Name: <input type = "text" name = "first_name">
<br />
Last Name: <input type = "text" name = "last_name" />
<input type = "submit" value = "Submit" />
</form>
</body>
</html>
Conservez le contenu HTML au-dessus dans un fichier Hello.htm et placez-le dans le répertoire <Tomcat-installationdirectory> / webapps / ROOT. Lorsque vous accéderez à http: // localhost: 8080 / Hello.htm , voici la sortie réelle du formulaire ci-dessus.
Essayez d'entrer le prénom et le nom, puis cliquez sur le bouton Soumettre. Cela afficherait le prénom et le nom sur votre écran et en même temps cela définirait deux cookies firstName et lastName qui seraient renvoyés au serveur la prochaine fois que vous appuyez sur le bouton Soumettre.
La section suivante vous explique comment accéder à ces cookies dans votre application Web.
Lire les cookies avec Servlet
Pour lire les cookies, vous devez créer un tableau d' objets javax.servlet.http.Cookie en appelant legetCookies()méthode de HttpServletRequest . Parcourez ensuite le tableau et utilisez les méthodes getName () et getValue () pour accéder à chaque cookie et à la valeur associée.
Exemple
Lisons les cookies que nous avons définis dans l'exemple précédent -
// Import required java libraries
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
// Extend HttpServlet class
public class ReadCookies extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
Cookie cookie = null;
Cookie[] cookies = null;
// Get an array of Cookies associated with this domain
cookies = request.getCookies();
// Set response content type
response.setContentType("text/html");
PrintWriter out = response.getWriter();
String title = "Reading Cookies Example";
String docType =
"<!doctype html public \"-//w3c//dtd html 4.0 " +
"transitional//en\">\n";
out.println(docType +
"<html>\n" +
"<head><title>" + title + "</title></head>\n" +
"<body bgcolor = \"#f0f0f0\">\n" );
if( cookies != null ) {
out.println("<h2> Found Cookies Name and Value</h2>");
for (int i = 0; i < cookies.length; i++) {
cookie = cookies[i];
out.print("Name : " + cookie.getName( ) + ", ");
out.print("Value: " + cookie.getValue( ) + " <br/>");
}
} else {
out.println("<h2>No cookies founds</h2>");
}
out.println("</body>");
out.println("</html>");
}
}
Compiler au-dessus du servlet ReadCookieset créez l'entrée appropriée dans le fichier web.xml. Si vous aviez défini le cookie first_name comme "John" et le cookie last_name comme "Player", alors exécuter http: // localhost: 8080 / ReadCookies afficherait le résultat suivant -
Found Cookies Name and Value
Name : first_name, Value: John
Name : last_name, Value: Player
Supprimer les cookies avec Servlet
Supprimer les cookies est très simple. Si vous souhaitez supprimer un cookie, il vous suffit de suivre les trois étapes suivantes -
Lisez un cookie déjà existant et stockez-le dans l'objet Cookie.
Définir l'âge des cookies sur zéro en utilisant setMaxAge() méthode pour supprimer un cookie existant
Ajoutez ce cookie dans l'en-tête de la réponse.
Exemple
L'exemple suivant supprimerait le cookie existant nommé "first_name" et lorsque vous exécuteriez le servlet ReadCookies la prochaine fois, il renverrait une valeur nulle pour first_name.
// Import required java libraries
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
// Extend HttpServlet class
public class DeleteCookies extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
Cookie cookie = null;
Cookie[] cookies = null;
// Get an array of Cookies associated with this domain
cookies = request.getCookies();
// Set response content type
response.setContentType("text/html");
PrintWriter out = response.getWriter();
String title = "Delete Cookies Example";
String docType =
"<!doctype html public \"-//w3c//dtd html 4.0 " + "transitional//en\">\n";
out.println(docType +
"<html>\n" +
"<head><title>" + title + "</title></head>\n" +
"<body bgcolor = \"#f0f0f0\">\n" );
if( cookies != null ) {
out.println("<h2> Cookies Name and Value</h2>");
for (int i = 0; i < cookies.length; i++) {
cookie = cookies[i];
if((cookie.getName( )).compareTo("first_name") == 0 ) {
cookie.setMaxAge(0);
response.addCookie(cookie);
out.print("Deleted cookie : " + cookie.getName( ) + "<br/>");
}
out.print("Name : " + cookie.getName( ) + ", ");
out.print("Value: " + cookie.getValue( )+" <br/>");
}
} else {
out.println("<h2>No cookies founds</h2>");
}
out.println("</body>");
out.println("</html>");
}
}
Compiler au-dessus du servlet DeleteCookieset créez l'entrée appropriée dans le fichier web.xml. Maintenant, exécutant http: // localhost: 8080 / DeleteCookies afficherait le résultat suivant -
Cookies Name and Value
Deleted cookie : first_name
Name : first_name, Value: John
Name : last_name, Value: Player
Maintenant, essayez d'exécuter http: // localhost: 8080 / ReadCookies et il n'afficherait qu'un seul cookie comme suit -
Found Cookies Name and Value
Name : last_name, Value: Player
Vous pouvez supprimer manuellement vos cookies dans Internet Explorer. Démarrez dans le menu Outils et sélectionnez Options Internet. Pour supprimer tous les cookies, appuyez sur Supprimer les cookies.
HTTP est un protocole «sans état», ce qui signifie que chaque fois qu'un client récupère une page Web, le client ouvre une connexion distincte au serveur Web et le serveur ne conserve automatiquement aucun enregistrement de la demande client précédente.
Il existe toujours trois façons de maintenir la session entre le client Web et le serveur Web -
Biscuits
Un serveur Web peut attribuer un identifiant de session unique en tant que cookie à chaque client Web et pour les demandes ultérieures du client, il peut être reconnu à l'aide du cookie reçu.
Cela peut ne pas être un moyen efficace car le navigateur de nombreuses fois ne prend pas en charge un cookie, donc je ne recommanderais pas d'utiliser cette procédure pour maintenir les sessions.
Champs de formulaire masqués
Un serveur Web peut envoyer un champ de formulaire HTML masqué avec un ID de session unique comme suit -
<input type = "hidden" name = "sessionid" value = "12345">
Cette entrée signifie que, lorsque le formulaire est soumis, le nom et la valeur spécifiés sont automatiquement inclus dans les données GET ou POST. Chaque fois que le navigateur Web renvoie la demande, la valeur session_id peut être utilisée pour garder la trace des différents navigateurs Web.
Cela pourrait être un moyen efficace de garder une trace de la session, mais le fait de cliquer sur un lien hypertexte régulier (<A HREF...>) n'entraîne pas l'envoi d'un formulaire, de sorte que les champs de formulaire masqués ne peuvent pas non plus prendre en charge le suivi général de la session.
Réécriture d'URL
Vous pouvez ajouter des données supplémentaires à la fin de chaque URL qui identifie la session, et le serveur peut associer cet identificateur de session aux données qu'il a stockées sur cette session.
Par exemple, avec http://tutorialspoint.com/file.htm;sessionid = 12345, l'identifiant de session est attaché sous la forme sessionid = 12345, accessible sur le serveur Web pour identifier le client.
La réécriture d'URL est un meilleur moyen de maintenir les sessions et cela fonctionne même lorsque les navigateurs ne prennent pas en charge les cookies. L'inconvénient de la réécriture d'URL est que vous devrez générer chaque URL de manière dynamique pour attribuer un identifiant de session, même dans le cas d'une simple page HTML statique.
L'objet HttpSession
Outre les trois méthodes mentionnées ci-dessus, le servlet fournit une interface HttpSession qui permet d'identifier un utilisateur à travers plus d'une demande de page ou de visiter un site Web et de stocker des informations sur cet utilisateur.
Le conteneur de servlet utilise cette interface pour créer une session entre un client HTTP et un serveur HTTP. La session persiste pendant une période de temps spécifiée, sur plus d'une connexion ou demande de page de l'utilisateur.
Vous obtiendrez l'objet HttpSession en appelant la méthode publique getSession() de HttpServletRequest, comme ci-dessous -
HttpSession session = request.getSession();
Vous devez appeler request.getSession () avant d'envoyer tout contenu de document au client. Voici un résumé des méthodes importantes disponibles via l'objet HttpSession -
Sr.No. | Méthode et description |
---|---|
1 | public Object getAttribute(String name) Cette méthode renvoie l'objet lié avec le nom spécifié dans cette session, ou null si aucun objet n'est lié sous le nom. |
2 | public Enumeration getAttributeNames() Cette méthode retourne une énumération d'objets String contenant les noms de tous les objets liés à cette session. |
3 | public long getCreationTime() Cette méthode renvoie l'heure à laquelle cette session a été créée, mesurée en millisecondes depuis le 1er janvier 1970 à minuit (GMT). |
4 | public String getId() Cette méthode renvoie une chaîne contenant l'identifiant unique attribué à cette session. |
5 | public long getLastAccessedTime() Cette méthode renvoie l'heure du dernier accès de la session, au format de millisecondes depuis minuit le 1er janvier 1970 GMT |
6 | public int getMaxInactiveInterval() Cette méthode renvoie l'intervalle de temps maximum (secondes) pendant lequel le conteneur de servlet maintiendra la session ouverte entre les accès client. |
sept | public void invalidate() Cette méthode invalide cette session et dissocie tous les objets qui y sont liés. |
8 | public boolean isNew( Cette méthode retourne true si le client ne connaît pas encore la session ou si le client choisit de ne pas rejoindre la session. |
9 | public void removeAttribute(String name) Cette méthode supprime l'objet lié avec le nom spécifié de cette session. |
dix | public void setAttribute(String name, Object value) Cette méthode lie un objet à cette session, en utilisant le nom spécifié. |
11 | public void setMaxInactiveInterval(int interval) Cette méthode spécifie le temps, en secondes, entre les demandes du client avant que le conteneur de servlet n'invalide cette session. |
Exemple de suivi de session
Cet exemple décrit comment utiliser l'objet HttpSession pour connaître l'heure de création et l'heure du dernier accès d'une session. Nous associerions une nouvelle session à la demande s'il n'en existe pas déjà une.
// Import required java libraries
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
import java.util.*;
// Extend HttpServlet class
public class SessionTrack extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
// Create a session object if it is already not created.
HttpSession session = request.getSession(true);
// Get session creation time.
Date createTime = new Date(session.getCreationTime());
// Get last access time of this web page.
Date lastAccessTime = new Date(session.getLastAccessedTime());
String title = "Welcome Back to my website";
Integer visitCount = new Integer(0);
String visitCountKey = new String("visitCount");
String userIDKey = new String("userID");
String userID = new String("ABCD");
// Check if this is new comer on your web page.
if (session.isNew()) {
title = "Welcome to my website";
session.setAttribute(userIDKey, userID);
} else {
visitCount = (Integer)session.getAttribute(visitCountKey);
visitCount = visitCount + 1;
userID = (String)session.getAttribute(userIDKey);
}
session.setAttribute(visitCountKey, visitCount);
// Set response content type
response.setContentType("text/html");
PrintWriter out = response.getWriter();
String docType =
"<!doctype html public \"-//w3c//dtd html 4.0 " +
"transitional//en\">\n";
out.println(docType +
"<html>\n" +
"<head><title>" + title + "</title></head>\n" +
"<body bgcolor = \"#f0f0f0\">\n" +
"<h1 align = \"center\">" + title + "</h1>\n" +
"<h2 align = \"center\">Session Infomation</h2>\n" +
"<table border = \"1\" align = \"center\">\n" +
"<tr bgcolor = \"#949494\">\n" +
" <th>Session info</th><th>value</th>
</tr>\n" +
"<tr>\n" +
" <td>id</td>\n" +
" <td>" + session.getId() + "</td>
</tr>\n" +
"<tr>\n" +
" <td>Creation Time</td>\n" +
" <td>" + createTime + " </td>
</tr>\n" +
"<tr>\n" +
" <td>Time of Last Access</td>\n" +
" <td>" + lastAccessTime + " </td>
</tr>\n" +
"<tr>\n" +
" <td>User ID</td>\n" +
" <td>" + userID + " </td>
</tr>\n" +
"<tr>\n" +
" <td>Number of visits</td>\n" +
" <td>" + visitCount + "</td>
</tr>\n" +
"</table>\n" +
"</body>
</html>"
);
}
}
Compilez le servlet ci-dessus SessionTracket créez l'entrée appropriée dans le fichier web.xml. Maintenant, exécutez http: // localhost: 8080 / SessionTrack afficherait le résultat suivant lorsque vous exécuteriez pour la première fois -
Welcome to my website
Session Infomation
Session info
value
id
0AE3EC93FF44E3C525B4351B77ABB2D5
Creation Time
Tue Jun 08 17:26:40 GMT+04:00 2010
Time of Last Access
Tue Jun 08 17:26:40 GMT+04:00 2010
User ID
ABCD
Number of visits
0
Maintenant, essayez d'exécuter le même servlet pour la deuxième fois, il afficherait le résultat suivant.
Welcome Back to my website
Session Infomation
info type
value
id
0AE3EC93FF44E3C525B4351B77ABB2D5
Creation Time
Tue Jun 08 17:26:40 GMT+04:00 2010
Time of Last Access
Tue Jun 08 17:26:40 GMT+04:00 2010
User ID
ABCD
Number of visits
1
Suppression des données de session
Lorsque vous avez terminé avec les données de session d'un utilisateur, vous avez plusieurs options -
Remove a particular attribute- Vous pouvez appeler la méthode publique void removeAttribute (String name) pour supprimer la valeur associée à une clé particulière.
Delete the whole session- Vous pouvez appeler la méthode public void invalidate () pour supprimer une session entière.
Setting Session timeout- Vous pouvez appeler la méthode publique void setMaxInactiveInterval (intervalle int) pour définir le délai d'expiration d'une session individuellement.
Log the user out - Les serveurs prenant en charge les servlets 2.4, vous pouvez appeler logout pour déconnecter le client du serveur Web et invalider toutes les sessions appartenant à tous les utilisateurs.
web.xml Configuration - Si vous utilisez Tomcat, en dehors des méthodes mentionnées ci-dessus, vous pouvez configurer le délai d'expiration de session dans le fichier web.xml comme suit.
<session-config>
<session-timeout>15</session-timeout>
</session-config>
Le délai d'expiration est exprimé en minutes et remplace le délai par défaut qui est de 30 minutes dans Tomcat.
La méthode getMaxInactiveInterval () dans un servlet renvoie le délai d'expiration de cette session en secondes. Donc, si votre session est configurée dans web.xml pendant 15 minutes, getMaxInactiveInterval () renvoie 900.
Ce didacticiel suppose que vous comprenez le fonctionnement de l'application JDBC. Avant de commencer avec l'accès à la base de données via un servlet, assurez-vous que l'environnement JDBC est correctement configuré avec une base de données.
Pour plus de détails sur l'accès à la base de données à l'aide de JDBC et la configuration de son environnement, vous pouvez consulter notre didacticiel JDBC .
Pour commencer avec le concept de base, créons une table simple et créons quelques enregistrements dans cette table comme suit -
Créer une table
Pour créer le Employees table dans la base de données TEST, utilisez les étapes suivantes -
Étape 1
Ouvrir un Command Prompt et passez au répertoire d'installation comme suit -
C:\>
C:\>cd Program Files\MySQL\bin
C:\Program Files\MySQL\bin>
Étape 2
Connectez-vous à la base de données comme suit
C:\Program Files\MySQL\bin>mysql -u root -p
Enter password: ********
mysql>
Étape 3
Créer la table Employee dans TEST base de données comme suit -
mysql> use TEST;
mysql> create table Employees (
id int not null,
age int not null,
first varchar (255),
last varchar (255)
);
Query OK, 0 rows affected (0.08 sec)
mysql>
Créer des enregistrements de données
Enfin, vous créez quelques enregistrements dans la table Employee comme suit -
mysql> INSERT INTO Employees VALUES (100, 18, 'Zara', 'Ali');
Query OK, 1 row affected (0.05 sec)
mysql> INSERT INTO Employees VALUES (101, 25, 'Mahnaz', 'Fatma');
Query OK, 1 row affected (0.00 sec)
mysql> INSERT INTO Employees VALUES (102, 30, 'Zaid', 'Khan');
Query OK, 1 row affected (0.00 sec)
mysql> INSERT INTO Employees VALUES (103, 28, 'Sumit', 'Mittal');
Query OK, 1 row affected (0.00 sec)
mysql>
Accéder à une base de données
Voici un exemple qui montre comment accéder à la base de données TEST à l'aide de Servlet.
// Loading required libraries
import java.io.*;
import java.util.*;
import javax.servlet.*;
import javax.servlet.http.*;
import java.sql.*;
public class DatabaseAccess extends HttpServlet{
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
// JDBC driver name and database URL
static final String JDBC_DRIVER = "com.mysql.jdbc.Driver";
static final String DB_URL="jdbc:mysql://localhost/TEST";
// Database credentials
static final String USER = "root";
static final String PASS = "password";
// Set response content type
response.setContentType("text/html");
PrintWriter out = response.getWriter();
String title = "Database Result";
String docType =
"<!doctype html public \"-//w3c//dtd html 4.0 " + "transitional//en\">\n";
out.println(docType +
"<html>\n" +
"<head><title>" + title + "</title></head>\n" +
"<body bgcolor = \"#f0f0f0\">\n" +
"<h1 align = \"center\">" + title + "</h1>\n");
try {
// Register JDBC driver
Class.forName("com.mysql.jdbc.Driver");
// Open a connection
Connection conn = DriverManager.getConnection(DB_URL, USER, PASS);
// Execute SQL query
Statement stmt = conn.createStatement();
String sql;
sql = "SELECT id, first, last, age FROM Employees";
ResultSet rs = stmt.executeQuery(sql);
// Extract data from result set
while(rs.next()){
//Retrieve by column name
int id = rs.getInt("id");
int age = rs.getInt("age");
String first = rs.getString("first");
String last = rs.getString("last");
//Display values
out.println("ID: " + id + "<br>");
out.println(", Age: " + age + "<br>");
out.println(", First: " + first + "<br>");
out.println(", Last: " + last + "<br>");
}
out.println("</body></html>");
// Clean-up environment
rs.close();
stmt.close();
conn.close();
} catch(SQLException se) {
//Handle errors for JDBC
se.printStackTrace();
} catch(Exception e) {
//Handle errors for Class.forName
e.printStackTrace();
} finally {
//finally block used to close resources
try {
if(stmt!=null)
stmt.close();
} catch(SQLException se2) {
} // nothing we can do
try {
if(conn!=null)
conn.close();
} catch(SQLException se) {
se.printStackTrace();
} //end finally try
} //end try
}
}
Maintenant, compilons le servlet ci-dessus et créons les entrées suivantes dans web.xml
....
<servlet>
<servlet-name>DatabaseAccess</servlet-name>
<servlet-class>DatabaseAccess</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>DatabaseAccess</servlet-name>
<url-pattern>/DatabaseAccess</url-pattern>
</servlet-mapping>
....
Appelez maintenant ce servlet en utilisant l'URL http: // localhost: 8080 / DatabaseAccess qui afficherait la réponse suivante -
Database Result
ID: 100, Age: 18, First: Zara, Last: Ali
ID: 101, Age: 25, First: Mahnaz, Last: Fatma
ID: 102, Age: 30, First: Zaid, Last: Khan
ID: 103, Age: 28, First: Sumit, Last: Mittal
Un servlet peut être utilisé avec une balise de formulaire HTML pour permettre aux utilisateurs de télécharger des fichiers sur le serveur. Un fichier téléchargé peut être un fichier texte ou un fichier image ou tout autre document.
Création d'un formulaire de téléchargement de fichier
Le code HTM suivant ci-dessous crée un formulaire de téléchargement. Voici les points importants à noter -
La forme method l'attribut doit être défini sur POST la méthode et la méthode GET ne peuvent pas être utilisées
La forme enctype l'attribut doit être défini sur multipart/form-data.
La forme actionL'attribut doit être défini sur un fichier de servlet qui gérerait le téléchargement de fichiers sur le serveur principal. L'exemple suivant utiliseUploadServlet servlet pour télécharger le fichier.
Pour télécharger un seul fichier, vous devez utiliser une seule balise <input ... /> avec l'attribut type = "file". Pour autoriser le téléchargement de plusieurs fichiers, incluez plusieurs balises d'entrée avec des valeurs différentes pour l'attribut de nom. Le navigateur associe un bouton Parcourir à chacun d'eux.
<html>
<head>
<title>File Uploading Form</title>
</head>
<body>
<h3>File Upload:</h3>
Select a file to upload: <br />
<form action = "UploadServlet" method = "post" enctype = "multipart/form-data">
<input type = "file" name = "file" size = "50" />
<br />
<input type = "submit" value = "Upload File" />
</form>
</body>
</html>
Cela affichera le résultat suivant qui permettrait de sélectionner un fichier à partir du PC local et lorsque l'utilisateur cliquera sur "Télécharger le fichier", le formulaire sera soumis avec le fichier sélectionné -
File Upload:
Select a file to upload:
NOTE: This is just dummy form and would not work.
Écriture d'un servlet backend
Voici le servlet UploadServletqui prendrait soin d'accepter le fichier téléchargé et de le stocker dans le répertoire <Tomcat-installation-directory> / webapps / data. Ce nom de répertoire peut également être ajouté à l'aide d'une configuration externe telle qu'uncontext-param élément dans web.xml comme suit -
<web-app>
....
<context-param>
<description>Location to store uploaded file</description>
<param-name>file-upload</param-name>
<param-value>
c:\apache-tomcat-5.5.29\webapps\data\
</param-value>
</context-param>
....
</web-app>
Voici le code source de UploadServlet qui peut gérer plusieurs fichiers à la fois. Avant de continuer, assurez-vous que les éléments suivants -
L'exemple suivant dépend de FileUpload, assurez-vous donc de disposer de la dernière version de commons-fileupload.x.x.jarfichier dans votre chemin de classe. Vous pouvez le télécharger surhttps://commons.apache.org/fileupload/.
FileUpload dépend de Commons IO, alors assurez-vous de disposer de la dernière version de commons-io-x.x.jarfichier dans votre chemin de classe. Vous pouvez le télécharger surhttps://commons.apache.org/io/.
Lors du test de l'exemple suivant, vous devez télécharger un fichier dont la taille est inférieure à maxFileSize, sinon le fichier ne sera pas téléchargé.
Assurez-vous d'avoir créé les répertoires c: \ temp et c: \ apache-tomcat8.0.28 \ webapps \ data bien à l'avance.
// Import required java libraries
import java.io.*;
import java.util.*;
import javax.servlet.ServletConfig;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.apache.commons.fileupload.FileItem;
import org.apache.commons.fileupload.FileUploadException;
import org.apache.commons.fileupload.disk.DiskFileItemFactory;
import org.apache.commons.fileupload.servlet.ServletFileUpload;
import org.apache.commons.io.output.*;
public class UploadServlet extends HttpServlet {
private boolean isMultipart;
private String filePath;
private int maxFileSize = 50 * 1024;
private int maxMemSize = 4 * 1024;
private File file ;
public void init( ){
// Get the file location where it would be stored.
filePath = getServletContext().getInitParameter("file-upload");
}
public void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, java.io.IOException {
// Check that we have a file upload request
isMultipart = ServletFileUpload.isMultipartContent(request);
response.setContentType("text/html");
java.io.PrintWriter out = response.getWriter( );
if( !isMultipart ) {
out.println("<html>");
out.println("<head>");
out.println("<title>Servlet upload</title>");
out.println("</head>");
out.println("<body>");
out.println("<p>No file uploaded</p>");
out.println("</body>");
out.println("</html>");
return;
}
DiskFileItemFactory factory = new DiskFileItemFactory();
// maximum size that will be stored in memory
factory.setSizeThreshold(maxMemSize);
// Location to save data that is larger than maxMemSize.
factory.setRepository(new File("c:\\temp"));
// Create a new file upload handler
ServletFileUpload upload = new ServletFileUpload(factory);
// maximum file size to be uploaded.
upload.setSizeMax( maxFileSize );
try {
// Parse the request to get file items.
List fileItems = upload.parseRequest(request);
// Process the uploaded file items
Iterator i = fileItems.iterator();
out.println("<html>");
out.println("<head>");
out.println("<title>Servlet upload</title>");
out.println("</head>");
out.println("<body>");
while ( i.hasNext () ) {
FileItem fi = (FileItem)i.next();
if ( !fi.isFormField () ) {
// Get the uploaded file parameters
String fieldName = fi.getFieldName();
String fileName = fi.getName();
String contentType = fi.getContentType();
boolean isInMemory = fi.isInMemory();
long sizeInBytes = fi.getSize();
// Write the file
if( fileName.lastIndexOf("\\") >= 0 ) {
file = new File( filePath + fileName.substring( fileName.lastIndexOf("\\"))) ;
} else {
file = new File( filePath + fileName.substring(fileName.lastIndexOf("\\")+1)) ;
}
fi.write( file ) ;
out.println("Uploaded Filename: " + fileName + "<br>");
}
}
out.println("</body>");
out.println("</html>");
} catch(Exception ex) {
System.out.println(ex);
}
}
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, java.io.IOException {
throw new ServletException("GET method used with " +
getClass( ).getName( )+": POST method required.");
}
}
}
Compiler et exécuter un servlet
Compilez le servlet UploadServlet ci-dessus et créez l'entrée requise dans le fichier web.xml comme suit.
<servlet>
<servlet-name>UploadServlet</servlet-name>
<servlet-class>UploadServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>UploadServlet</servlet-name>
<url-pattern>/UploadServlet</url-pattern>
</servlet-mapping>
Essayez maintenant de télécharger des fichiers à l'aide du formulaire HTML que vous avez créé ci-dessus. Lorsque vous essayez http: // localhost: 8080 / UploadFile.htm, il affichera le résultat suivant qui vous aidera à télécharger n'importe quel fichier depuis votre machine locale.
File Upload:
Select a file to upload:
Si votre script de servlet fonctionne correctement, votre fichier doit être téléchargé dans le répertoire c: \ apache-tomcat8.0.28 \ webapps \ data \.
L'un des avantages les plus importants de l'utilisation de Servlet est que vous pouvez utiliser la plupart des méthodes disponibles dans le noyau Java. Ce tutoriel vous guidera à travers Java fourniDate classe qui est disponible dans java.util package, cette classe encapsule la date et l'heure actuelles.
La classe Date prend en charge deux constructeurs. Le premier constructeur initialise l'objet avec la date et l'heure actuelles.
Date( )
Le constructeur suivant accepte un argument égal au nombre de millisecondes écoulées depuis le 1er janvier 1970 à minuit
Date(long millisec)
Une fois que vous avez un objet Date disponible, vous pouvez appeler l'une des méthodes de support suivantes pour jouer avec les dates -
Sr.No. | Méthodes et description |
---|---|
1 | boolean after(Date date) Renvoie true si l'objet Date appelant contient une date postérieure à celle spécifiée par date, sinon, elle renvoie false. |
2 | boolean before(Date date) Renvoie true si l'objet Date appelant contient une date antérieure à celle spécifiée par date, sinon, elle renvoie false. |
3 | Object clone( ) Duplique l'objet Date appelant. |
4 | int compareTo(Date date) Compare la valeur de l'objet appelant avec celle de date. Renvoie 0 si les valeurs sont égales. Renvoie une valeur négative si l'objet appelant est antérieur à la date. Renvoie une valeur positive si l'objet appelant est postérieur à la date. |
5 | int compareTo(Object obj) Fonctionne de la même manière que compareTo (Date) si obj est de classe Date. Sinon, il lève une ClassCastException. |
6 | boolean equals(Object date) Renvoie true si l'objet Date appelant contient la même heure et la même date que celles spécifiées par date, sinon, il renvoie false. |
sept | long getTime( ) Renvoie le nombre de millisecondes qui se sont écoulées depuis le 1er janvier 1970. |
8 | int hashCode( ) Renvoie un code de hachage pour l'objet appelant. |
9 | void setTime(long time) Définit l'heure et la date spécifiées par time, qui représente un temps écoulé en millisecondes à partir du 1er janvier 1970 à minuit. |
dix | String toString( ) Convertit l'objet Date appelant en une chaîne et renvoie le résultat. |
Obtenir la date et l'heure actuelles
Il est très facile d'obtenir la date et l'heure actuelles dans Java Servlet. Vous pouvez utiliser un objet Date simple avec la méthode toString () pour imprimer la date et l'heure actuelles comme suit -
// Import required java libraries
import java.io.*;
import java.util.Date;
import javax.servlet.*;
import javax.servlet.http.*;
// Extend HttpServlet class
public class CurrentDate extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
// Set response content type
response.setContentType("text/html");
PrintWriter out = response.getWriter();
String title = "Display Current Date & Time";
Date date = new Date();
String docType = "<!doctype html public \"-//w3c//dtd html 4.0 " + "transitional//en\">\n";
out.println(docType +
"<html>\n" +
"<head><title>" + title + "</title></head>\n" +
"<body bgcolor = \"#f0f0f0\">\n" +
"<h1 align = \"center\">" + title + "</h1>\n" +
"<h2 align = \"center\">" + date.toString() + "</h2>\n" +
"</body>
</html>"
);
}
}
Maintenant, compilons le servlet ci-dessus et créons les entrées appropriées dans web.xml, puis appelons ce servlet en utilisant l'URL http: // localhost: 8080 / CurrentDate. Cela produirait le résultat suivant -
Display Current Date & Time
Mon Jun 21 21:46:49 GMT+04:00 2010
Essayez d'actualiser l'URL http: // localhost: 8080 / CurrentDate et vous trouverez une différence en secondes à chaque actualisation.
Comparaison des dates
Comme je l'ai mentionné ci-dessus, vous pouvez utiliser toutes les méthodes Java disponibles dans votre servlet. Au cas où vous auriez besoin de comparer deux dates, voici les méthodes -
Vous pouvez utiliser getTime () pour obtenir le nombre de millisecondes qui se sont écoulées depuis minuit, le 1er janvier 1970, pour les deux objets, puis comparer ces deux valeurs.
Vous pouvez utiliser les méthodes before (), after () et equals (). Parce que le 12 du mois vient avant le 18, par exemple, new Date (99, 2, 12) .before (new Date (99, 2, 18)) renvoie true.
Vous pouvez utiliser la méthode compareTo (), qui est définie par l'interface Comparable et implémentée par Date.
Formatage de la date à l'aide de SimpleDateFormat
SimpleDateFormat est une classe concrète pour la mise en forme et l'analyse des dates d'une manière sensible à la langue. SimpleDateFormat vous permet de commencer par choisir les modèles définis par l'utilisateur pour le formatage de la date et de l'heure.
Modifions l'exemple ci-dessus comme suit -
// Import required java libraries
import java.io.*;
import java.text.*;
import java.util.Date;
import javax.servlet.*;
import javax.servlet.http.*;
// Extend HttpServlet class
public class CurrentDate extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
// Set response content type
response.setContentType("text/html");
PrintWriter out = response.getWriter();
String title = "Display Current Date & Time";
Date dNow = new Date( );
SimpleDateFormat ft = new SimpleDateFormat ("E yyyy.MM.dd 'at' hh:mm:ss a zzz");
String docType = "<!doctype html public \"-//w3c//dtd html 4.0 " + "transitional//en\">\n";
out.println(docType +
"<html>\n" +
"<head><title>" + title + "</title></head>\n" +
"<body bgcolor = \"#f0f0f0\">\n" +
"<h1 align = \"center\">" + title + "</h1>\n" +
"<h2 align = \"center\">" + ft.format(dNow) + "</h2>\n" +
"</body>
</html>"
);
}
}
Compilez à nouveau le servlet ci-dessus, puis appelez ce servlet en utilisant l'URL http: // localhost: 8080 / CurrentDate. Cela produirait le résultat suivant -
Display Current Date & Time
Mon 2010.06.21 at 10:06:44 PM GMT+04:00
Codes de format de format de date simples
Pour spécifier le format d'heure, utilisez une chaîne de modèle d'heure. Dans ce modèle, toutes les lettres ASCII sont réservées en tant que lettres de modèle, qui sont définies comme suit -
Personnage | La description | Exemple |
---|---|---|
g | Désignation de l'époque | UN D |
y | L'année en quatre chiffres | 2001 |
M | Mois dans l'année | Juillet ou 07 |
ré | Jour dans le mois | dix |
h | Heure en AM / PM (1 ~ 12) | 12 |
H | Heure dans la journée (0 ~ 23) | 22 |
m | Minute en heure | 30 |
s | Seconde en minute | 55 |
S | Milliseconde | 234 |
E | Jour en semaine | Mardi |
ré | Jour dans l'année | 360 |
F | Jour de la semaine dans le mois | 2 (deuxième mercredi de juillet) |
w | Semaine dans l'année | 40 |
W | Semaine en mois | 1 |
une | Marqueur AM / PM | PM |
k | Heure dans la journée (1 ~ 24) | 24 |
K | Heure en AM / PM (0 ~ 11) | dix |
z | Fuseau horaire | Heure normale de l'Est |
' | Échapper pour le texte | Délimiteur |
" | Simple citation | » |
Pour une liste complète des méthodes constantes disponibles pour manipuler la date, vous pouvez vous référer à la documentation Java standard.
La redirection de page est une technique dans laquelle le client est envoyé vers un nouvel emplacement autre que celui demandé. La redirection de page est généralement utilisée lorsqu'un document est déplacé vers un nouvel emplacement ou peut être due à l'équilibrage de charge.
Le moyen le plus simple de rediriger une requête vers une autre page consiste à utiliser la méthode sendRedirect()de l'objet de réponse. Voici la signature de cette méthode -
public void HttpServletResponse.sendRedirect(String location)
throws IOException
Cette méthode renvoie la réponse au navigateur avec le code d'état et le nouvel emplacement de la page. Vous pouvez également utiliser les méthodes setStatus () et setHeader () ensemble pour obtenir le même résultat -
....
String site = "http://www.newpage.com" ;
response.setStatus(response.SC_MOVED_TEMPORARILY);
response.setHeader("Location", site);
....
Exemple
Cet exemple montre comment un servlet effectue la redirection de page vers un autre emplacement -
import java.io.*;
import java.sql.Date;
import java.util.*;
import javax.servlet.*;
import javax.servlet.http.*;
public class PageRedirect extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
// Set response content type
response.setContentType("text/html");
// New location to be redirected
String site = new String("http://www.photofuntoos.com");
response.setStatus(response.SC_MOVED_TEMPORARILY);
response.setHeader("Location", site);
}
}
Maintenant, compilons le servlet ci-dessus et créons les entrées suivantes dans web.xml
....
<servlet>
<servlet-name>PageRedirect</servlet-name>
<servlet-class>PageRedirect</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>PageRedirect</servlet-name>
<url-pattern>/PageRedirect</url-pattern>
</servlet-mapping>
....
Appelez maintenant ce servlet en utilisant l'URL http: // localhost: 8080 / PageRedirect. Cela vous redirige vers l'URL http://www.photofuntoos.com.
Compteur d'accès pour une page Web
Plusieurs fois, vous seriez intéressé à connaître le nombre total de visites sur une page particulière de votre site Web. Il est très simple de compter ces hits à l'aide d'un servlet car le cycle de vie d'un servlet est contrôlé par le conteneur dans lequel il s'exécute.
Voici les étapes à suivre pour implémenter un compteur d'accès de page simple basé sur le cycle de vie du servlet -
Initialisez une variable globale dans la méthode init ().
Augmentez la variable globale chaque fois que la méthode doGet () ou doPost () est appelée.
Si nécessaire, vous pouvez utiliser une table de base de données pour stocker la valeur de la variable globale dans la méthode destroy (). Cette valeur peut être lue dans la méthode init () lorsque la servlet sera initialisée la prochaine fois. Cette étape est facultative.
Si vous souhaitez ne compter que les accès de page uniques dans une session, vous pouvez utiliser la méthode isNew () pour vérifier si la même page a déjà été atteinte dans cette session. Cette étape est facultative.
Vous pouvez afficher la valeur du compteur global pour afficher le nombre total de visites sur votre site Web. Cette étape est également facultative.
Ici, je suppose que le conteneur Web ne sera pas redémarré. S'il est redémarré ou si le servlet est détruit, le compteur d'accès sera réinitialisé.
Exemple
Cet exemple montre comment implémenter un simple compteur d'accès à la page -
import java.io.*;
import java.sql.Date;
import java.util.*;
import javax.servlet.*;
import javax.servlet.http.*;
public class PageHitCounter extends HttpServlet {
private int hitCount;
public void init() {
// Reset hit counter.
hitCount = 0;
}
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
// Set response content type
response.setContentType("text/html");
// This method executes whenever the servlet is hit
// increment hitCount
hitCount++;
PrintWriter out = response.getWriter();
String title = "Total Number of Hits";
String docType = "<!doctype html public \"-//w3c//dtd html 4.0 " + "transitional//en\">\n";
out.println(docType +
"<html>\n" +
"<head><title>" + title + "</title></head>\n" +
"<body bgcolor = \"#f0f0f0\">\n" +
"<h1 align = \"center\">" + title + "</h1>\n" +
"<h2 align = \"center\">" + hitCount + "</h2>\n" +
"</body>
</html>"
);
}
public void destroy() {
// This is optional step but if you like you
// can write hitCount value in your database.
}
}
Maintenant, compilons le servlet ci-dessus et créons les entrées suivantes dans web.xml
<servlet>
<servlet-name>PageHitCounter</servlet-name>
<servlet-class>PageHitCounter</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>PageHitCounter</servlet-name>
<url-pattern>/PageHitCounter</url-pattern>
</servlet-mapping>
....
Appelez maintenant ce servlet en utilisant l'URL http: // localhost: 8080 / PageHitCounter. Cela augmenterait le compteur de un à chaque fois que cette page est actualisée et afficherait le résultat suivant -
Total Number of Hits
6
Hit Counter for a Website:
Plusieurs fois, vous seriez intéressé de connaître le nombre total de visites sur l'ensemble de votre site Web. C'est également très simple dans Servlet et nous pouvons y parvenir en utilisant des filtres.
Voici les étapes à suivre pour mettre en œuvre un simple compteur de visites de site Web basé sur le cycle de vie du filtre -
Initialise une variable globale dans la méthode init () d'un filtre.
Augmentez la variable globale chaque fois que la méthode doFilter est appelée.
Si nécessaire, vous pouvez utiliser une table de base de données pour stocker la valeur de la variable globale dans la méthode destroy () du filtre. Cette valeur peut être lue dans la méthode init () lorsque le filtre sera initialisé la prochaine fois. Cette étape est facultative.
Ici, je suppose que le conteneur Web ne sera pas redémarré. S'il est redémarré ou si le servlet est détruit, le compteur d'accès sera réinitialisé.
Exemple
Cet exemple montre comment implémenter un simple compteur d'accès à un site Web -
// Import required java libraries
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
import java.util.*;
public class SiteHitCounter implements Filter {
private int hitCount;
public void init(FilterConfig config) throws ServletException {
// Reset hit counter.
hitCount = 0;
}
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
throws java.io.IOException, ServletException {
// increase counter by one
hitCount++;
// Print the counter.
System.out.println("Site visits count :"+ hitCount );
// Pass request back down the filter chain
chain.doFilter(request,response);
}
public void destroy() {
// This is optional step but if you like you
// can write hitCount value in your database.
}
}
Maintenant, compilons le servlet ci-dessus et créons les entrées suivantes dans web.xml
....
<filter>
<filter-name>SiteHitCounter</filter-name>
<filter-class>SiteHitCounter</filter-class>
</filter>
<filter-mapping>
<filter-name>SiteHitCounter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
....
Maintenant, appelez n'importe quelle URL comme URL http: // localhost: 8080 /. Cela augmenterait le compteur de un à chaque fois qu'une page obtient un hit et afficherait le message suivant dans le journal -
Site visits count : 1
Site visits count : 2
Site visits count : 3
Site visits count : 4
Site visits count : 5
..................
Considérez une page Web qui affiche le score du match en direct ou l'état de la bourse ou la ration de change. Pour tous ces types de pages, vous devez actualiser régulièrement votre page Web en utilisant le bouton d'actualisation ou de rechargement de votre navigateur.
Java Servlet facilite ce travail en vous fournissant un mécanisme dans lequel vous pouvez créer une page Web de manière à ce qu'elle s'actualise automatiquement après un intervalle donné.
Le moyen le plus simple d'actualiser une page Web consiste à utiliser la méthode setIntHeader()de l'objet de réponse. Voici la signature de cette méthode -
public void setIntHeader(String header, int headerValue)
Cette méthode renvoie l'en-tête "Refresh" au navigateur avec une valeur entière qui indique l'intervalle de temps en secondes.
Exemple d'actualisation automatique de la page
Cet exemple montre comment un servlet effectue l'actualisation automatique de la page en utilisant setIntHeader() méthode à définir Refresh entête.
// Import required java libraries
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
import java.util.*;
// Extend HttpServlet class
public class Refresh extends HttpServlet {
// Method to handle GET method request.
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
// Set refresh, autoload time as 5 seconds
response.setIntHeader("Refresh", 5);
// Set response content type
response.setContentType("text/html");
// Get current time
Calendar calendar = new GregorianCalendar();
String am_pm;
int hour = calendar.get(Calendar.HOUR);
int minute = calendar.get(Calendar.MINUTE);
int second = calendar.get(Calendar.SECOND);
if(calendar.get(Calendar.AM_PM) == 0)
am_pm = "AM";
else
am_pm = "PM";
String CT = hour+":"+ minute +":"+ second +" "+ am_pm;
PrintWriter out = response.getWriter();
String title = "Auto Page Refresh using Servlet";
String docType =
"<!doctype html public \"-//w3c//dtd html 4.0 " + "transitional//en\">\n";
out.println(docType +
"<html>\n" +
"<head><title>" + title + "</title></head>\n"+
"<body bgcolor = \"#f0f0f0\">\n" +
"<h1 align = \"center\">" + title + "</h1>\n" +
"<p>Current Time is: " + CT + "</p>\n"
);
}
// Method to handle POST method request.
public void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
doGet(request, response);
}
}
Maintenant, compilons le servlet ci-dessus et créons les entrées suivantes dans web.xml
....
<servlet>
<servlet-name>Refresh</servlet-name>
<servlet-class>Refresh</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>Refresh</servlet-name>
<url-pattern>/Refresh</url-pattern>
</servlet-mapping>
....
Appelez maintenant ce servlet en utilisant l'URL http: // localhost: 8080 / Refresh qui afficherait l'heure actuelle du système toutes les 5 secondes comme suit. Exécutez simplement le servlet et attendez de voir le résultat -
Auto Page Refresh using Servlet
Current Time is: 9:44:50 PM
Envoyer un e-mail en utilisant votre servlet est assez simple mais pour commencer, vous devriez avoir JavaMail API et Java Activation Framework (JAF) installé sur votre machine.
Vous pouvez télécharger la dernière version de JavaMail (version 1.2) à partir du site Web standard de Java.
Vous pouvez télécharger la dernière version de JAF (version 1.1.1) à partir du site Web standard de Java.
Téléchargez et décompressez ces fichiers, dans les répertoires de niveau supérieur nouvellement créés, vous trouverez un certain nombre de fichiers jar pour les deux applications. Vous devez ajoutermail.jar et activation.jar fichiers dans votre CLASSPATH.
Envoyer un e-mail simple
Voici un exemple pour envoyer un simple e-mail depuis votre machine. Ici, on suppose que votrelocalhostest connecté à Internet et suffisamment capable d'envoyer un e-mail. En même temps, assurez-vous que tous les fichiers jar du package Java Email API et du package JAF sont disponibles dans CLASSPATH.
// File Name SendEmail.java
import java.io.*;
import java.util.*;
import javax.servlet.*;
import javax.servlet.http.*;
import javax.mail.*;
import javax.mail.internet.*;
import javax.activation.*;
public class SendEmail extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
// Recipient's email ID needs to be mentioned.
String to = "[email protected]";
// Sender's email ID needs to be mentioned
String from = "[email protected]";
// Assuming you are sending email from localhost
String host = "localhost";
// Get system properties
Properties properties = System.getProperties();
// Setup mail server
properties.setProperty("mail.smtp.host", host);
// Get the default Session object.
Session session = Session.getDefaultInstance(properties);
// Set response content type
response.setContentType("text/html");
PrintWriter out = response.getWriter();
try {
// Create a default MimeMessage object.
MimeMessage message = new MimeMessage(session);
// Set From: header field of the header.
message.setFrom(new InternetAddress(from));
// Set To: header field of the header.
message.addRecipient(Message.RecipientType.TO, new InternetAddress(to));
// Set Subject: header field
message.setSubject("This is the Subject Line!");
// Now set the actual message
message.setText("This is actual message");
// Send message
Transport.send(message);
String title = "Send Email";
String res = "Sent message successfully....";
String docType =
"<!doctype html public \"-//w3c//dtd html 4.0 " + "transitional//en\">\n";
out.println(docType +
"<html>\n" +
"<head><title>" + title + "</title></head>\n" +
"<body bgcolor = \"#f0f0f0\">\n" +
"<h1 align = \"center\">" + title + "</h1>\n" +
"<p align = \"center\">" + res + "</p>\n" +
"</body>
</html>"
);
} catch (MessagingException mex) {
mex.printStackTrace();
}
}
}
Maintenant, compilons le servlet ci-dessus et créons les entrées suivantes dans web.xml
....
<servlet>
<servlet-name>SendEmail</servlet-name>
<servlet-class>SendEmail</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>SendEmail</servlet-name>
<url-pattern>/SendEmail</url-pattern>
</servlet-mapping>
....
Appelez maintenant ce servlet en utilisant l'URL http: // localhost: 8080 / SendEmail qui enverrait un e-mail à l'ID de messagerie donné [email protected] et afficherait la réponse suivante -
Send Email
Sent message successfully....
Si vous souhaitez envoyer un e-mail à plusieurs destinataires, les méthodes suivantes seront utilisées pour spécifier plusieurs ID d'e-mail -
void addRecipients(Message.RecipientType type, Address[] addresses)
throws MessagingException
Voici la description des paramètres -
type- Ce serait réglé sur TO, CC ou BCC. Ici, CC représente Carbon Copy et BCC représente Black Carbon Copy. Exemple de Message.RecipientType.TO
addresses- Ceci est le tableau des identifiants de messagerie. Vous devrez utiliser la méthode InternetAddress () lors de la spécification des identifiants de messagerie.
Envoyer un e-mail HTML
Voici un exemple pour envoyer un e-mail HTML depuis votre machine. Ici, on suppose que votrelocalhostest connecté à Internet et suffisamment capable d'envoyer un e-mail. En même temps, assurez-vous que tous les fichiers jar du package Java Email API et du package JAF sont disponibles dans CLASSPATH.
Cet exemple est très similaire au précédent, sauf que nous utilisons ici la méthode setContent () pour définir le contenu dont le deuxième argument est "text / html" pour spécifier que le contenu HTML est inclus dans le message.
En utilisant cet exemple, vous pouvez envoyer un contenu HTML aussi volumineux que vous le souhaitez.
// File Name SendEmail.java
import java.io.*;
import java.util.*;
import javax.servlet.*;
import javax.servlet.http.*;
import javax.mail.*;
import javax.mail.internet.*;
import javax.activation.*;
public class SendEmail extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
// Recipient's email ID needs to be mentioned.
String to = "[email protected]";
// Sender's email ID needs to be mentioned
String from = "[email protected]";
// Assuming you are sending email from localhost
String host = "localhost";
// Get system properties
Properties properties = System.getProperties();
// Setup mail server
properties.setProperty("mail.smtp.host", host);
// Get the default Session object.
Session session = Session.getDefaultInstance(properties);
// Set response content type
response.setContentType("text/html");
PrintWriter out = response.getWriter();
try {
// Create a default MimeMessage object.
MimeMessage message = new MimeMessage(session);
// Set From: header field of the header.
message.setFrom(new InternetAddress(from));
// Set To: header field of the header.
message.addRecipient(Message.RecipientType.TO, new InternetAddress(to));
// Set Subject: header field
message.setSubject("This is the Subject Line!");
// Send the actual HTML message, as big as you like
message.setContent("<h1>This is actual message</h1>", "text/html" );
// Send message
Transport.send(message);
String title = "Send Email";
String res = "Sent message successfully....";
String docType =
"<!doctype html public \"-//w3c//dtd html 4.0 " + "transitional//en\">\n";
out.println(docType +
"<html>\n" +
"<head><title>" + title + "</title></head>\n" +
"<body bgcolor = \"#f0f0f0\">\n" +
"<h1 align = \"center\">" + title + "</h1>\n" +
"<p align = \"center\">" + res + "</p>\n" +
"</body>
</html>"
);
} catch (MessagingException mex) {
mex.printStackTrace();
}
}
}
Compilez et exécutez le servlet ci-dessus pour envoyer un message HTML sur un ID de messagerie donné.
Envoyer la pièce jointe par e-mail
Voici un exemple pour envoyer un e-mail avec pièce jointe depuis votre machine. Ici, on suppose que votrelocalhost est connecté à Internet et suffisamment capable d'envoyer un e-mail.
// File Name SendEmail.java
import java.io.*;
import java.util.*;
import javax.servlet.*;
import javax.servlet.http.*;
import javax.mail.*;
import javax.mail.internet.*;
import javax.activation.*;
public class SendEmail extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
// Recipient's email ID needs to be mentioned.
String to = "[email protected]";
// Sender's email ID needs to be mentioned
String from = "[email protected]";
// Assuming you are sending email from localhost
String host = "localhost";
// Get system properties
Properties properties = System.getProperties();
// Setup mail server
properties.setProperty("mail.smtp.host", host);
// Get the default Session object.
Session session = Session.getDefaultInstance(properties);
// Set response content type
response.setContentType("text/html");
PrintWriter out = response.getWriter();
try {
// Create a default MimeMessage object.
MimeMessage message = new MimeMessage(session);
// Set From: header field of the header.
message.setFrom(new InternetAddress(from));
// Set To: header field of the header.
message.addRecipient(Message.RecipientType.TO, new InternetAddress(to));
// Set Subject: header field
message.setSubject("This is the Subject Line!");
// Create the message part
BodyPart messageBodyPart = new MimeBodyPart();
// Fill the message
messageBodyPart.setText("This is message body");
// Create a multipar message
Multipart multipart = new MimeMultipart();
// Set text message part
multipart.addBodyPart(messageBodyPart);
// Part two is attachment
messageBodyPart = new MimeBodyPart();
String filename = "file.txt";
DataSource source = new FileDataSource(filename);
messageBodyPart.setDataHandler(new DataHandler(source));
messageBodyPart.setFileName(filename);
multipart.addBodyPart(messageBodyPart);
// Send the complete message parts
message.setContent(multipart );
// Send message
Transport.send(message);
String title = "Send Email";
String res = "Sent message successfully....";
String docType =
"<!doctype html public \"-//w3c//dtd html 4.0 " + "transitional//en\">\n";
out.println(docType +
"<html>\n" +
"<head><title>" + title + "</title></head>\n" +
"<body bgcolor = \"#f0f0f0\">\n" +
"<h1 align = \"center\">" + title + "</h1>\n" +
"<p align = \"center\">" + res + "</p>\n" +
"</body>
</html>"
);
} catch (MessagingException mex) {
mex.printStackTrace();
}
}
}
Compilez et exécutez le servlet ci-dessus pour envoyer un fichier en pièce jointe avec un message sur un identifiant de messagerie donné.
Partie d'authentification utilisateur
S'il est nécessaire de fournir un ID utilisateur et un mot de passe au serveur de messagerie à des fins d'authentification, vous pouvez définir ces propriétés comme suit:
props.setProperty("mail.user", "myuser");
props.setProperty("mail.password", "mypwd");
Le reste du mécanisme d'envoi de courrier électronique resterait tel qu'expliqué ci-dessus.
La structure de l'application Web impliquant le sous-répertoire WEB-INF est standard pour toutes les applications Web Java et spécifiée par la spécification de l'API du servlet. Étant donné un nom de répertoire de premier niveau de myapp. Voici à quoi ressemble cette structure de répertoires -
/myapp
/images
/WEB-INF
/classes
/lib
Le sous-répertoire WEB-INF contient le descripteur de déploiement de l'application, nommé web.xml. Tous les fichiers HTML doivent être conservés dans le répertoire de niveau supérieur qui est myapp . Pour l'utilisateur administrateur, vous trouverez le répertoire ROOT comme répertoire parent.
Création de servlets dans des packages
Le répertoire WEB-INF / classes contient toutes les classes de servlet et autres fichiers de classe, dans une structure qui correspond à leur nom de package. Par exemple, si vous avez un nom de classe qualifié complet decom.myorg.MyServlet, alors cette classe de servlet doit être située dans le répertoire suivant -
/myapp/WEB-INF/classes/com/myorg/MyServlet.class
Voici l'exemple pour créer une classe MyServlet avec un nom de package com.myorg
// Name your package
package com.myorg;
// Import required java libraries
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
public class MyServlet extends HttpServlet {
private String message;
public void init() throws ServletException {
// Do required initialization
message = "Hello World";
}
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
// Set response content type
response.setContentType("text/html");
// Actual logic goes here.
PrintWriter out = response.getWriter();
out.println("<h1>" + message + "</h1>");
}
public void destroy() {
// do nothing.
}
}
Compilation de servlets dans des packages
Il n'y a rien de bien différent pour compiler une classe disponible dans package. Le moyen le plus simple est de conserver votre fichier java dans un chemin complet, comme mentionné ci-dessus, la classe serait conservée dans com.myorg. Vous devrez également ajouter ce répertoire dans CLASSPATH.
En supposant que votre environnement est correctement configuré, entrez <Tomcat-installationdirectory>/ webapps / ROOT / WEB-INF / classes et compilez MyServlet.java comme suit
$ javac MyServlet.java
Si le servlet dépend d'autres bibliothèques, vous devez également inclure ces fichiers JAR sur votre CLASSPATH. J'ai inclus uniquement le fichier JAR servlet-api.jar car je n'utilise aucune autre bibliothèque dans le programme Hello World.
Cette ligne de commande utilise le compilateur javac intégré fourni avec le kit de développement logiciel Java Sun Microsystems (JDK). Pour que cette commande fonctionne correctement, vous devez inclure l'emplacement du SDK Java que vous utilisez dans la variable d'environnement PATH.
Si tout se passe bien, la compilation ci-dessus produirait MyServlet.classfichier dans le même répertoire. La section suivante explique comment un servlet compilé serait déployé en production.
Déploiement de servlet packagé
Par défaut, une application de servlet se trouve dans le chemin <Tomcat-installationdirectory> / webapps / ROOT et le fichier de classe résiderait dans <Tomcat-installationdirectory> / webapps / ROOT / WEB-INF / classes.
Si vous avez un nom de classe complet de com.myorg.MyServlet, alors cette classe de servlet doit être située dans WEB-INF / classes / com / myorg / MyServlet.class et vous devrez créer les entrées suivantes dans web.xml fichier situé dans <Tomcat-installationdirectory> / webapps / ROOT / WEB-INF /
<servlet>
<servlet-name>MyServlet</servlet-name>
<servlet-class>com.myorg.MyServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>MyServlet</servlet-name>
<url-pattern>/MyServlet</url-pattern>
</servlet-mapping>
Au-dessus des entrées à créer dans les balises <web-app> ... </web-app> disponibles dans le fichier web.xml. Il peut y avoir plusieurs entrées dans ce tableau déjà disponibles, mais peu importe.
Vous avez presque terminé, commençons maintenant le serveur tomcat en utilisant <Tomcat-installationdirectory> \ bin \ startup.bat (sous Windows) ou <Tomcat-installationdirectory> /bin/startup.sh (sous Linux / Solaris etc.) et enfin tapez http://localhost:8080/MyServletdans la zone d'adresse du navigateur. Si tout se passe bien, vous obtiendrez le résultat suivant -
Hello World
Il est toujours difficile de tester / déboguer des servlets. Les servlets ont tendance à impliquer une grande quantité d'interactions client / serveur, ce qui rend les erreurs probables mais difficiles à reproduire.
Voici quelques conseils et suggestions qui peuvent vous aider dans votre débogage.
System.out.println ()
System.out.println () est facile à utiliser comme marqueur pour tester si un certain morceau de code est en cours d'exécution ou non. Nous pouvons également imprimer les valeurs des variables. De plus -
Étant donné que l'objet System fait partie des objets Java de base, il peut être utilisé partout sans avoir besoin d'installer de classes supplémentaires. Cela inclut les servlets, les JSP, les RMI, les EJB, les Beans ordinaires et les classes et les applications autonomes.
La technique d'arrêt aux points d'arrêt arrête l'exécution normale et prend donc plus de temps. Alors que l'écriture dans System.out n'interfère pas beaucoup avec le flux d'exécution normal de l'application, ce qui la rend très utile lorsque le timing est crucial.
Voici la syntaxe pour utiliser System.out.println () -
System.out.println("Debugging message");
Tous les messages générés par la syntaxe ci-dessus seraient enregistrés dans le fichier journal du serveur Web.
Journalisation des messages
Il est toujours judicieux d'utiliser une méthode de journalisation appropriée pour enregistrer tous les messages de débogage, d'avertissement et d'erreur à l'aide d'une méthode de journalisation standard. J'utilise log4J pour enregistrer tous les messages.
L'API Servlet fournit également un moyen simple de générer des informations en utilisant la méthode log () comme suit -
// Import required java libraries
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
public class ContextLog extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, java.io.IOException {
String par = request.getParameter("par1");
//Call the two ServletContext.log methods
ServletContext context = getServletContext( );
if (par == null || par.equals(""))
//log version with Throwable parameter
context.log("No message received:", new IllegalStateException("Missing parameter"));
else
context.log("Here is the visitor's message: " + par);
response.setContentType("text/html");
java.io.PrintWriter out = response.getWriter( );
String title = "Context Log";
String docType =
"<!doctype html public \"-//w3c//dtd html 4.0 " + "transitional//en\">\n";
out.println(docType +
"<html>\n" +
"<head><title>" + title + "</title></head>\n" +
"<body bgcolor = \"#f0f0f0\">\n" +
"<h1 align = \"center\">" + title + "</h1>\n" +
"<h2 align = \"center\">Messages sent</h2>\n" +
"</body>
</html>"
);
} //doGet
}
ServletContext enregistre ses messages texte dans le fichier journal du conteneur de servlet. Avec Tomcat, ces journaux se trouvent dans <Tomcat-installation-directory> / logs.
Les fichiers journaux donnent une indication des nouveaux bogues émergents ou de la fréquence des problèmes. Pour cette raison, il est bon d'utiliser la fonction log () dans la clause catch des exceptions qui ne devraient normalement pas se produire.
Utilisation du débogueur JDB
Vous pouvez déboguer les servlets avec les mêmes commandes jdb que vous utilisez pour déboguer une applet ou une application.
Pour déboguer un servlet, nous débogageons sun.servlet.http.HttpServer et observons attentivement pendant que HttpServer exécute les servlets en réponse aux requêtes HTTP faites à partir du navigateur. Ceci est très similaire à la façon dont les applets sont débogués. La différence est qu'avec les applets, le programme en cours de débogage est sun.applet.AppletViewer.
La plupart des débogueurs cachent ce détail en sachant automatiquement comment déboguer les applets. Jusqu'à ce qu'ils fassent de même pour les servlets, vous devez aider votre débogueur en procédant comme suit:
Définissez le chemin d'accès aux classes de votre débogueur afin qu'il puisse trouver sun.servlet.http.Http-Server et les classes associées.
Définissez le chemin de classe de votre débogueur afin qu'il puisse également trouver vos servlets et classes de support, généralement racine_serveur / servlets et racine_serveur / classes.
Normalement, vous ne voudriez pas racine_serveur / servlets dans votre chemin de classe car cela désactive le rechargement des servlets. Cette inclusion, cependant, est utile pour le débogage. Il permet à votre débogueur de définir des points d'arrêt dans un servlet avant que le chargeur de servlet personnalisé dans HttpServer ne charge le servlet.
Une fois que vous avez défini le chemin de classe approprié, démarrez le débogage de sun.servlet.http.HttpServer. Vous pouvez définir des points d'arrêt dans le servlet que vous souhaitez déboguer, puis utiliser un navigateur Web pour faire une requête au serveur HttpServer pour le servlet donné (http: // localhost: 8080 / servlet / ServletToDebug). Vous devriez voir l'exécution s'arrêter à vos points d'arrêt.
Utilisation des commentaires
Les commentaires dans votre code peuvent aider le processus de débogage de différentes manières. Les commentaires peuvent être utilisés de nombreuses autres manières dans le processus de débogage.
Le servlet utilise des commentaires Java et des commentaires sur une seule ligne (// ...) et sur plusieurs lignes (/ * ... * /) peuvent être utilisés pour supprimer temporairement des parties de votre code Java. Si le bogue disparaît, examinez de plus près le code que vous venez de commenter et découvrez le problème.
En-têtes client et serveur
Parfois, lorsqu'un servlet ne se comporte pas comme prévu, il est utile de regarder la requête et la réponse HTTP brutes. Si vous connaissez la structure de HTTP, vous pouvez lire la requête et la réponse et voir exactement ce qui se passe exactement avec ces en-têtes.
Conseils de débogage importants
Voici une liste de quelques autres conseils de débogage sur le débogage de servlet -
Rappelez-vous que racine_serveur / classes ne se recharge pas et que racine_serveur / servlets le fait probablement.
Demandez à un navigateur d'afficher le contenu brut de la page qu'il affiche. Cela peut aider à identifier les problèmes de formatage. C'est généralement une option dans le menu Affichage.
Assurez-vous que le navigateur ne met pas en cache la sortie d'une requête précédente en forçant un rechargement complet de la page. Avec Netscape Navigator, utilisez Shift-Reload; avec Internet Explorer, utilisez Shift-Refresh.
Vérifiez que la méthode init () de votre servlet prend un paramètre ServletConfig et appelle immédiatement super.init (config).
Avant de continuer, laissez-moi vous expliquer trois termes importants -
Internationalization (i18n) - Cela signifie permettre à un site Web de fournir différentes versions de contenu traduites dans la langue ou la nationalité du visiteur
Localization (l10n) - Cela signifie ajouter des ressources à un site Web pour s'adapter à une région géographique ou culturelle particulière.
locale- Il s'agit d'une région culturelle ou géographique particulière. Il est généralement appelé symbole de langue suivi d'un symbole de pays séparé par un trait de soulignement. Par exemple, "en_US" représente les paramètres régionaux anglais pour les États-Unis.
Il y a un certain nombre d'éléments qui doivent être pris en compte lors de la création d'un site Web mondial. Ce tutoriel ne vous donnerait pas tous les détails à ce sujet, mais il vous donnerait un bon exemple sur la façon dont vous pouvez proposer votre page Web dans différentes langues à la communauté Internet en différenciant leur emplacement, c'est-à-dire les paramètres régionaux.
Un servlet peut récupérer la version appropriée du site en fonction des paramètres régionaux du demandeur et fournir une version de site appropriée en fonction de la langue, de la culture et des exigences locales. Voici la méthode d'objet de requête qui renvoie l'objet Locale.
java.util.Locale request.getLocale()
Détection des paramètres régionaux
Voici les méthodes locales importantes que vous pouvez utiliser pour détecter l'emplacement, la langue et bien sûr les paramètres régionaux du demandeur. Toutes les méthodes ci-dessous affichent le nom du pays et le nom de la langue définis dans le navigateur du demandeur.
Sr.No. | Méthode et description |
---|---|
1 | String getCountry() Cette méthode renvoie le code du pays / région en majuscules pour ce paramètre régional au format ISO 3166 à 2 lettres. |
2 | String getDisplayCountry() Cette méthode renvoie un nom pour le pays des paramètres régionaux approprié pour l'affichage à l'utilisateur. |
3 | String getLanguage() Cette méthode renvoie le code de langue en minuscules pour cette locale au format ISO 639. |
4 | String getDisplayLanguage() Cette méthode retourne un nom pour la langue des paramètres régionaux appropriée pour l'affichage à l'utilisateur. |
5 | String getISO3Country() Cette méthode renvoie une abréviation de trois lettres pour le pays de cette locale. |
6 | String getISO3Language() Cette méthode renvoie une abréviation de trois lettres pour la langue de cette locale. |
Exemple
Cet exemple montre comment afficher une langue et un pays associé pour une demande -
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
import java.util.Locale;
public class GetLocale extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
//Get the client's Locale
Locale locale = request.getLocale();
String language = locale.getLanguage();
String country = locale.getCountry();
// Set response content type
response.setContentType("text/html");
PrintWriter out = response.getWriter();
String title = "Detecting Locale";
String docType =
"<!doctype html public \"-//w3c//dtd html 4.0 " + "transitional//en\">\n";
out.println(docType +
"<html>\n" +
"<head><title>" + title + "</title></head>\n" +
"<body bgcolor = \"#f0f0f0\">\n" +
"<h1 align = \"center\">" + language + "</h1>\n" +
"<h2 align = \"center\">" + country + "</h2>\n" +
"</body>
</html>"
);
}
}
Réglage des langues
Un servlet peut afficher une page écrite dans une langue d'Europe occidentale telle que l'anglais, l'espagnol, l'allemand, le français, l'italien, le néerlandais, etc. Ici, il est important de définir l'en-tête ContentLanguage pour afficher correctement tous les caractères.
Le deuxième point est d'afficher tous les caractères spéciaux à l'aide d'entités HTML, par exemple, "& # 241;" représente "ñ" et "& # 161;" représente "¡" comme suit:
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
import java.util.Locale;
public class DisplaySpanish extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
// Set response content type
response.setContentType("text/html");
PrintWriter out = response.getWriter();
// Set spanish language code.
response.setHeader("Content-Language", "es");
String title = "En Español";
String docType =
"<!doctype html public \"-//w3c//dtd html 4.0 " + "transitional//en\">\n";
out.println(docType +
"<html>\n" +
"<head><title>" + title + "</title></head>\n" +
"<body bgcolor = \"#f0f0f0\">\n" +
"<h1>" + "En Español:" + "</h1>\n" +
"<h1>" + "¡Hola Mundo!" + "</h1>\n" +
"</body>
</html>"
);
}
}
Dates spécifiques aux paramètres régionaux
Vous pouvez utiliser la classe java.text.DateFormat et sa méthode statique getDateTimeInstance () pour formater la date et l'heure spécifiques aux paramètres régionaux. Voici l'exemple qui montre comment formater des dates spécifiques à une locale donnée -
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
import java.util.Locale;
import java.text.DateFormat;
import java.util.Date;
public class DateLocale extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
// Set response content type
response.setContentType("text/html");
PrintWriter out = response.getWriter();
//Get the client's Locale
Locale locale = request.getLocale( );
String date = DateFormat.getDateTimeInstance(DateFormat.FULL,
DateFormat.SHORT, locale).format(new Date( ));
String title = "Locale Specific Dates";
String docType =
"<!doctype html public \"-//w3c//dtd html 4.0 " + "transitional//en\">\n";
out.println(docType +
"<html>\n" +
"<head><title>" + title + "</title></head>\n" +
"<body bgcolor = \"#f0f0f0\">\n" +
"<h1 align = \"center\">" + date + "</h1>\n" +
"</body>
</html>"
);
}
}
Monnaie spécifique aux paramètres régionaux
Vous pouvez utiliser la classe java.txt.NumberFormat et sa méthode statique getCurrencyInstance () pour formater un nombre, tel qu'un type long ou double, dans une devise spécifique aux paramètres régionaux. Voici l'exemple qui montre comment formater une devise spécifique à une locale donnée -
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
import java.util.Locale;
import java.text.NumberFormat;
import java.util.Date;
public class CurrencyLocale extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
// Set response content type
response.setContentType("text/html");
PrintWriter out = response.getWriter();
//Get the client's Locale
Locale locale = request.getLocale( );
NumberFormat nft = NumberFormat.getCurrencyInstance(locale);
String formattedCurr = nft.format(1000000);
String title = "Locale Specific Currency";
String docType =
"<!doctype html public \"-//w3c//dtd html 4.0 " + "transitional//en\">\n";
out.println(docType +
"<html>\n" +
"<head><title>" + title + "</title></head>\n" +
"<body bgcolor = \"#f0f0f0\">\n" +
"<h1 align = \"center\">" + formattedCurr + "</h1>\n" +
"</body>
</html>"
);
}
}
Pourcentage spécifique aux paramètres régionaux
Vous pouvez utiliser la classe java.txt.NumberFormat et sa méthode statique getPercentInstance () pour obtenir le pourcentage spécifique aux paramètres régionaux. Voici l'exemple qui montre comment formater le pourcentage spécifique à une locale donnée -
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
import java.util.Locale;
import java.text.NumberFormat;
import java.util.Date;
public class PercentageLocale extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
// Set response content type
response.setContentType("text/html");
PrintWriter out = response.getWriter();
//Get the client's Locale
Locale locale = request.getLocale( );
NumberFormat nft = NumberFormat.getPercentInstance(locale);
String formattedPerc = nft.format(0.51);
String title = "Locale Specific Percentage";
String docType =
"<!doctype html public \"-//w3c//dtd html 4.0 " + "transitional//en\">\n";
out.println(docType +
"<html>\n" +
"<head><title>" + title + "</title></head>\n" +
"<body bgcolor = \"#f0f0f0\">\n" +
"<h1 align = \"center\">" + formattedPerc + "</h1>\n" +
"</body>
</html>"
);
}
}
Jusqu'à présent, vous avez appris comment Servlet utilise le descripteur de déploiement (fichier web.xml) pour déployer votre application sur un serveur Web. Servlet API 3.0 a introduit un nouveau package appelé javax.servlet.annotation. Il fournit des types d'annotations qui peuvent être utilisés pour annoter une classe de servlet. Si vous utilisez une annotation, le descripteur de déploiement (web.xml) n'est pas requis. Mais vous devez utiliser tomcat7 ou toute version ultérieure de tomcat.
Les annotations peuvent remplacer la configuration XML équivalente dans le fichier descripteur de déploiement Web (web.xml), comme la déclaration de servlet et le mappage de servlet. Les conteneurs de servlet traiteront les classes annotées au moment du déploiement.
Les types d'annotations introduits dans Servlet 3.0 sont -
Sr.No. | Annotation et description |
---|---|
1 | @WebServlet Pour déclarer un servlet. |
2 | @WebInitParam Pour spécifier un paramètre d'initialisation. |
3 | @WebFilter Pour déclarer un filtre de servlet. |
4 | @WebListener Pour déclarer un WebListener |
5 | @HandlesTypes Pour déclarer les types de classe qu'un ServletContainerInitializer peut gérer. |
6 | @HttpConstraint Cette annotation est utilisée dans l'annotation ServletSecurity pour représenter les contraintes de sécurité à appliquer à toutes les méthodes de protocole HTTP pour lesquelles un élément HttpMethodConstraint correspondant ne se produit PAS dans l'annotation ServletSecurity. |
sept | @HttpMethodConstraint Cette annotation est utilisée dans l'annotation ServletSecurity pour représenter les contraintes de sécurité sur des messages de protocole HTTP spécifiques. |
8 | @MultipartConfig Annotation qui peut être spécifiée sur une classe Servlet, indiquant que les instances du Servlet attendent des demandes conformes au type MIME multipart / form-data. |
9 | @ServletSecurity Cette annotation est utilisée sur une classe d'implémentation de servlet pour spécifier les contraintes de sécurité à appliquer par un conteneur de servlet sur les messages de protocole HTTP. |
Ici, nous avons discuté en détail de certaines des annotations.
@WebServlet
Le @WebServlet est utilisé pour déclarer la configuration d'un servlet avec un conteneur. Le tableau suivant contient la liste des attributs utilisés pour l'annotation WebServlet.
Sr.No. | Attribut et description |
---|---|
1 | String name Nom du servlet |
2 | String[] value Tableau de modèles d'URL |
3 | String[] urlPatterns Tableau de modèles d'URL auxquels ce filtre s'applique |
4 | Int loadOnStartup La valeur entière vous donne l'indication de commande de démarrage |
5 | WebInitParam[] initParams Tableau de paramètres d'initialisation pour ce servlet |
6 | Boolean asyncSupported Opération asynchrone prise en charge par ce servlet |
sept | String smallIcon Petite icône pour ce servlet, si présent |
8 | String largeIcon Grande icône pour ce servlet, si présent |
9 | String description Description de ce servlet, si présent |
dix | String displayName Afficher le nom de ce servlet, s'il est présent |
Au moins un modèle d'URL DOIT être déclaré dans l'un ou l'autre value ou urlPattern attribut de l'annotation, mais pas les deux.
le value est recommandé pour une utilisation lorsque le modèle d'URL est le seul attribut défini, sinon urlPattern l'attribut doit être utilisé.
Exemple
L'exemple suivant décrit comment utiliser l'annotation @WebServlet. C'est un simple servlet qui affiche le texteHello Servlet.
import java.io.IOException;
import java.io.PrintWriter;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebInitParam;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
@WebServlet(value = "/Simple")
public class Simple extends HttpServlet {
private static final long serialVersionUID = 1L;
protected void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
response.setContentType("text/html");
PrintWriter out = response.getWriter();
out.print("<html><body>");
out.print("<h3>Hello Servlet</h3>");
out.print("</body></html>");
}
}
Compiler Simple.java de la manière habituelle et placez votre fichier de classe dans <Tomcat-installationdirectory> / webapps / ROOT / WEB-INF / classes.
Essayez maintenant d'appeler n'importe quelle servlet en exécutant simplement http: // localhost: 8080 / Simple . Vous verrez la sortie suivante sur la page Web.
Hello servlet
@WebInitParam
L'annotation @WebInitParam est utilisée pour spécifier un paramètre d'initialisation pour un servlet ou un filtre. Il est utilisé dans les annotations WebFilter ou WebSevlet. Le tableau suivant contient la liste des attributs utilisés pour l'annotation WebInitParam.
Sr.No. | Attribut et description |
---|---|
1 | String name Nom du paramètre d'initialisation |
2 | String value Valeur du paramètre d'initialisation |
3 | String description Description du paramètre d'initialisation |
Exemple
L'exemple suivant décrit comment utiliser l'annotation @WeInitParam avec l'annotation @WebServlet. C'est un simple servlet qui affiche le texteHello Servlet et la valeur de la chaîne Hello World! qui sont tirés du init paramètres.
import java.io.IOException;
import java.io.PrintWriter;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebInitParam;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
@WebServlet(value = "/Simple", initParams = {
@WebInitParam(name = "foo", value = "Hello "),
@WebInitParam(name = "bar", value = " World!")
})
public class Simple extends HttpServlet {
private static final long serialVersionUID = 1L;
protected void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
response.setContentType("text/html");
PrintWriter out = response.getWriter();
out.print("<html><body>");
out.print("<h3>Hello Servlet</h3>");
out.println(getInitParameter("foo"));
out.println(getInitParameter("bar"));
out.print("</body></html>");
}
}
Compiler Simple.java de la manière habituelle et placez votre fichier de classe dans <Tomcat-installationdirectory>; / webapps / ROOT / WEB-INF / classes.
Essayez maintenant d'appeler n'importe quelle servlet en exécutant simplement http: // localhost: 8080 / Simple . Vous verrez la sortie suivante sur la page Web.
Hello Servlet
Hello World!
@Webfilter
Il s'agit de l'annotation utilisée pour déclarer un filtre de servlet. Il est traité par le conteneur au moment du déploiement et le filtre correspondant est appliqué aux modèles d'URL, servlets et types de répartiteur spécifiés.
le @WebFilterl'annotation définit un filtre dans une application Web. Cette annotation est spécifiée sur une classe et contient des métadonnées sur le filtre déclaré. Le filtre annoté doit spécifier au moins un modèle d'URL. Le tableau suivant répertorie les attributs utilisés pour l'annotation WebFilter.
Sr.No. | Attribut et description |
---|---|
1 | String filterName Nom du filtre |
2 | String[] urlPatterns Fournit un tableau de valeurs ou de URLPatterns auxquels le filtre s'applique |
3 | DispatcherType[] dispatcherTypes Spécifie les types de répartiteur (demande / réponse) auxquels le filtre s'applique |
4 | String[] servletNames Fournit un tableau de noms de servlet |
5 | String displayName Nom du filtre |
6 | String description Description du filtre |
sept | WebInitParam[] initParams Tableau de paramètres d'initialisation pour ce filtre |
8 | Boolean asyncSupported Opération asynchrone prise en charge par ce filtre |
9 | String smallIcon Petite icône pour ce filtre, le cas échéant |
dix | String largeIcon Grande icône pour ce filtre, le cas échéant |
Exemple
L'exemple suivant décrit comment utiliser l'annotation @WebFilter. C'est un simple LogFilter qui affiche la valeur de Init-paramtest-paramet l'horodatage de l'heure actuelle sur la console. Cela signifie que le filtre fonctionne comme une couche d'interface entre la demande et la réponse. Ici, nous utilisons "/ *" pour urlPattern. Cela signifie que ce filtre est applicable à toutes les servlets.
import java.io.IOException;
import javax.servlet.annotation.WebFilter;
import javax.servlet.annotation.WebInitParam;
import javax.servlet.*;
import java.util.*;
// Implements Filter class
@WebFilter(urlPatterns = {"/*"}, initParams = {
@WebInitParam(name = "test-param", value = "Initialization Paramter")})
public class LogFilter implements Filter {
public void init(FilterConfig config) throws ServletException {
// Get init parameter
String testParam = config.getInitParameter("test-param");
//Print the init parameter
System.out.println("Test Param: " + testParam);
}
public void doFilter(ServletRequest request, ServletResponse response,
FilterChain chain) throws IOException, ServletException {
// Log the current timestamp.
System.out.println("Time " + new Date().toString());
// Pass request back down the filter chain
chain.doFilter(request,response);
}
public void destroy( ) {
/* Called before the Filter instance is removed
from service by the web container*/
}
}
Compiler Simple.java de la manière habituelle et placez votre fichier de classe dans <Tomcat-installationdirectory> / webapps / ROOT / WEB-INF / classes.
Essayez maintenant d'appeler n'importe quelle servlet en exécutant simplement http: // localhost: 8080 / Simple . Vous verrez la sortie suivante sur la page Web.
Hello Servlet
Hello World!
Maintenant, ouvrez la console de servlet. Là, vous trouverez la valeur duinit paramètre testparam et le current timestamp ainsi que des messages de notification de servlet.