Servlets - Kurzanleitung

Was sind Servlets?

Java-Servlets sind Programme, die auf einem Web- oder Anwendungsserver ausgeführt werden und als mittlere Schicht zwischen Anforderungen eines Webbrowsers oder eines anderen HTTP-Clients und Datenbanken oder Anwendungen auf dem HTTP-Server fungieren.

Mithilfe von Servlets können Sie Eingaben von Benutzern über Webseitenformulare sammeln, Datensätze aus einer Datenbank oder einer anderen Quelle präsentieren und Webseiten dynamisch erstellen.

Java-Servlets dienen häufig demselben Zweck wie Programme, die über das Common Gateway Interface (CGI) implementiert wurden. Servlets bieten jedoch im Vergleich zum CGI mehrere Vorteile.

  • Die Leistung ist deutlich besser.

  • Servlets werden im Adressraum eines Webservers ausgeführt. Es ist nicht erforderlich, einen separaten Prozess für jede Clientanforderung zu erstellen.

  • Servlets sind plattformunabhängig, da sie in Java geschrieben sind.

  • Der Java-Sicherheitsmanager auf dem Server erzwingt eine Reihe von Einschränkungen, um die Ressourcen auf einem Server zu schützen. Servlets sind also vertrauenswürdig.

  • Die volle Funktionalität der Java-Klassenbibliotheken steht einem Servlet zur Verfügung. Es kann mit Applets, Datenbanken oder anderer Software über die Sockets und RMI-Mechanismen kommunizieren, die Sie bereits gesehen haben.

Servlet-Architektur

Das folgende Diagramm zeigt die Position von Servlets in einer Webanwendung.

Servlet-Aufgaben

Servlets führen die folgenden Hauptaufgaben aus:

  • Lesen Sie die expliziten Daten, die von den Clients (Browsern) gesendet wurden. Dies umfasst ein HTML-Formular auf einer Webseite oder kann auch von einem Applet oder einem benutzerdefinierten HTTP-Client-Programm stammen.

  • Lesen Sie die impliziten HTTP-Anforderungsdaten, die von den Clients (Browsern) gesendet wurden. Dies umfasst Cookies, Medientypen und Komprimierungsschemata, die der Browser versteht, und so weiter.

  • Verarbeiten Sie die Daten und generieren Sie die Ergebnisse. Für diesen Prozess muss möglicherweise mit einer Datenbank gesprochen, ein RMI- oder CORBA-Aufruf ausgeführt, ein Webdienst aufgerufen oder die Antwort direkt berechnet werden.

  • Senden Sie die expliziten Daten (dh das Dokument) an die Clients (Browser). Dieses Dokument kann in verschiedenen Formaten gesendet werden, darunter Text (HTML oder XML), Binärformate (GIF-Bilder), Excel usw.

  • Senden Sie die implizite HTTP-Antwort an die Clients (Browser). Dazu gehört, den Browsern oder anderen Clients mitzuteilen, welche Art von Dokument zurückgegeben wird (z. B. HTML), Cookies und Caching-Parameter festzulegen und andere solche Aufgaben auszuführen.

Servlet-Pakete

Java-Servlets sind Java-Klassen, die von einem Webserver ausgeführt werden, der über einen Interpreter verfügt, der die Java-Servlet-Spezifikation unterstützt.

Servlets können mit dem erstellt werden javax.servlet und javax.servlet.http Pakete, die ein Standardbestandteil der Enterprise Edition von Java sind, einer erweiterten Version der Java-Klassenbibliothek, die umfangreiche Entwicklungsprojekte unterstützt.

Diese Klassen implementieren die Java Servlet- und JSP-Spezifikationen. Zum Zeitpunkt des Schreibens dieses Tutorials sind die Versionen Java Servlet 2.5 und JSP 2.1.

Java-Servlets wurden wie jede andere Java-Klasse erstellt und kompiliert. Nachdem Sie die Servlet-Pakete installiert und zum Klassenpfad Ihres Computers hinzugefügt haben, können Sie Servlets mit dem Java-Compiler des JDK oder einem anderen aktuellen Compiler kompilieren.

Was kommt als nächstes?

Ich würde Sie Schritt für Schritt dazu bringen, Ihre Umgebung so einzurichten, dass sie mit Servlets beginnt. Also schnallen Sie sich Ihren Gurt für eine schöne Fahrt mit Servlets an. Ich bin sicher, Sie werden dieses Tutorial sehr genießen.

In einer Entwicklungsumgebung würden Sie Ihr Servlet entwickeln, testen und schließlich ausführen.

Wie bei jedem anderen Java-Programm müssen Sie ein Servlet mithilfe des Java-Compilers kompilieren javac Nach dem Kompilieren der Servlet-Anwendung wird sie in einer konfigurierten Umgebung zum Testen und Ausführen bereitgestellt.

Diese Einrichtung der Entwicklungsumgebung umfasst die folgenden Schritte:

Einrichten des Java Development Kit

In diesem Schritt wird eine Implementierung des Java Software Development Kit (SDK) heruntergeladen und die Umgebungsvariable PATH entsprechend eingerichtet.

Sie können das SDK von der Java-Site von Oracle herunterladen - Java SE Downloads .

Befolgen Sie nach dem Herunterladen Ihrer Java-Implementierung die angegebenen Anweisungen, um das Setup zu installieren und zu konfigurieren. Stellen Sie schließlich die Umgebungsvariablen PATH und JAVA_HOME so ein, dass sie auf das Verzeichnis verweisen, das Java und Javac enthält, normalerweise java_install_dir / bin bzw. java_install_dir.

Wenn Sie Windows ausführen und das SDK in C: \ jdk1.8.0_65 installiert haben, fügen Sie die folgende Zeile in Ihre Datei C: \ autoexec.bat ein.

set PATH = C:\jdk1.8.0_65\bin;%PATH% 
set JAVA_HOME = C:\jdk1.8.0_65

Alternativ können Sie unter Windows NT / 2000 / XP auch mit der rechten Maustaste auf Arbeitsplatz klicken, Eigenschaften auswählen, dann Erweitert und dann Umgebungsvariablen. Dann würden Sie den PATH-Wert aktualisieren und die OK-Taste drücken.

Wenn unter Unix (Solaris, Linux usw.) das SDK in /usr/local/jdk1.8.0_65 installiert ist und Sie die C-Shell verwenden, fügen Sie Folgendes in Ihre .cshrc-Datei ein.

setenv PATH /usr/local/jdk1.8.0_65/bin:$PATH 
setenv JAVA_HOME /usr/local/jdk1.8.0_65

Wenn Sie alternativ eine integrierte Entwicklungsumgebung (IDE) wie Borland JBuilder, Eclipse, IntelliJ IDEA oder Sun ONE Studio verwenden, kompilieren Sie ein einfaches Programm und führen Sie es aus, um zu bestätigen, dass die IDE weiß, wo Sie Java installiert haben.

Einrichten des Webservers - Tomcat

Auf dem Markt sind eine Reihe von Webservern verfügbar, die Servlets unterstützen. Einige Webserver können kostenlos heruntergeladen werden, und Tomcat ist einer davon.

Apache Tomcat ist eine Open-Source-Softwareimplementierung der Technologien Java Servlet und Java Server Pages. Sie kann als eigenständiger Server zum Testen von Servlets fungieren und in den Apache Web Server integriert werden. Hier sind die Schritte zum Einrichten von Tomcat auf Ihrem Computer:

  • Laden Sie die neueste Version von Tomcat von herunter https://tomcat.apache.org/.

  • Nachdem Sie die Installation heruntergeladen haben, entpacken Sie die Binärdistribution an einem geeigneten Ort. Zum Beispiel in C: \ apache-tomcat-8.0.28 unter Windows oder /usr/local/apache-tomcat-8.0.289 unter Linux / Unix und erstellen Sie die Umgebungsvariable CATALINA_HOME, die auf diese Speicherorte verweist.

Tomcat kann durch Ausführen der folgenden Befehle auf einem Windows-Computer gestartet werden:

%CATALINA_HOME%\bin\startup.bat
or
C:\apache-tomcat-8.0.28\bin\startup.bat

Tomcat kann durch Ausführen der folgenden Befehle auf einem Unix-Computer (Solaris, Linux usw.) gestartet werden:

$CATALINA_HOME/bin/startup.sh
or
/usr/local/apache-tomcat-8.0.28/bin/startup.sh

Nach dem Start sind die in Tomcat enthaltenen Standard-Webanwendungen unter verfügbar http://localhost:8080/. Wenn alles in Ordnung ist, sollte folgendes Ergebnis angezeigt werden:

Weitere Informationen zum Konfigurieren und Ausführen von Tomcat finden Sie in der hier enthaltenen Dokumentation sowie auf der Tomcat-Website unter http://tomcat.apache.org

Tomcat kann gestoppt werden, indem die folgenden Befehle auf einem Windows-Computer ausgeführt werden:

C:\apache-tomcat-8.0.28\bin\shutdown

Tomcat kann gestoppt werden, indem die folgenden Befehle auf einem Unix-Computer (Solaris, Linux usw.) ausgeführt werden:

/usr/local/apache-tomcat-8.0.28/bin/shutdown.sh

Einrichten des CLASSPATH

Da Servlets nicht Teil der Java Platform, Standard Edition, sind, müssen Sie dem Compiler die Servlet-Klassen identifizieren.

Wenn Sie Windows ausführen, müssen Sie die folgenden Zeilen in Ihre Datei C: \ autoexec.bat einfügen.

set CATALINA = C:\apache-tomcat-8.0.28 
set CLASSPATH = %CATALINA%\common\lib\servlet-api.jar;%CLASSPATH%

Alternativ können Sie unter Windows NT / 2000 / XP zu Arbeitsplatz -> Eigenschaften -> Erweitert -> Umgebungsvariablen gehen. Dann würden Sie den CLASSPATH-Wert aktualisieren und die OK-Taste drücken.

Wenn Sie unter Unix (Solaris, Linux usw.) die C-Shell verwenden, fügen Sie die folgenden Zeilen in Ihre .cshrc-Datei ein.

setenv CATALINA = /usr/local/apache-tomcat-8.0.28
setenv CLASSPATH $CATALINA/common/lib/servlet-api.jar:$CLASSPATH

NOTE - Angenommen, Ihr Entwicklungsverzeichnis ist C: \ ServletDevel (Windows) oder / usr / ServletDevel (Unix), dann müssten Sie diese Verzeichnisse auch in CLASSPATH auf ähnliche Weise wie oben hinzugefügt hinzufügen.

Ein Servlet-Lebenszyklus kann als der gesamte Prozess von seiner Erstellung bis zur Zerstörung definiert werden. Das Folgende sind die Pfade, denen ein Servlet folgt.

  • Das Servlet wird durch Aufrufen von initialisiert init() Methode.

  • Das Servlet ruft auf service() Methode zum Verarbeiten der Anfrage eines Kunden.

  • Das Servlet wird durch Aufrufen von beendet destroy() Methode.

  • Schließlich ist Servlet Müll, der vom Garbage Collector der JVM gesammelt wird.

Lassen Sie uns nun die Lebenszyklusmethoden im Detail diskutieren.

Die init () -Methode

Die init-Methode wird nur einmal aufgerufen. Es wird nur aufgerufen, wenn das Servlet erstellt wird, und anschließend nicht für Benutzeranforderungen aufgerufen. Daher wird es für einmalige Initialisierungen verwendet, genau wie bei der Init-Methode von Applets.

Das Servlet wird normalerweise erstellt, wenn ein Benutzer zum ersten Mal eine dem Servlet entsprechende URL aufruft. Sie können jedoch auch angeben, dass das Servlet beim ersten Start des Servers geladen werden soll.

Wenn ein Benutzer ein Servlet aufruft, wird eine einzelne Instanz jedes Servlets erstellt, wobei jede Benutzeranforderung zu einem neuen Thread führt, der entsprechend an doGet oder doPost übergeben wird. Die Methode init () erstellt oder lädt einfach einige Daten, die während der gesamten Lebensdauer des Servlets verwendet werden.

Die Definition der init-Methode sieht folgendermaßen aus:

public void init() throws ServletException {
   // Initialization code...
}

Die service () -Methode

Die service () -Methode ist die Hauptmethode zum Ausführen der eigentlichen Aufgabe. Der Servlet-Container (dh der Webserver) ruft die service () -Methode auf, um vom Client (Browser) kommende Anforderungen zu verarbeiten und die formatierte Antwort zurück an den Client zu schreiben.

Jedes Mal, wenn der Server eine Anforderung für ein Servlet empfängt, erzeugt der Server einen neuen Thread und ruft den Dienst auf. Die service () -Methode überprüft den HTTP-Anforderungstyp (GET, POST, PUT, DELETE usw.) und ruft die entsprechenden Methoden doGet, doPost, doPut, doDelete usw. auf.

Hier ist die Signatur dieser Methode -

public void service(ServletRequest request, ServletResponse response) 
   throws ServletException, IOException {
}

Die service () -Methode wird vom Container aufgerufen, und die service-Methode ruft die entsprechenden Methoden doGet, doPost, doPut, doDelete usw. auf. Sie haben also nichts mit der service () -Methode zu tun, sondern überschreiben entweder doGet () oder doPost (), je nachdem, welche Art von Anforderung Sie vom Client erhalten.

DoGet () und doPost () sind die am häufigsten verwendeten Methoden in jeder Serviceanforderung. Hier ist die Signatur dieser beiden Methoden.

Die doGet () -Methode

Eine GET-Anforderung ergibt sich aus einer normalen Anforderung für eine URL oder aus einem HTML-Formular, für das keine METHODE angegeben ist und das von der Methode doGet () verarbeitet werden sollte.

public void doGet(HttpServletRequest request, HttpServletResponse response)
   throws ServletException, IOException {
   // Servlet code
}

Die doPost () -Methode

Eine POST-Anforderung resultiert aus einem HTML-Formular, in dem POST speziell als METHODE aufgeführt ist, und sollte von der Methode doPost () verarbeitet werden.

public void doPost(HttpServletRequest request, HttpServletResponse response)
   throws ServletException, IOException {
   // Servlet code
}

Die destroy () -Methode

Die Methode destroy () wird am Ende des Lebenszyklus eines Servlets nur einmal aufgerufen. Diese Methode gibt Ihrem Servlet die Möglichkeit, Datenbankverbindungen zu schließen, Hintergrundthreads anzuhalten, Cookie-Listen zu schreiben oder die Anzahl der Treffer auf die Festplatte zu zählen und andere solche Bereinigungsaktivitäten durchzuführen.

Nach dem Aufruf der destroy () -Methode wird das Servlet-Objekt für die Garbage Collection markiert. Die Definition der Zerstörungsmethode sieht folgendermaßen aus:

public void destroy() {
   // Finalization code...
}

Architekturdiagramm

Die folgende Abbildung zeigt ein typisches Servlet-Lebenszyklus-Szenario.

  • Zuerst werden die an den Server kommenden HTTP-Anforderungen an den Servlet-Container delegiert.

  • Der Servlet-Container lädt das Servlet, bevor die service () -Methode aufgerufen wird.

  • Anschließend verarbeitet der Servlet-Container mehrere Anforderungen, indem mehrere Threads erzeugt werden, wobei jeder Thread die service () -Methode einer einzelnen Instanz des Servlets ausführt.

Servlets sind Java-Klassen, die HTTP-Anforderungen bearbeiten und die implementieren javax.servlet.ServletSchnittstelle. Webanwendungsentwickler schreiben normalerweise Servlets, die javax.servlet.http.HttpServlet erweitern, eine abstrakte Klasse, die die Servlet-Schnittstelle implementiert und speziell für die Verarbeitung von HTTP-Anforderungen entwickelt wurde.

Beispielcode

Im Folgenden finden Sie die Beispiel-Quellcodestruktur eines Servlet-Beispiels zur Darstellung von 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.
   }
}

Servlet kompilieren

Lassen Sie uns eine Datei mit dem Namen HelloWorld.java mit dem oben gezeigten Code erstellen. Platzieren Sie diese Datei unter C: \ ServletDevel (unter Windows) oder unter / usr / ServletDevel (unter Unix). Diese Pfadposition muss zu CLASSPATH hinzugefügt werden, bevor Sie fortfahren können.

Angenommen, Ihre Umgebung ist ordnungsgemäß eingerichtet, gehen Sie hinein ServletDevel Verzeichnis und kompilieren Sie HelloWorld.java wie folgt -

$ javac HelloWorld.java

Wenn das Servlet von anderen Bibliotheken abhängt, müssen Sie diese JAR-Dateien auch in Ihren CLASSPATH aufnehmen. Ich habe nur die JAR-Datei servlet-api.jar eingefügt, da ich keine andere Bibliothek im Hello World-Programm verwende.

Diese Befehlszeile verwendet den integrierten Javac-Compiler, der mit dem Sun Microsystems Java Software Development Kit (JDK) geliefert wird. Damit dieser Befehl ordnungsgemäß funktioniert, müssen Sie den Speicherort des von Ihnen verwendeten Java SDK in die Umgebungsvariable PATH aufnehmen.

Wenn alles gut geht, würde die obige Zusammenstellung produzieren HelloWorld.classDatei im selben Verzeichnis. Im nächsten Abschnitt wird erläutert, wie ein kompiliertes Servlet in der Produktion bereitgestellt wird.

Servlet-Bereitstellung

Standardmäßig befindet sich eine Servlet-Anwendung im Pfad <Tomcat-Installationsverzeichnis> / webapps / ROOT, und die Klassendatei befindet sich im <Tomcat-Installationsverzeichnis> / webapps / ROOT / WEB-INF / classes.

Wenn Sie einen vollständig qualifizierten Klassennamen von haben com.myorg.MyServletDann muss sich diese Servlet-Klasse in WEB-INF / classes / com / myorg / MyServlet.class befinden.

Lassen Sie uns zunächst HelloWorld.class in das <Tomcat-Installationsverzeichnis> / webapps / ROOT / WEB-INF / classes kopieren und die folgenden Einträge in erstellen web.xml Datei im Verzeichnis <Tomcat-Installationsverzeichnis> / 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>

Über den Einträgen, die in <web-app> ... </ web-app> -Tags erstellt werden sollen, die in der Datei web.xml verfügbar sind. Es könnten bereits verschiedene Einträge in dieser Tabelle verfügbar sein, aber egal.

Sie sind fast fertig. Lassen Sie uns nun den Tomcat-Server mit <Tomcat-Installationsverzeichnis> \ bin \ startup.bat (unter Windows) oder <Tomcat-Installationsverzeichnis> /bin/startup.sh (unter Linux / Solaris usw.) starten und schließlich eingeben http://localhost:8080/HelloWorldim Adressfeld des Browsers. Wenn alles gut geht, erhalten Sie das folgende Ergebnis

Sie müssen auf viele Situationen gestoßen sein, in denen Sie einige Informationen von Ihrem Browser an den Webserver und letztendlich an Ihr Backend-Programm übergeben müssen. Der Browser verwendet zwei Methoden, um diese Informationen an den Webserver zu übergeben. Diese Methoden sind GET-Methode und POST-Methode.

GET-Methode

Die GET-Methode sendet die codierten Benutzerinformationen, die an die Seitenanforderung angehängt sind. Die Seite und die verschlüsselten Informationen werden durch die getrennt? (Fragezeichen) Symbol wie folgt -

http://www.test.com/hello?key1 = value1&key2 = value2

Die GET-Methode ist die Standardmethode zum Übergeben von Informationen vom Browser an den Webserver und erzeugt eine lange Zeichenfolge, die im Feld Speicherort: Ihres Browsers angezeigt wird. Verwenden Sie niemals die GET-Methode, wenn Sie ein Kennwort oder andere vertrauliche Informationen haben, die an den Server übergeben werden sollen. Die GET-Methode hat eine Größenbeschränkung: In einer Anforderungszeichenfolge können nur 1024 Zeichen verwendet werden.

Diese Informationen werden mithilfe des QUERY_STRING-Headers übergeben und sind über die Umgebungsvariable QUERY_STRING zugänglich. Servlet verarbeitet diese Art von Anforderungen mithilfe von doGet() Methode.

POST-Methode

Eine allgemein zuverlässigere Methode zum Übergeben von Informationen an ein Backend-Programm ist die POST-Methode. Dadurch werden die Informationen genauso verpackt wie bei der GET-Methode, jedoch nicht als Textzeichenfolge nach einem? (Fragezeichen) in der URL, die es als separate Nachricht sendet. Diese Nachricht wird in Form der Standardeingabe an das Backend-Programm gesendet, die Sie analysieren und für Ihre Verarbeitung verwenden können. Servlet verarbeitet diese Art von Anforderungen mitdoPost() Methode.

Lesen von Formulardaten mit Servlet

Servlets verarbeiten das Parsen von Formulardaten je nach Situation automatisch mit den folgenden Methoden:

  • getParameter() - Sie rufen die Methode request.getParameter () auf, um den Wert eines Formularparameters abzurufen.

  • getParameterValues() - Rufen Sie diese Methode auf, wenn der Parameter mehrmals angezeigt wird und mehrere Werte zurückgibt, z. B. das Kontrollkästchen.

  • getParameterNames() - Rufen Sie diese Methode auf, wenn Sie eine vollständige Liste aller Parameter in der aktuellen Anforderung wünschen.

Beispiel für eine GET-Methode unter Verwendung einer URL

Hier ist eine einfache URL, die mit der GET-Methode zwei Werte an das HelloForm-Programm übergibt.

http://localhost:8080/HelloForm?first_name = ZARA&last_name = ALI

Unten ist die angegeben HelloForm.javaServlet-Programm für Eingaben vom Webbrowser. Wir werden verwendengetParameter() Methode, die den Zugriff auf übergebene Informationen sehr einfach macht -

// 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>"
      );
   }
}

Vorausgesetzt, Ihre Umgebung ist ordnungsgemäß eingerichtet, kompilieren Sie HelloForm.java wie folgt:

$ javac HelloForm.java

Wenn alles gut geht, würde die obige Zusammenstellung produzieren HelloForm.classDatei. Als nächstes müssten Sie diese Klassendatei in <Tomcat-Installationsverzeichnis> / webapps / ROOT / WEB-INF / classes kopieren und die folgenden Einträge in erstellenweb.xml Datei im Verzeichnis <Tomcat-Installationsverzeichnis> / 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>

Geben Sie nun http: // localhost: 8080 / HelloForm? First_name = ZARA & last_name = ALI in das Feld Location: Ihres Browsers ein und stellen Sie sicher, dass Sie den Tomcat-Server bereits gestartet haben, bevor Sie den obigen Befehl im Browser auslösen . Dies würde folgendes Ergebnis erzeugen -

Using GET Method to Read Form Data

  • First Name: ZARA
  • Last Name: ALI

Beispiel für eine GET-Methode mit Formular

Hier ist ein einfaches Beispiel, das zwei Werte mit HTML FORM und der Schaltfläche "Senden" übergibt. Wir werden dasselbe Servlet HelloForm verwenden, um diese Eingabe zu verarbeiten.

<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>

Bewahren Sie diesen HTML-Code in einer Datei Hello.htm auf und legen Sie ihn im Verzeichnis <Tomcat-Installationsverzeichnis> / webapps / ROOT ab. Wenn Sie auf http: // localhost: 8080 / Hello.htm zugreifen würden , sehen Sie hier die tatsächliche Ausgabe des obigen Formulars.

Versuchen Sie, Vor- und Nachnamen einzugeben, und klicken Sie dann auf die Schaltfläche Senden, um das Ergebnis auf Ihrem lokalen Computer anzuzeigen, auf dem Tomcat ausgeführt wird. Basierend auf der bereitgestellten Eingabe wird ein ähnliches Ergebnis wie im obigen Beispiel generiert.

Beispiel für eine POST-Methode mit Formular

Lassen Sie uns das obige Servlet nur geringfügig ändern, damit es sowohl GET- als auch POST-Methoden verarbeiten kann. Drunter istHelloForm.java Servlet-Programm zur Verarbeitung von Eingaben, die vom Webbrowser mithilfe von GET- oder POST-Methoden gegeben werden.

// 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);
   }
}

Kompilieren und implementieren Sie nun das obige Servlet und testen Sie es mit Hello.htm mit der POST-Methode wie folgt:

<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>

Hier ist die tatsächliche Ausgabe des obigen Formulars. Versuchen Sie, Vor- und Nachnamen einzugeben, und klicken Sie dann auf die Schaltfläche Senden, um das Ergebnis auf Ihrem lokalen Computer anzuzeigen, auf dem Tomcat ausgeführt wird.

Basierend auf der bereitgestellten Eingabe würde es ein ähnliches Ergebnis erzeugen, wie in den obigen Beispielen erwähnt.

Übergeben von Checkbox-Daten an das Servlet-Programm

Kontrollkästchen werden verwendet, wenn mehr als eine Option ausgewählt werden muss.

Hier ist der HTML-Beispielcode CheckBox.htm für ein Formular mit zwei Kontrollkästchen

<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>

Das Ergebnis dieses Codes ist das folgende Formular

Im Folgenden finden Sie das Servlet-Programm CheckBox.java, mit dem Eingaben des Webbrowsers für die Schaltfläche zum Aktivieren des Kontrollkästchens verarbeitet werden.

// 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);
   }
}

Für das obige Beispiel würde folgendes Ergebnis angezeigt:

Reading Checkbox Data

  • Maths Flag : : on
  • Physics Flag: : null
  • Chemistry Flag: : on

Alle Formularparameter lesen

Es folgt das allgemeine Beispiel, das verwendet wird getParameterNames()Methode von HttpServletRequest zum Lesen aller verfügbaren Formularparameter. Diese Methode gibt eine Aufzählung zurück, die die Parameternamen in einer nicht angegebenen Reihenfolge enthält

Sobald wir eine Aufzählung haben, können wir die Aufzählung auf standardmäßige Weise durchlaufen , indem wir die hasMoreElements () -Methode verwenden, um zu bestimmen, wann gestoppt werden soll, und die nextElement () -Methode verwenden, um jeden Parameternamen abzurufen .

// 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);
   }
}

Versuchen Sie nun das obige Servlet mit dem folgenden Formular:

<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>

Wenn Sie nun ein Servlet mit dem obigen Formular aufrufen, wird das folgende Ergebnis generiert:

Reading All Form Parameters

Param Name Param Value(s)
maths on
chemistry on

Sie können das obige Servlet versuchen, um die Daten eines anderen Formulars mit anderen Objekten wie Textfeld, Optionsfeld oder Dropdown-Feld usw. zu lesen.

Wenn ein Browser eine Webseite anfordert, sendet er viele Informationen an den Webserver, die nicht direkt gelesen werden können, da diese Informationen als Teil des Headers der HTTP-Anforderung übertragen werden. Weitere Informationen hierzu finden Sie im HTTP-Protokoll .

Im Folgenden finden Sie wichtige Header-Informationen, die von der Browserseite stammen und die Sie in der Webprogrammierung sehr häufig verwenden würden.

Sr.Nr. Header & Beschreibung
1

Accept

Dieser Header gibt die MIME-Typen an, die der Browser oder andere Clients verarbeiten können. Werte vonimage/png oder image/jpeg sind die beiden häufigsten Möglichkeiten.

2

Accept-Charset

Diese Überschrift gibt die Zeichensätze an, mit denen der Browser die Informationen anzeigen kann. Zum Beispiel ISO-8859-1.

3

Accept-Encoding

Dieser Header gibt die Arten von Codierungen an, mit denen der Browser umgehen kann. Werte vongzip oder compress sind die beiden häufigsten Möglichkeiten.

4

Accept-Language

Dieser Header gibt die bevorzugten Sprachen des Clients an, falls das Servlet Ergebnisse in mehr als einer Sprache liefern kann. Zum Beispiel en, en-us, ru usw.

5

Authorization

Dieser Header wird von Clients verwendet, um sich beim Zugriff auf kennwortgeschützte Webseiten zu identifizieren.

6

Connection

Dieser Header gibt an, ob der Client dauerhafte HTTP-Verbindungen verarbeiten kann. Durch dauerhafte Verbindungen kann der Client oder ein anderer Browser mehrere Dateien mit einer einzigen Anforderung abrufen. Ein Wert vonKeep-Alive bedeutet, dass dauerhafte Verbindungen verwendet werden sollten.

7

Content-Length

Dieser Header gilt nur für POST-Anforderungen und gibt die Größe der POST-Daten in Byte an.

8

Cookie

Dieser Header gibt Cookies an Server zurück, die sie zuvor an den Browser gesendet haben.

9

Host

Dieser Header gibt den Host und den Port an, wie in der ursprünglichen URL angegeben.

10

If-Modified-Since

Dieser Header gibt an, dass der Client die Seite nur dann möchte, wenn sie nach dem angegebenen Datum geändert wurde. Der Server sendet einen Code, 304 was bedeutetNot Modified Header, wenn kein neueres Ergebnis verfügbar ist.

11

If-Unmodified-Since

Dieser Header ist die Umkehrung von If-Modified-Since. Es gibt an, dass der Vorgang nur erfolgreich sein soll, wenn das Dokument älter als das angegebene Datum ist.

12

Referer

Dieser Header gibt die URL der verweisenden Webseite an. Wenn Sie sich beispielsweise auf Webseite 1 befinden und auf einen Link zu Webseite 2 klicken, wird die URL von Webseite 1 in den Referrer-Header aufgenommen, wenn der Browser Webseite 2 anfordert.

13

User-Agent

Dieser Header identifiziert den Browser oder einen anderen Client, der die Anforderung stellt, und kann verwendet werden, um unterschiedliche Inhalte an verschiedene Browsertypen zurückzugeben.

Methoden zum Lesen des HTTP-Headers

Es gibt folgende Methoden, mit denen Sie den HTTP-Header in Ihrem Servlet-Programm lesen können. Diese Methoden sind mit dem HttpServletRequest- Objekt verfügbar

Sr.Nr. Methode & Beschreibung
1

Cookie[] getCookies()

Gibt ein Array zurück, das alle Cookie-Objekte enthält, die der Client mit dieser Anforderung gesendet hat.

2

Enumeration getAttributeNames()

Gibt eine Aufzählung zurück, die die Namen der Attribute enthält, die für diese Anforderung verfügbar sind.

3

Enumeration getHeaderNames()

Gibt eine Aufzählung aller in dieser Anforderung enthaltenen Headernamen zurück.

4

Enumeration getParameterNames()

Gibt eine Aufzählung von String-Objekten zurück, die die Namen der in dieser Anforderung enthaltenen Parameter enthalten

5

HttpSession getSession()

Gibt die aktuelle Sitzung zurück, die dieser Anforderung zugeordnet ist, oder erstellt eine Sitzung, wenn die Anforderung keine Sitzung enthält.

6

HttpSession getSession(boolean create)

Gibt die aktuelle HttpSession zurück, die dieser Anforderung zugeordnet ist, oder gibt eine neue Sitzung zurück, wenn keine aktuelle Sitzung vorhanden ist und der Wert von create true ist.

7

Locale getLocale()

Gibt das bevorzugte Gebietsschema zurück, in dem der Client Inhalte akzeptiert, basierend auf dem Header "Accept-Language".

8

Object getAttribute(String name)

Gibt den Wert des benannten Attributs als Objekt zurück oder null, wenn kein Attribut des angegebenen Namens vorhanden ist.

9

ServletInputStream getInputStream()

Ruft den Hauptteil der Anforderung mithilfe eines ServletInputStream als Binärdaten ab.

10

String getAuthType()

Gibt den Namen des Authentifizierungsschemas zurück, das zum Schutz des Servlets verwendet wird, z. B. "BASIC" oder "SSL" oder null, wenn die JSP nicht geschützt war.

11

String getCharacterEncoding()

Gibt den Namen der Zeichencodierung zurück, die im Hauptteil dieser Anforderung verwendet wird.

12

String getContentType()

Gibt den MIME-Typ des Hauptteils der Anforderung zurück oder null, wenn der Typ nicht bekannt ist.

13

String getContextPath()

Gibt den Teil des Anforderungs-URI zurück, der den Kontext der Anforderung angibt.

14

String getHeader(String name)

Gibt den Wert des angegebenen Anforderungsheaders als String zurück.

15

String getMethod()

Gibt den Namen der HTTP-Methode zurück, mit der diese Anforderung gestellt wurde, z. B. GET, POST oder PUT.

16

String getParameter(String name)

Gibt den Wert eines Anforderungsparameters als Zeichenfolge zurück oder null, wenn der Parameter nicht vorhanden ist.

17

String getPathInfo()

Gibt alle zusätzlichen Pfadinformationen zurück, die der URL zugeordnet sind, die der Client bei dieser Anforderung gesendet hat

18

String getProtocol()

Gibt den Namen und die Version des Protokolls der Anforderung zurück.

19

String getQueryString()

Gibt die Abfragezeichenfolge zurück, die in der Anforderungs-URL nach dem Pfad enthalten ist.

20

String getRemoteAddr()

Gibt die IP-Adresse (Internet Protocol) des Clients zurück, der die Anforderung gesendet hat.

21

String getRemoteHost()

Gibt den vollständig qualifizierten Namen des Clients zurück, der die Anforderung gesendet hat.

22

String getRemoteUser()

Gibt die Anmeldung des Benutzers zurück, der diese Anforderung stellt, wenn der Benutzer authentifiziert wurde, oder null, wenn der Benutzer nicht authentifiziert wurde.

23

String getRequestURI()

Gibt den Teil der URL dieser Anforderung vom Protokollnamen bis zur Abfragezeichenfolge in der ersten Zeile der HTTP-Anforderung zurück.

24

String getRequestedSessionId()

Gibt die vom Client angegebene Sitzungs-ID zurück.

25

String getServletPath()

Gibt den Teil der URL dieser Anforderung zurück, der die JSP aufruft.

26

String[] getParameterValues(String name)

Gibt ein Array von String-Objekten zurück, die alle Werte des angegebenen Anforderungsparameters enthalten, oder null, wenn der Parameter nicht vorhanden ist.

27

boolean isSecure()

Gibt einen Booleschen Wert zurück, der angibt, ob diese Anforderung über einen sicheren Kanal wie HTTPS gestellt wurde.

28

int getContentLength()

Gibt die Länge des Anforderungshauptteils in Byte zurück, die vom Eingabestream zur Verfügung gestellt wird, oder -1, wenn die Länge nicht bekannt ist.

29

int getIntHeader(String name)

Gibt den Wert des angegebenen Anforderungsheaders als int zurück.

30

int getServerPort()

Gibt die Portnummer zurück, an der diese Anforderung empfangen wurde.

Beispiel für eine HTTP-Header-Anforderung

Es folgt das verwendete Beispiel getHeaderNames()Methode von HttpServletRequest zum Lesen der HTTP-Header-Informationen. Diese Methode gibt eine Aufzählung zurück, die die Headerinformationen enthält, die der aktuellen HTTP-Anforderung zugeordnet sind.

Sobald wir eine Aufzählung haben, können wir die Aufzählung auf standardmäßige Weise durchlaufen , indem wir die hasMoreElements () -Methode verwenden, um zu bestimmen, wann gestoppt werden soll, und die nextElement () -Methode verwenden, um jeden Parameternamen abzurufen

// 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);
   }
}

Wenn Sie nun das obige Servlet aufrufen, wird das folgende Ergebnis generiert:

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

Wie im vorherigen Kapitel erläutert, besteht die Antwort in der Regel aus einer Statuszeile, einigen Antwortheadern, einer Leerzeile und dem Dokument, wenn ein Webserver auf eine HTTP-Anforderung antwortet. Eine typische Antwort sieht so aus -

HTTP/1.1 200 OK
Content-Type: text/html
Header2: ...
...
HeaderN: ...
   (Blank Line)
<!doctype ...>
<html>
   <head>...</head>
   <body>
      ...
   </body>
</html>

Die Statuszeile besteht aus der HTTP-Version (im Beispiel HTTP / 1.1), einem Statuscode (im Beispiel 200) und einer sehr kurzen Nachricht, die dem Statuscode entspricht (im Beispiel OK).

Im Folgenden finden Sie eine Zusammenfassung der nützlichsten HTTP 1.1-Antwortheader, die von der Webserverseite zum Browser zurückkehren und bei der Webprogrammierung sehr häufig verwendet werden.

Sr.Nr. Header & Beschreibung
1

Allow

Dieser Header gibt die Anforderungsmethoden (GET, POST usw.) an, die der Server unterstützt.

2

Cache-Control

Dieser Header gibt die Umstände an, unter denen das Antwortdokument sicher zwischengespeichert werden kann. Es kann Werte habenpublic, private oder no-cache usw. Öffentlich bedeutet, dass das Dokument zwischengespeichert werden kann. Privat bedeutet, dass das Dokument für einen einzelnen Benutzer bestimmt ist und nur in privaten (nicht freigegebenen) Caches gespeichert werden kann. Nocache bedeutet, dass das Dokument niemals zwischengespeichert werden sollte.

3

Connection

Dieser Header weist den Browser an, ob er in HTTP-Verbindungen dauerhaft verwendet werden soll oder nicht. Ein Wert vonclose weist den Browser an, keine dauerhaften HTTP-Verbindungen zu verwenden und keepalive bedeutet, dauerhafte Verbindungen zu verwenden.

4

Content-Disposition

In diesem Header können Sie den Benutzer auffordern, die Antwort auf der Festplatte in einer Datei mit dem angegebenen Namen zu speichern.

5

Content-Encoding

Dieser Header gibt an, wie die Seite während der Übertragung codiert wurde.

6

Content-Language

Diese Überschrift gibt die Sprache an, in der das Dokument geschrieben ist. Zum Beispiel en, en-us, ru usw.

7

Content-Length

Dieser Header gibt die Anzahl der Bytes in der Antwort an. Diese Informationen werden nur benötigt, wenn der Browser eine dauerhafte (Keep-Alive-) HTTP-Verbindung verwendet.

8

Content-Type

Dieser Header gibt den MIME-Typ (Multipurpose Internet Mail Extension) des Antwortdokuments an.

9

Expires

Dieser Header gibt den Zeitpunkt an, zu dem der Inhalt als veraltet betrachtet und somit nicht mehr zwischengespeichert werden soll.

10

Last-Modified

Diese Kopfzeile gibt an, wann das Dokument zuletzt geändert wurde. Der Client kann dann das Dokument zwischenspeichern und ein Datum von einem angebenIf-Modified-Since Anforderungsheader in späteren Anforderungen.

11

Location

Dieser Header sollte in allen Antworten enthalten sein, die in den 300er Jahren einen Statuscode haben. Dies benachrichtigt den Browser über die Dokumentadresse. Der Browser stellt automatisch wieder eine Verbindung zu diesem Speicherort her und ruft das neue Dokument ab.

12

Refresh

Dieser Header gibt an, wann der Browser nach einer aktualisierten Seite fragen soll. Sie können die Zeit in Sekunden angeben, nach der eine Seite aktualisiert werden soll.

13

Retry-After

Dieser Header kann in Verbindung mit einer 503-Antwort (Service Unavailable) verwendet werden, um dem Client mitzuteilen, wann er seine Anforderung wiederholen kann.

14

Set-Cookie

Dieser Header gibt ein Cookie an, das der Seite zugeordnet ist.

Methoden zum Festlegen des HTTP-Antwortheaders

Es gibt folgende Methoden, mit denen Sie den HTTP-Antwortheader in Ihrem Servlet-Programm festlegen können. Diese Methoden sind mit dem HttpServletResponse- Objekt verfügbar .

Sr.Nr. Methode & Beschreibung
1

String encodeRedirectURL(String url)

Codiert die angegebene URL zur Verwendung in der sendRedirect-Methode oder gibt die URL unverändert zurück, wenn keine Codierung erforderlich ist.

2

String encodeURL(String url)

Codiert die angegebene URL, indem die Sitzungs-ID darin enthalten ist, oder gibt die URL unverändert zurück, wenn keine Codierung erforderlich ist.

3

boolean containsHeader(String name)

Gibt einen Booleschen Wert zurück, der angibt, ob der benannte Antwortheader bereits festgelegt wurde.

4

boolean isCommitted()

Gibt einen Booleschen Wert zurück, der angibt, ob die Antwort festgeschrieben wurde.

5

void addCookie(Cookie cookie)

Fügt der Antwort das angegebene Cookie hinzu.

6

void addDateHeader(String name, long date)

Fügt einen Antwortheader mit dem angegebenen Namen und Datumswert hinzu.

7

void addHeader(String name, String value)

Fügt einen Antwortheader mit dem angegebenen Namen und Wert hinzu.

8

void addIntHeader(String name, int value)

Fügt einen Antwortheader mit dem angegebenen Namen und dem ganzzahligen Wert hinzu.

9

void flushBuffer()

Erzwingt das Schreiben von Inhalten im Puffer in den Client.

10

void reset()

Löscht alle im Puffer vorhandenen Daten sowie den Statuscode und die Header.

11

void resetBuffer()

Löscht den Inhalt des zugrunde liegenden Puffers in der Antwort, ohne Header oder Statuscode zu löschen.

12

void sendError(int sc)

Sendet eine Fehlerantwort an den Client unter Verwendung des angegebenen Statuscodes und Löschen des Puffers.

13

void sendError(int sc, String msg)

Sendet eine Fehlerantwort an den Client mit dem angegebenen Status.

14

void sendRedirect(String location)

Sendet eine temporäre Umleitungsantwort an den Client unter Verwendung der angegebenen URL für den Umleitungsspeicherort.

15

void setBufferSize(int size)

Legt die bevorzugte Puffergröße für den Hauptteil der Antwort fest.

16

void setCharacterEncoding(String charset)

Legt die Zeichenkodierung (MIME-Zeichensatz) der Antwort fest, die an den Client gesendet wird, z. B. an UTF-8.

17

void setContentLength(int len)

Legt die Länge des Inhaltskörpers in der Antwort fest. In HTTP-Servlets legt diese Methode den HTTP-Header für die Inhaltslänge fest.

18

void setContentType(String type)

Legt den Inhaltstyp der Antwort fest, die an den Client gesendet wird, wenn die Antwort noch nicht festgeschrieben wurde.

19

void setDateHeader(String name, long date)

Legt einen Antwortheader mit dem angegebenen Namen und Datumswert fest.

20

void setHeader(String name, String value)

Legt einen Antwortheader mit dem angegebenen Namen und Wert fest.

21

void setIntHeader(String name, int value)

Legt einen Antwortheader mit dem angegebenen Namen und dem ganzzahligen Wert fest

22

void setLocale(Locale loc)

Legt das Gebietsschema der Antwort fest, wenn die Antwort noch nicht festgeschrieben wurde.

23

void setStatus(int sc)

Legt den Statuscode für diese Antwort fest

Beispiel für eine HTTP-Header-Antwort

Sie haben bereits gesehen, dass die Methode setContentType () in den vorherigen Beispielen funktioniert, und das folgende Beispiel würde dieselbe Methode verwenden, zusätzlich würden wir sie verwenden setIntHeader() Methode zum Einstellen Refresh Header.

// 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);
   }
}

Wenn Sie nun das obige Servlet aufrufen, wird die aktuelle Systemzeit alle 5 Sekunden wie folgt angezeigt. Führen Sie einfach das Servlet aus und warten Sie, bis das Ergebnis angezeigt wird.

Auto Refresh Header Setting

Current Time is: 9:44:50 PM

Das Format der HTTP-Anforderungs- und HTTP-Antwortnachrichten ist ähnlich und hat folgende Struktur:

  • Eine anfängliche Statuszeile + CRLF (Wagenrücklauf + Zeilenvorschub, dh neue Zeile)

  • Keine oder mehr Kopfzeilen + CRLF

  • Eine leere Zeile, dh eine CRLF

  • Ein optionaler Nachrichtentext wie Datei, Abfragedaten oder Abfrageausgabe.

Ein Server-Antwortheader sieht beispielsweise wie folgt aus:

HTTP/1.1 200 OK
Content-Type: text/html
Header2: ...
...
HeaderN: ...
   (Blank Line)
<!doctype ...>
<html>
   <head>...</head>
   <body>
      ...
   </body>
</html>

Die Statuszeile besteht aus der HTTP-Version (im Beispiel HTTP / 1.1), einem Statuscode (im Beispiel 200) und einer sehr kurzen Nachricht, die dem Statuscode entspricht (im Beispiel OK).

Im Folgenden finden Sie eine Liste der HTTP-Statuscodes und der zugehörigen Nachrichten, die möglicherweise vom Webserver zurückgegeben werden.

Code Botschaft Beschreibung
100 Fortsetzen Nur ein Teil der Anfrage wurde vom Server empfangen. Solange sie nicht abgelehnt wurde, sollte der Client mit der Anfrage fortfahren
101 Protokolle wechseln Der Server wechselt das Protokoll.
200 in Ordnung Die Anfrage ist OK
201 Erstellt Die Anforderung ist abgeschlossen und eine neue Ressource wird erstellt
202 Akzeptiert Die Anforderung wird zur Verarbeitung angenommen, die Verarbeitung ist jedoch nicht abgeschlossen.
203 Nicht maßgebliche Informationen  
204 Kein Inhalt  
205 Inhalt zurücksetzen  
206 Teilinhalt  
300 Mehrere Auswahlmöglichkeiten Eine Linkliste. Der Benutzer kann einen Link auswählen und zu diesem Ort gehen. Maximal fünf Adressen
301 dauerhaft umgezogen Die angeforderte Seite wurde in eine neue URL verschoben
302 Gefunden Die angeforderte Seite wurde vorübergehend in eine neue URL verschoben
303 Siehe Andere Die angeforderte Seite befindet sich unter einer anderen URL
304 Nicht modifiziert  
305 Verwenden Sie Proxy  
306 Ungebraucht Dieser Code wurde in einer früheren Version verwendet. Es wird nicht mehr verwendet, aber der Code ist reserviert
307 Temporäre Weiterleitung Die angeforderte Seite wurde vorübergehend in eine neue URL verschoben.
400 Ungültige Anforderung Der Server hat die Anfrage nicht verstanden
401 Nicht autorisiert Die angeforderte Seite benötigt einen Benutzernamen und ein Passwort
402 Bezahlung erforderlich Sie können diesen Code noch nicht verwenden
403 verboten Der Zugriff auf die angeforderte Seite ist verboten
404 Nicht gefunden Der Server kann die angeforderte Seite nicht finden.
405 Methode nicht erlaubt Die in der Anfrage angegebene Methode ist nicht zulässig.
406 Inakzeptabel Der Server kann nur eine Antwort generieren, die vom Client nicht akzeptiert wird.
407 Proxy-Authentifizierung erforderlich Sie müssen sich bei einem Proxyserver authentifizieren, bevor diese Anforderung bearbeitet werden kann.
408 Zeitüberschreitung der Anforderung Die Anfrage dauerte länger als der Server bereit war zu warten.
409 Konflikt Die Anforderung konnte aufgrund eines Konflikts nicht abgeschlossen werden.
410 Weg Die angeforderte Seite ist nicht mehr verfügbar.
411 Länge erforderlich Die "Inhaltslänge" ist nicht definiert. Der Server akzeptiert die Anfrage ohne sie nicht.
412 Voraussetzung fehlgeschlagen Die in der Anforderung angegebene Voraussetzung wird vom Server als falsch bewertet.
413 Anfrage Entität zu groß Der Server akzeptiert die Anforderung nicht, da die Anforderungsentität zu groß ist.
414 Anfrage-URL zu lang Der Server akzeptiert die Anforderung nicht, da die URL zu lang ist. Tritt auf, wenn Sie eine "Post" -Anforderung in eine "Get" -Anforderung mit langen Abfrageinformationen konvertieren.
415 Nicht unterstützter Medientyp Der Server akzeptiert die Anforderung nicht, da der Medientyp nicht unterstützt wird.
417 Erwartung fehlgeschlagen  
500 interner Serverfehler Die Anfrage wurde nicht abgeschlossen. Der Server hat eine unerwartete Bedingung erfüllt.
501 Nicht implementiert Die Anfrage wurde nicht abgeschlossen. Der Server hat die erforderliche Funktionalität nicht unterstützt.
502 Schlechtes Gateway Die Anfrage wurde nicht abgeschlossen. Der Server hat eine ungültige Antwort vom Upstream-Server erhalten.
503 Dienst nicht verfügbar Die Anfrage wurde nicht abgeschlossen. Der Server ist vorübergehend überlastet oder ausgefallen.
504 Gateway-Zeitüberschreitung Das Gateway hat eine Zeitüberschreitung.
505 HTTP-Version wird nicht unterstützt Der Server unterstützt die Version "http protocol" nicht.

Methoden zum Festlegen des HTTP-Statuscodes

Die folgenden Methoden können verwendet werden, um den HTTP-Statuscode in Ihrem Servlet-Programm festzulegen. Diese Methoden sind mit dem HttpServletResponse- Objekt verfügbar .

Sr.Nr. Methode & Beschreibung
1

public void setStatus ( int statusCode )

Diese Methode legt einen beliebigen Statuscode fest. Die setStatus-Methode verwendet ein int (den Statuscode) als Argument. Wenn Ihre Antwort einen speziellen Statuscode und ein Dokument enthält, rufen Sie setStatus auf, bevor Sie den Inhalt mit dem PrintWriter zurückgeben .

2

public void sendRedirect(String url)

Diese Methode generiert eine 302-Antwort zusammen mit einem Standortkopf , der die URL des neuen Dokuments angibt

3

public void sendError(int code, String message)

Diese Methode sendet einen Statuscode (normalerweise 404) zusammen mit einer Kurznachricht, die automatisch in einem HTML-Dokument formatiert und an den Client gesendet wird.

Beispiel für einen HTTP-Statuscode

Das folgende Beispiel sendet einen 407-Fehlercode an den Client-Browser und der Browser zeigt "Authentifizierung erforderlich !!!" an. Botschaft.

// 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);
   }
}

Wenn Sie nun das obige Servlet aufrufen, wird das folgende Ergebnis angezeigt:

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

Servlet-Filter sind Java-Klassen, die in der Servlet-Programmierung für die folgenden Zwecke verwendet werden können:

  • Abfangen von Anforderungen von einem Client, bevor dieser auf eine Ressource im Back-End zugreift.

  • So bearbeiten Sie Antworten vom Server, bevor sie an den Client zurückgesendet werden.

Es gibt verschiedene Arten von Filtern, die in den Spezifikationen vorgeschlagen werden -

  • Authentifizierungsfilter.
  • Datenkomprimierungsfilter.
  • Verschlüsselungsfilter.
  • Filter, die Ressourcenzugriffsereignisse auslösen.
  • Bildkonvertierungsfilter.
  • Protokollieren und Überwachen von Filtern.
  • MIME-TYPE-Kettenfilter.
  • Tokenisieren von Filtern.
  • XSL / T-Filter, die XML-Inhalte transformieren.

Filter werden in der Bereitstellungsdeskriptordatei bereitgestellt web.xml und ordnen Sie dann entweder Servlet-Namen oder URL-Mustern im Deployment-Deskriptor Ihrer Anwendung zu.

Wenn der Webcontainer Ihre Webanwendung startet, erstellt er eine Instanz jedes Filters, den Sie im Bereitstellungsdeskriptor deklariert haben. Die Filter werden in der Reihenfolge ausgeführt, in der sie im Bereitstellungsdeskriptor deklariert sind.

Servlet-Filtermethoden

Ein Filter ist einfach eine Java-Klasse, die die Schnittstelle javax.servlet.Filter implementiert. Die Schnittstelle javax.servlet.Filter definiert drei Methoden:

Sr.Nr. Methode & Beschreibung
1

public void doFilter (ServletRequest, ServletResponse, FilterChain)

Diese Methode wird vom Container jedes Mal aufgerufen, wenn ein Anforderungs- / Antwortpaar aufgrund einer Clientanforderung für eine Ressource am Ende der Kette durch die Kette geleitet wird.

2

public void init(FilterConfig filterConfig)

Diese Methode wird vom Webcontainer aufgerufen, um einem Filter anzuzeigen, dass er in Betrieb genommen wird.

3

public void destroy()

Diese Methode wird vom Webcontainer aufgerufen, um einem Filter anzuzeigen, dass er außer Betrieb genommen wird.

Servlet-Filter - Beispiel

Im Folgenden finden Sie das Servlet-Filter-Beispiel, mit dem die IP-Adresse des Clients und die aktuelle Datums- und Uhrzeitangabe gedruckt werden. Dieses Beispiel vermittelt Ihnen ein grundlegendes Verständnis des Servlet-Filters. Sie können jedoch komplexere Filteranwendungen mit demselben Konzept schreiben:

// 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*/
   }
}

Kompilieren LogFilter.java wie gewohnt und legen Sie Ihre Klassendatei in <Tomcat-Installationsverzeichnis> / webapps / ROOT / WEB-INF / classes ab

Servlet-Filterzuordnung in Web.xml

Filter werden definiert und dann einer URL oder einem Servlet zugeordnet, ähnlich wie Servlet definiert und dann einem URL-Muster zugeordnet wird. Erstellen Sie den folgenden Eintrag für das Filter-Tag in der Deployment-Deskriptordateiweb.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>

Der obige Filter würde für alle Servlets gelten, da wir angegeben haben /*in unserer Konfiguration. Sie können einen bestimmten Servlet-Pfad angeben, wenn Sie Filter nur auf wenige Servlets anwenden möchten.

Versuchen Sie nun, ein Servlet wie gewohnt aufzurufen, und Sie sehen das generierte Protokoll in Ihrem Webserver-Protokoll. Sie können den Log4J-Logger verwenden, um sich über dem Protokoll in einer separaten Datei anzumelden.

Verwenden mehrerer Filter

Ihre Webanwendung kann mehrere verschiedene Filter für einen bestimmten Zweck definieren. Stellen Sie sich vor, Sie definieren zwei Filter, AuthenFilter und LogFilter . Der Rest des Prozesses bleibt wie oben erläutert, außer dass Sie eine andere Zuordnung erstellen müssen, wie unten erwähnt.

<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>

Filter Anwendungsreihenfolge

Die Reihenfolge der Filterzuordnungselemente in web.xml bestimmt die Reihenfolge, in der der Webcontainer den Filter auf das Servlet anwendet. Um die Reihenfolge des Filters umzukehren, müssen Sie nur die Filterzuordnungselemente in der Datei web.xml umkehren.

Das obige Beispiel würde beispielsweise zuerst LogFilter und dann AuthenFilter auf jedes Servlet anwenden, aber das folgende Beispiel würde die Reihenfolge umkehren -

<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>

Wenn ein Servlet eine Ausnahme auslöst, durchsucht der Webcontainer die Konfigurationen in web.xml die das Element vom Ausnahmetyp für eine Übereinstimmung mit dem ausgelösten Ausnahmetyp verwenden.

Sie müssten die verwenden error-page Element in web.xml, um den Aufruf von Servlets als Antwort auf bestimmte zu spezifizieren exceptions oder HTTP status codes.

web.xml Konfiguration

Angenommen , Sie haben ein ErrorHandler- Servlet, das aufgerufen wird, wenn eine definierte Ausnahme oder ein Fehler definiert ist. Es folgt der Eintrag in 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>

Wenn Sie einen generischen Fehlerbehandler für alle Ausnahmen haben möchten, sollten Sie die folgende Fehlerseite definieren, anstatt für jede Ausnahme separate Fehlerseitenelemente zu definieren.

<error-page>
   <exception-type>java.lang.Throwable</exception-type >
   <location>/ErrorHandler</location>
</error-page>

Im Folgenden sind die Punkte aufgeführt, die in der obigen Datei web.xml für die Ausnahmebehandlung zu beachten sind:

  • Das Servlet ErrorHandler wird wie gewohnt wie jedes andere Servlet definiert und in der Datei web.xml konfiguriert.

  • Wenn ein Fehler mit dem Statuscode 404 (Nicht gefunden) oder 403 (Verboten) auftritt, wird das Servlet ErrorHandler aufgerufen.

  • Wenn die Webanwendung entweder ServletException oder IOException auslöst, ruft der Webcontainer das Servlet / ErrorHandler auf.

  • Sie können verschiedene Fehlerbehandlungsroutinen definieren, um verschiedene Arten von Fehlern oder Ausnahmen zu behandeln. Das obige Beispiel ist sehr allgemein gehalten und hofft, dass es dem Zweck dient, Ihnen das Grundkonzept zu erklären.

Anforderungsattribute - Fehler / Ausnahmen

Im Folgenden finden Sie eine Liste der Anforderungsattribute, auf die ein Servlet zur Fehlerbehandlung zugreifen kann, um die Art des Fehlers / der Ausnahme zu analysieren.

Sr.Nr. Attribut & Beschreibung
1

javax.servlet.error.status_code

Dieses Attribut gibt den Statuscode an, der nach dem Speichern in einem Datentyp java.lang.Integer gespeichert und analysiert werden kann.

2

javax.servlet.error.exception_type

Dieses Attribut enthält Informationen zum Ausnahmetyp, die nach dem Speichern in einem Datentyp java.lang.Class gespeichert und analysiert werden können.

3

javax.servlet.error.message

Dieses Attribut gibt eine genaue Fehlermeldung an, die nach dem Speichern in einem java.lang.String-Datentyp gespeichert und analysiert werden kann.

4

javax.servlet.error.request_uri

Dieses Attribut enthält Informationen zur URL, die das Servlet aufruft, und kann nach dem Speichern in einem Datentyp java.lang.String gespeichert und analysiert werden.

5

javax.servlet.error.exception

Dieses Attribut gibt Informationen über die ausgelöste Ausnahme, die gespeichert und analysiert werden können.

6

javax.servlet.error.servlet_name

Dieses Attribut gibt den Servlet-Namen an, der nach dem Speichern in einem java.lang.String-Datentyp gespeichert und analysiert werden kann.

Beispiel für ein Fehlerbehandlungs-Servlet

Dieses Beispiel vermittelt Ihnen ein grundlegendes Verständnis der Ausnahmebehandlung in Servlet. Sie können jedoch komplexere Filteranwendungen mit demselben Konzept schreiben.

// 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);
   }
}

Kompilieren ErrorHandler.java in gewohnter Weise und legen Sie Ihre Klassendatei in / webapps / ROOT / WEB-INF / classes.

Fügen wir die folgende Konfiguration in web.xml hinzu, um Ausnahmen zu behandeln:

<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>

Versuchen Sie nun, ein Servlet zu verwenden, das eine Ausnahme auslöst oder eine falsche URL eingibt. Dies würde den Aufruf von Web Container auslösen ErrorHandlerServlet und zeigen eine entsprechende Meldung wie programmiert an. Wenn Sie beispielsweise eine falsche URL eingeben, wird das folgende Ergebnis angezeigt:

The status code : 404

Der obige Code funktioniert möglicherweise nicht mit einigen Webbrowsern. Versuchen Sie es mit Mozilla und Safari und es sollte funktionieren.

Cookies sind Textdateien, die auf dem Client-Computer gespeichert werden und für verschiedene Zwecke der Informationsverfolgung aufbewahrt werden. Java Servlets unterstützen transparent HTTP-Cookies.

Die Identifizierung wiederkehrender Benutzer umfasst drei Schritte:

  • Das Serverskript sendet eine Reihe von Cookies an den Browser. Zum Beispiel Name, Alter oder Identifikationsnummer usw.

  • Der Browser speichert diese Informationen auf dem lokalen Computer für die zukünftige Verwendung.

  • Wenn der Browser das nächste Mal eine Anfrage an den Webserver sendet, sendet er diese Cookie-Informationen an den Server, und der Server verwendet diese Informationen, um den Benutzer zu identifizieren.

In diesem Kapitel erfahren Sie, wie Sie Cookies setzen oder zurücksetzen, wie Sie darauf zugreifen und wie Sie sie löschen.

Die Anatomie eines Kekses

Cookies werden normalerweise in einem HTTP-Header gesetzt (obwohl JavaScript ein Cookie auch direkt in einem Browser setzen kann). Ein Servlet, das ein Cookie setzt, sendet möglicherweise Header, die ungefähr so ​​aussehen:

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

Wie Sie sehen können, enthält der Set-Cookie-Header ein Name-Wert-Paar, ein GMT-Datum, einen Pfad und eine Domäne. Der Name und der Wert werden URL-codiert. Das Feld expires ist eine Anweisung an den Browser, das Cookie nach der angegebenen Uhrzeit und dem angegebenen Datum zu "vergessen".

Wenn der Browser zum Speichern von Cookies konfiguriert ist, werden diese Informationen bis zum Ablaufdatum gespeichert. Wenn der Benutzer den Browser auf eine Seite verweist, die dem Pfad und der Domäne des Cookies entspricht, sendet er das Cookie erneut an den Server. Die Header des Browsers könnten ungefähr so ​​aussehen -

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

Ein Servlet hat dann über die Anforderungsmethode request.getCookies () Zugriff auf das Cookie, die ein Array von Cookie- Objekten zurückgibt .

Servlet-Cookies-Methoden

Im Folgenden finden Sie eine Liste nützlicher Methoden, die Sie beim Bearbeiten von Cookies im Servlet verwenden können.

Sr.Nr. Methode & Beschreibung
1

public void setDomain(String pattern)

Diese Methode legt die Domäne fest, für die das Cookie gilt, z. B. tutorialspoint.com.

2

public String getDomain()

Diese Methode ruft die Domain ab, für die das Cookie gilt, z. B. tutorialspoint.com.

3

public void setMaxAge(int expiry)

Diese Methode legt fest, wie viel Zeit (in Sekunden) vergehen soll, bevor das Cookie abläuft. Wenn Sie dies nicht festlegen, bleibt das Cookie nur für die aktuelle Sitzung gültig.

4

public int getMaxAge()

Diese Methode gibt das maximale Alter des Cookies in Sekunden zurück. Standardmäßig gibt -1 an, dass das Cookie bis zum Herunterfahren des Browsers bestehen bleibt.

5

public String getName()

Diese Methode gibt den Namen des Cookies zurück. Der Name kann nach der Erstellung nicht mehr geändert werden.

6

public void setValue(String newValue)

Diese Methode legt den Wert fest, der dem Cookie zugeordnet ist

7

public String getValue()

Diese Methode ruft den dem Cookie zugeordneten Wert ab.

8

public void setPath(String uri)

Diese Methode legt den Pfad fest, für den dieses Cookie gilt. Wenn Sie keinen Pfad angeben, wird das Cookie für alle URLs im selben Verzeichnis wie die aktuelle Seite sowie für alle Unterverzeichnisse zurückgegeben.

9

public String getPath()

Diese Methode ruft den Pfad ab, für den dieses Cookie gilt.

10

public void setSecure(boolean flag)

Diese Methode legt den booleschen Wert fest, der angibt, ob das Cookie nur über verschlüsselte (dh SSL) Verbindungen gesendet werden soll.

11

public void setComment(String purpose)

Diese Methode gibt einen Kommentar an, der den Zweck eines Cookies beschreibt. Der Kommentar ist nützlich, wenn der Browser dem Benutzer das Cookie präsentiert.

12

public String getComment()

Diese Methode gibt den Kommentar zurück, der den Zweck dieses Cookies beschreibt, oder null, wenn das Cookie keinen Kommentar enthält.

Cookies mit Servlet setzen

Das Setzen von Cookies mit Servlet umfasst drei Schritte:

(1) Creating a Cookie object - Sie rufen den Cookie-Konstruktor mit einem Cookie-Namen und einem Cookie-Wert auf, die beide Zeichenfolgen sind.

Cookie cookie = new Cookie("key","value");

Beachten Sie, dass weder der Name noch der Wert Leerzeichen oder eines der folgenden Zeichen enthalten dürfen:

[ ] ( ) = , " / ? @ : ;

(2) Setting the maximum age- Mit setMaxAge geben Sie an, wie lange (in Sekunden) das Cookie gültig sein soll. Im Folgenden wird ein Cookie für 24 Stunden eingerichtet.

cookie.setMaxAge(60 * 60 * 24);

(3) Sending the Cookie into the HTTP response headers - Sie verwenden response.addCookie, um Cookies wie folgt in den HTTP-Antwortheader einzufügen. -

response.addCookie(cookie);

Beispiel

Lassen Sie uns unser Formularbeispiel ändern , um die Cookies für Vor- und Nachnamen zu setzen.

// 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>"
      );
   }
}

Kompilieren Sie das obige Servlet HelloForm Erstellen Sie einen entsprechenden Eintrag in der Datei web.xml und versuchen Sie schließlich, der folgenden HTML-Seite zu folgen, um das Servlet aufzurufen.

<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>

Behalten Sie den obigen HTML-Inhalt in einer Datei Hello.htm bei und legen Sie ihn im Verzeichnis <Tomcat-Installationsverzeichnis> / webapps / ROOT ab. Wenn Sie auf http: // localhost: 8080 / Hello.htm zugreifen würden , sehen Sie hier die tatsächliche Ausgabe des obigen Formulars.

Versuchen Sie, Vor- und Nachnamen einzugeben, und klicken Sie dann auf die Schaltfläche Senden. Dies würde Vor- und Nachnamen auf Ihrem Bildschirm anzeigen und gleichzeitig zwei Cookies setzen, Vor- und Nachname, die beim nächsten Drücken der Senden-Taste an den Server zurückgegeben werden.

Im nächsten Abschnitt erfahren Sie, wie Sie in Ihrer Webanwendung wieder auf diese Cookies zugreifen.

Kekse mit Servlet lesen

Um Cookies zu lesen, müssen Sie ein Array von javax.servlet.http.Cookie- Objekten erstellen, indem Sie das aufrufengetCookies()Methode von HttpServletRequest . Durchlaufen Sie dann das Array und verwenden Sie die Methoden getName () und getValue (), um auf jedes Cookie und den zugehörigen Wert zuzugreifen.

Beispiel

Lesen wir die Cookies, die wir im vorherigen Beispiel gesetzt haben -

// 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>");
   }
}

Kompilieren Sie über dem Servlet ReadCookiesund erstellen Sie einen entsprechenden Eintrag in der Datei web.xml. Wenn Sie das Cookie "Vorname" als "John" und das Cookie "Nachname" als "Player" festgelegt hätten, würde beim Ausführen von http: // localhost: 8080 / ReadCookies das folgende Ergebnis angezeigt:

Found Cookies Name and Value

Name : first_name, Value: John
Name : last_name, Value: Player

Cookies mit Servlet löschen

Das Löschen von Cookies ist sehr einfach. Wenn Sie ein Cookie löschen möchten, müssen Sie lediglich die folgenden drei Schritte ausführen:

  • Lesen Sie ein bereits vorhandenes Cookie und speichern Sie es im Cookie-Objekt.

  • Setzen Sie das Cookie-Alter mit auf Null setMaxAge() Methode zum Löschen eines vorhandenen Cookies

  • Fügen Sie dieses Cookie wieder in den Antwortheader ein.

Beispiel

Im folgenden Beispiel wird ein vorhandenes Cookie mit dem Namen "first_name" gelöscht und beim nächsten Ausführen des ReadCookies-Servlets wird der Nullwert für first_name zurückgegeben.

// 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>");
   }
}

Kompilieren Sie über dem Servlet DeleteCookiesund erstellen Sie einen entsprechenden Eintrag in der Datei web.xml. Wenn Sie jetzt http: // localhost: 8080 / DeleteCookies ausführen , wird das folgende Ergebnis angezeigt:

Cookies Name and Value

Deleted cookie : first_name

Name : first_name, Value: John

Name : last_name, Value: Player

Versuchen Sie nun, http: // localhost: 8080 / ReadCookies auszuführen, und es wird nur ein Cookie wie folgt angezeigt:

Found Cookies Name and Value

Name : last_name, Value: Player

Sie können Ihre Cookies im Internet Explorer manuell löschen. Beginnen Sie im Menü Extras und wählen Sie Internetoptionen. Um alle Cookies zu löschen, klicken Sie auf Cookies löschen.

HTTP ist ein "zustandsloses" Protokoll. Dies bedeutet, dass der Client jedes Mal, wenn ein Client eine Webseite abruft, eine separate Verbindung zum Webserver herstellt und der Server automatisch keine Aufzeichnungen über vorherige Clientanforderungen führt.

Es gibt jedoch drei Möglichkeiten, die Sitzung zwischen Webclient und Webserver aufrechtzuerhalten:

Kekse

Ein Webserver kann jedem Webclient eine eindeutige Sitzungs-ID als Cookie zuweisen, und für nachfolgende Anforderungen des Clients können sie anhand des empfangenen Cookies erkannt werden.

Dies ist möglicherweise kein effektiver Weg, da viele Zeitbrowser kein Cookie unterstützen. Daher würde ich nicht empfehlen, dieses Verfahren zur Aufrechterhaltung der Sitzungen zu verwenden.

Versteckte Formularfelder

Ein Webserver kann ein verstecktes HTML-Formularfeld zusammen mit einer eindeutigen Sitzungs-ID wie folgt senden:

<input type = "hidden" name = "sessionid" value = "12345">

Dieser Eintrag bedeutet, dass beim Senden des Formulars der angegebene Name und Wert automatisch in den GET- oder POST-Daten enthalten sind. Jedes Mal, wenn ein Webbrowser eine Anfrage zurücksendet, kann der Wert session_id verwendet werden, um den Überblick über verschiedene Webbrowser zu behalten.

Dies könnte eine effektive Methode sein, um die Sitzung zu verfolgen. Wenn Sie jedoch auf einen regulären (<A HREF...>) Hypertext-Link klicken, wird kein Formular gesendet, sodass ausgeblendete Formularfelder auch die allgemeine Sitzungsverfolgung nicht unterstützen können.

URL-Umschreibung

Sie können am Ende jeder URL, die die Sitzung identifiziert, einige zusätzliche Daten anhängen, und der Server kann diese Sitzungskennung mit Daten verknüpfen, die er über diese Sitzung gespeichert hat.

Bei http://tutorialspoint.com/file.htm;sessionid = 12345 wird die Sitzungskennung beispielsweise als sessionid = 12345 angehängt, auf die auf dem Webserver zugegriffen werden kann, um den Client zu identifizieren.

Das Umschreiben von URLs ist eine bessere Möglichkeit, Sitzungen aufrechtzuerhalten, und funktioniert auch dann, wenn Browser keine Cookies unterstützen. Der Nachteil des erneuten Schreibens von URLs besteht darin, dass Sie jede URL dynamisch generieren müssen, um eine Sitzungs-ID zuzuweisen, selbst bei einer einfachen statischen HTML-Seite.

Das HttpSession-Objekt

Abgesehen von den oben genannten drei Möglichkeiten bietet das Servlet eine HttpSession-Schnittstelle, mit der ein Benutzer über mehr als eine Seitenanforderung oder einen Besuch auf einer Website identifiziert und Informationen über diesen Benutzer gespeichert werden können.

Der Servlet-Container verwendet diese Schnittstelle, um eine Sitzung zwischen einem HTTP-Client und einem HTTP-Server zu erstellen. Die Sitzung bleibt für einen bestimmten Zeitraum über mehrere Verbindungs- oder Seitenanforderungen des Benutzers hinweg bestehen.

Sie würden das HttpSession-Objekt erhalten, indem Sie die öffentliche Methode aufrufen getSession() von HttpServletRequest, wie unten -

HttpSession session = request.getSession();

Sie müssen request.getSession () aufrufen, bevor Sie Dokumentinhalte an den Client senden. Hier ist eine Zusammenfassung der wichtigen Methoden, die über das HttpSession-Objekt verfügbar sind:

Sr.Nr. Methode & Beschreibung
1

public Object getAttribute(String name)

Diese Methode gibt das Objekt zurück, das in dieser Sitzung mit dem angegebenen Namen gebunden ist, oder null, wenn kein Objekt unter dem Namen gebunden ist.

2

public Enumeration getAttributeNames()

Diese Methode gibt eine Aufzählung von String-Objekten zurück, die die Namen aller an diese Sitzung gebundenen Objekte enthält.

3

public long getCreationTime()

Diese Methode gibt die Zeit zurück, zu der diese Sitzung erstellt wurde, gemessen in Millisekunden seit Mitternacht, 1. Januar 1970 GMT.

4

public String getId()

Diese Methode gibt eine Zeichenfolge zurück, die den dieser Sitzung zugewiesenen eindeutigen Bezeichner enthält.

5

public long getLastAccessedTime()

Diese Methode gibt die zuletzt aufgerufene Zeit der Sitzung im Millisekundenformat seit Mitternacht des 1. Januar 1970 GMT zurück

6

public int getMaxInactiveInterval()

Diese Methode gibt das maximale Zeitintervall (Sekunden) zurück, in dem der Servlet-Container die Sitzung zwischen Clientzugriffen offen hält.

7

public void invalidate()

Diese Methode macht diese Sitzung ungültig und hebt die Bindung aller daran gebundenen Objekte auf.

8

public boolean isNew(

Diese Methode gibt true zurück, wenn der Client noch nichts über die Sitzung weiß oder wenn der Client sich dafür entscheidet, nicht an der Sitzung teilzunehmen.

9

public void removeAttribute(String name)

Diese Methode entfernt das mit dem angegebenen Namen gebundene Objekt aus dieser Sitzung.

10

public void setAttribute(String name, Object value)

Diese Methode bindet ein Objekt unter Verwendung des angegebenen Namens an diese Sitzung.

11

public void setMaxInactiveInterval(int interval)

Diese Methode gibt die Zeit in Sekunden zwischen Clientanforderungen an, bevor der Servlet-Container diese Sitzung ungültig macht.

Beispiel für die Sitzungsverfolgung

In diesem Beispiel wird beschrieben, wie Sie mit dem HttpSession-Objekt die Erstellungszeit und die Zeit für den letzten Zugriff für eine Sitzung ermitteln. Wir würden der Anfrage eine neue Sitzung zuordnen, falls noch keine existiert.

// 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>"
      );
   }
}

Kompilieren Sie das obige Servlet SessionTrackund erstellen Sie einen entsprechenden Eintrag in der Datei web.xml. Wenn Sie jetzt http: // localhost: 8080 / SessionTrack ausführen, wird beim ersten Ausführen das folgende Ergebnis angezeigt:

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

Versuchen Sie nun, dasselbe Servlet zum zweiten Mal auszuführen. Das folgende Ergebnis wird angezeigt.

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

Sitzungsdaten löschen

Wenn Sie mit den Sitzungsdaten eines Benutzers fertig sind, haben Sie mehrere Möglichkeiten:

  • Remove a particular attribute- Sie können die Methode public void removeAttribute (String name) aufrufen , um den einem bestimmten Schlüssel zugeordneten Wert zu löschen.

  • Delete the whole session- Sie können die Methode public void invalidate () aufrufen , um eine gesamte Sitzung zu verwerfen.

  • Setting Session timeout- Sie können die Methode public void setMaxInactiveInterval (int interval) aufrufen , um das Zeitlimit für eine Sitzung einzeln festzulegen .

  • Log the user out - Die Server, die Servlets 2.4 unterstützen, können Sie aufrufen logout um den Client vom Webserver abzumelden und alle Sitzungen aller Benutzer ungültig zu machen.

  • web.xml Configuration - Wenn Sie Tomcat verwenden, können Sie neben den oben genannten Methoden das Sitzungszeitlimit in der Datei web.xml wie folgt konfigurieren.

<session-config>
   <session-timeout>15</session-timeout>
</session-config>

Das Zeitlimit wird in Minuten ausgedrückt und überschreibt das Standardzeitlimit von 30 Minuten in Tomcat.

Die Methode getMaxInactiveInterval () in einem Servlet gibt die Zeitüberschreitung für diese Sitzung in Sekunden zurück. Wenn Ihre Sitzung also 15 Minuten lang in web.xml konfiguriert ist, gibt getMaxInactiveInterval () 900 zurück.

In diesem Lernprogramm wird davon ausgegangen, dass Sie Kenntnisse über die Funktionsweise der JDBC-Anwendung haben. Stellen Sie vor dem Start des Datenbankzugriffs über ein Servlet sicher, dass Sie die richtige JDBC-Umgebung zusammen mit einer Datenbank eingerichtet haben.

Weitere Informationen zum Zugriff auf die Datenbank mit JDBC und zum Einrichten der Umgebung finden Sie in unserem JDBC-Lernprogramm .

Lassen Sie uns zunächst eine einfache Tabelle erstellen und einige Datensätze in dieser Tabelle wie folgt erstellen:

Tabelle erstellen

So erstellen Sie die Employees Führen Sie die folgenden Schritte aus, um die Tabelle in der TEST-Datenbank auszuführen:

Schritt 1

Öffne ein Command Prompt und wechseln Sie wie folgt in das Installationsverzeichnis -

C:\>
C:\>cd Program Files\MySQL\bin
C:\Program Files\MySQL\bin>

Schritt 2

Melden Sie sich wie folgt bei der Datenbank an

C:\Program Files\MySQL\bin>mysql -u root -p
Enter password: ********
mysql>

Schritt 3

Erstellen Sie die Tabelle Employee im TEST Datenbank wie folgt -

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>

Datensätze erstellen

Schließlich erstellen Sie einige Datensätze in der Employee-Tabelle wie folgt:

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>

Zugriff auf eine Datenbank

Hier ist ein Beispiel, das zeigt, wie Sie mit Servlet auf die TEST-Datenbank zugreifen.

// 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
   }
}

Lassen Sie uns nun das obige Servlet kompilieren und die folgenden Einträge in web.xml erstellen

....
<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>
....

Rufen Sie nun dieses Servlet unter der URL http: // localhost: 8080 / DatabaseAccess auf, die die folgende Antwort anzeigen würde:

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

Ein Servlet kann mit einem HTML-Formular-Tag verwendet werden, damit Benutzer Dateien auf den Server hochladen können. Eine hochgeladene Datei kann eine Textdatei, eine Bilddatei oder ein beliebiges Dokument sein.

Erstellen eines Formulars zum Hochladen von Dateien

Der folgende HTM-Code erstellt ein Uploader-Formular. Im Folgenden sind die wichtigen Punkte aufgeführt, die zu beachten sind:

  • Die Form method Attribut sollte auf gesetzt sein POST Methode und GET-Methode können nicht verwendet werden

  • Die Form enctype Attribut sollte auf gesetzt sein multipart/form-data.

  • Die Form actionDas Attribut sollte auf eine Servlet-Datei festgelegt werden, die das Hochladen von Dateien auf dem Back-End-Server übernimmt. Das folgende Beispiel verwendetUploadServlet Servlet zum Hochladen der Datei.

  • Um eine einzelne Datei hochzuladen, sollten Sie ein einzelnes <input ... /> -Tag mit dem Attributtyp = "Datei" verwenden. Um das Hochladen mehrerer Dateien zu ermöglichen, fügen Sie mehr als ein Eingabe-Tag mit unterschiedlichen Werten für das Namensattribut hinzu. Der Browser ordnet jedem von ihnen eine Schaltfläche zum Durchsuchen zu.

<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>

Daraufhin wird das folgende Ergebnis angezeigt, mit dem eine Datei vom lokalen PC ausgewählt werden kann. Wenn der Benutzer auf "Datei hochladen" klickt, wird das Formular zusammen mit der ausgewählten Datei gesendet.

File Upload: 
Select a file to upload: 


NOTE: This is just dummy form and would not work.

Backend-Servlet schreiben

Es folgt das Servlet UploadServletDies würde dafür sorgen, dass hochgeladene Dateien akzeptiert und im Verzeichnis <Tomcat-Installationsverzeichnis> / webapps / data gespeichert werden. Dieser Verzeichnisname kann auch mit einer externen Konfiguration wie zcontext-param Element in web.xml wie folgt -

<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>

Im Folgenden finden Sie den Quellcode für UploadServlet, mit dem mehrere Dateien gleichzeitig hochgeladen werden können. Bevor Sie fortfahren, stellen Sie Folgendes sicher:

  • Das folgende Beispiel hängt von FileUpload ab. Stellen Sie daher sicher, dass Sie über die neueste Version von verfügen commons-fileupload.x.x.jarDatei in Ihrem Klassenpfad. Sie können es von herunterladenhttps://commons.apache.org/fileupload/.

  • FileUpload hängt von Commons IO ab. Stellen Sie daher sicher, dass Sie über die neueste Version von verfügen commons-io-x.x.jarDatei in Ihrem Klassenpfad. Sie können es von herunterladenhttps://commons.apache.org/io/.

  • Während Sie das folgende Beispiel testen, sollten Sie eine Datei hochladen, die kleiner als maxFileSize ist, da sonst die Datei nicht hochgeladen wird.

  • Stellen Sie sicher, dass Sie die Verzeichnisse c: \ temp und c: \ apache-tomcat8.0.28 \ webapps \ data rechtzeitig erstellt haben.

// 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.");
      }
   }
}

Servlet kompilieren und ausführen

Kompilieren Sie das obige Servlet UploadServlet und erstellen Sie den erforderlichen Eintrag in der Datei web.xml wie folgt.

<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>

Versuchen Sie nun, Dateien mit dem oben erstellten HTML-Formular hochzuladen. Wenn Sie http: // localhost: 8080 / UploadFile.htm ausprobieren, wird das folgende Ergebnis angezeigt, mit dem Sie Dateien von Ihrem lokalen Computer hochladen können.

File Upload: 

Select a file to upload:


Wenn Ihr Servlet-Skript ordnungsgemäß funktioniert, sollte Ihre Datei im Verzeichnis c: \ apache-tomcat8.0.28 \ webapps \ data \ hochgeladen werden.

Einer der wichtigsten Vorteile der Verwendung von Servlet besteht darin, dass Sie die meisten in Java verfügbaren Kernmethoden verwenden können. Dieses Tutorial führt Sie durch JavaDate Klasse, die in verfügbar ist java.util Paket, diese Klasse kapselt das aktuelle Datum und die aktuelle Uhrzeit.

Die Date-Klasse unterstützt zwei Konstruktoren. Der erste Konstruktor initialisiert das Objekt mit dem aktuellen Datum und der aktuellen Uhrzeit.

Date( )

Der folgende Konstruktor akzeptiert ein Argument, das der Anzahl der Millisekunden entspricht, die seit Mitternacht, dem 1. Januar 1970, vergangen sind

Date(long millisec)

Sobald Sie ein Date-Objekt verfügbar haben, können Sie eine der folgenden Unterstützungsmethoden aufrufen, um mit Datumsangaben zu spielen:

Sr.Nr. Methoden & Beschreibung
1

boolean after(Date date)

Gibt true zurück, wenn das aufrufende Date-Objekt ein Datum enthält, das nach dem durch date angegebenen Datum liegt. Andernfalls wird false zurückgegeben.

2

boolean before(Date date)

Gibt true zurück, wenn das aufrufende Date-Objekt ein Datum enthält, das vor dem durch date angegebenen Datum liegt. Andernfalls wird false zurückgegeben.

3

Object clone( )

Dupliziert das aufrufende Date-Objekt.

4

int compareTo(Date date)

Vergleicht den Wert des aufrufenden Objekts mit dem des Datums. Gibt 0 zurück, wenn die Werte gleich sind. Gibt einen negativen Wert zurück, wenn das aufrufende Objekt vor dem Datum liegt. Gibt einen positiven Wert zurück, wenn das aufrufende Objekt nach dem Datum liegt.

5

int compareTo(Object obj)

Funktioniert identisch mit compareTo (Date), wenn obj der Klasse Date entspricht. Andernfalls wird eine ClassCastException ausgelöst.

6

boolean equals(Object date)

Gibt true zurück, wenn das aufrufende Date-Objekt dieselbe Uhrzeit und dasselbe Datum enthält wie das durch date angegebene. Andernfalls wird false zurückgegeben.

7

long getTime( )

Gibt die Anzahl der Millisekunden zurück, die seit dem 1. Januar 1970 vergangen sind.

8

int hashCode( )

Gibt einen Hash-Code für das aufrufende Objekt zurück.

9

void setTime(long time)

Legt die Uhrzeit und das Datum wie durch die Uhrzeit festgelegt fest. Dies entspricht einer verstrichenen Zeit in Millisekunden ab Mitternacht, dem 1. Januar 1970.

10

String toString( )

Konvertiert das aufrufende Date-Objekt in eine Zeichenfolge und gibt das Ergebnis zurück.

Aktuelles Datum und Uhrzeit abrufen

Dies ist sehr einfach, um das aktuelle Datum und die aktuelle Uhrzeit in Java Servlet abzurufen. Sie können ein einfaches Datumsobjekt mit der toString () -Methode verwenden, um das aktuelle Datum und die aktuelle Uhrzeit wie folgt zu drucken:

// 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>"
      );
   }
}

Lassen Sie uns nun das obige Servlet kompilieren und entsprechende Einträge in web.xml erstellen und dieses Servlet dann unter der URL http: // localhost: 8080 / CurrentDate aufrufen. Dies würde folgendes Ergebnis liefern -

Display Current Date & Time

Mon Jun 21 21:46:49 GMT+04:00 2010

Wenn Sie versuchen, die URL http: // localhost: 8080 / CurrentDate zu aktualisieren, werden Sie bei jeder Aktualisierung einen Unterschied in Sekunden feststellen.

Datumsvergleich

Wie oben erwähnt, können Sie alle verfügbaren Java-Methoden in Ihrem Servlet verwenden. Wenn Sie zwei Daten vergleichen müssen, folgen die folgenden Methoden:

  • Mit getTime () können Sie die Anzahl der Millisekunden abrufen, die seit Mitternacht, dem 1. Januar 1970, für beide Objekte vergangen sind, und diese beiden Werte vergleichen.

  • Sie können die Methoden before (), after () und equals () verwenden. Da der 12. des Monats beispielsweise vor dem 18. liegt, gibt das neue Datum (99, 2, 12) vor (neues Datum (99, 2, 18)) true zurück.

  • Sie können die compareTo () -Methode verwenden, die von der Comparable-Schnittstelle definiert und von Date implementiert wird.

Datumsformatierung mit SimpleDateFormat

SimpleDateFormat ist eine konkrete Klasse zum Formatieren und Analysieren von Datumsangaben auf lokale Weise. Mit SimpleDateFormat können Sie zunächst benutzerdefinierte Muster für die Formatierung von Datum und Uhrzeit auswählen.

Lassen Sie uns das obige Beispiel wie folgt modifizieren:

// 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>"
      );
   }
}

Kompilieren Sie das obige Servlet erneut und rufen Sie dieses Servlet dann unter der URL http: // localhost: 8080 / CurrentDate auf. Dies würde folgendes Ergebnis liefern -

Display Current Date & Time

Mon 2010.06.21 at 10:06:44 PM GMT+04:00

Einfache DateFormat-Formatcodes

Verwenden Sie zum Festlegen des Zeitformats eine Zeitmusterzeichenfolge. In diesem Muster sind alle ASCII-Buchstaben als Musterbuchstaben reserviert, die wie folgt definiert sind:

Charakter Beschreibung Beispiel
G Ära Bezeichner ANZEIGE
y Jahr in vier Ziffern 2001
M. Monat im Jahr Juli oder 07
d Tag im Monat 10
h Stunde in AM / PM (1 ~ 12) 12
H. Stunde am Tag (0 ~ 23) 22
m Minute in Stunde 30
s Zweiter in der Minute 55
S. Millisekunde 234
E. Tag in der Woche Dienstag
D. Tag im Jahr 360
F. Wochentag im Monat 2 (zweiter Mi. im Juli)
w Woche im Jahr 40
W. Woche im Monat 1
ein AM / PM-Marker PM
k Stunde am Tag (1 ~ 24) 24
K. Stunde in AM / PM (0 ~ 11) 10
z Zeitzone Östliche Standardzeit
' Escape für Text Trennzeichen
"" Einfaches Zitat `

Eine vollständige Liste der ständig verfügbaren Methoden zum Bearbeiten des Datums finden Sie in der Standard-Java-Dokumentation.

Die Seitenumleitung ist eine Technik, bei der der Client an einen anderen als den angeforderten Speicherort gesendet wird. Die Seitenumleitung wird im Allgemeinen verwendet, wenn ein Dokument an einen neuen Speicherort verschoben wird oder möglicherweise auf einen Lastenausgleich zurückzuführen ist.

Die einfachste Möglichkeit, eine Anforderung auf eine andere Seite umzuleiten, ist die Verwendung der Methode sendRedirect()des Antwortobjekts. Es folgt die Signatur dieser Methode -

public void HttpServletResponse.sendRedirect(String location) 
throws IOException

Diese Methode sendet die Antwort zusammen mit dem Statuscode und dem neuen Seitenort an den Browser zurück. Sie können auch die Methoden setStatus () und setHeader () zusammen verwenden, um dasselbe zu erreichen -

.... 
String site = "http://www.newpage.com" ; 
response.setStatus(response.SC_MOVED_TEMPORARILY); 
response.setHeader("Location", site);  
....

Beispiel

Dieses Beispiel zeigt, wie ein Servlet eine Seitenumleitung an einen anderen Speicherort durchführt.

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);    
   }
}

Lassen Sie uns nun das obige Servlet kompilieren und die folgenden Einträge in web.xml erstellen

....
<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>
....

Rufen Sie dieses Servlet nun unter der URL http: // localhost: 8080 / PageRedirect auf. Dies würde Sie zur URL http://www.photofuntoos.com weiterleiten.

Drücken Sie den Zähler für eine Webseite

Oft wären Sie daran interessiert, die Gesamtzahl der Treffer auf einer bestimmten Seite Ihrer Website zu erfahren. Es ist sehr einfach, diese Treffer mit einem Servlet zu zählen, da der Lebenszyklus eines Servlets von dem Container gesteuert wird, in dem es ausgeführt wird.

Im Folgenden sind die Schritte aufgeführt, die zur Implementierung eines einfachen Seitenzugriffszählers ausgeführt werden müssen, der auf dem Servlet-Lebenszyklus basiert:

  • Initialisieren Sie eine globale Variable in der Methode init ().

  • Erhöhen Sie die globale Variable jedes Mal, wenn die Methode doGet () oder doPost () aufgerufen wird.

  • Bei Bedarf können Sie eine Datenbanktabelle verwenden, um den Wert der globalen Variablen in der destroy () -Methode zu speichern. Dieser Wert kann innerhalb der init () -Methode gelesen werden, wenn das Servlet das nächste Mal initialisiert wird. Dieser Schritt ist optional.

  • Wenn Sie in einer Sitzung nur eindeutige Seitentreffer zählen möchten, können Sie mit der Methode isNew () überprüfen, ob dieselbe Seite in dieser Sitzung bereits getroffen wurde. Dieser Schritt ist optional.

  • Sie können den Wert des globalen Zählers anzeigen, um die Gesamtzahl der Treffer auf Ihrer Website anzuzeigen. Dieser Schritt ist ebenfalls optional.

Hier gehe ich davon aus, dass der Webcontainer nicht neu gestartet wird. Wenn es neu gestartet oder das Servlet zerstört wird, wird der Trefferzähler zurückgesetzt.

Beispiel

Dieses Beispiel zeigt, wie ein einfacher Seitenzugriffszähler implementiert wird -

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.
   } 
}

Lassen Sie uns nun das obige Servlet kompilieren und die folgenden Einträge in web.xml erstellen

<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>
....

Rufen Sie dieses Servlet nun unter der URL http: // localhost: 8080 / PageHitCounter auf. Dies würde den Zähler jedes Mal um eins erhöhen, wenn diese Seite aktualisiert wird, und es würde folgendes Ergebnis anzeigen -

Total Number of Hits

6

Hit Counter for a Website:

Oft wären Sie daran interessiert, die Gesamtzahl der Treffer auf Ihrer gesamten Website zu erfahren. Dies ist auch in Servlet sehr einfach und wir können dies mithilfe von Filtern erreichen.

Im Folgenden sind die Schritte aufgeführt, die zur Implementierung eines einfachen Website-Trefferzählers ausgeführt werden müssen, der auf dem Filterlebenszyklus basiert:

  • Initialisieren Sie eine globale Variable in der init () -Methode eines Filters.

  • Erhöhen Sie die globale Variable jedes Mal, wenn die doFilter-Methode aufgerufen wird.

  • Bei Bedarf können Sie eine Datenbanktabelle verwenden, um den Wert der globalen Variablen in der Filtermethode destroy () zu speichern. Dieser Wert kann innerhalb der init () -Methode gelesen werden, wenn der Filter beim nächsten Mal initialisiert wird. Dieser Schritt ist optional.

Hier gehe ich davon aus, dass der Webcontainer nicht neu gestartet wird. Wenn es neu gestartet oder das Servlet zerstört wird, wird der Trefferzähler zurückgesetzt.

Beispiel

Dieses Beispiel zeigt, wie ein einfacher Website-Trefferzähler implementiert wird -

// 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.
   } 
}

Lassen Sie uns nun das obige Servlet kompilieren und die folgenden Einträge in web.xml erstellen

....
<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>
....

Rufen Sie nun eine beliebige URL wie die URL http: // localhost: 8080 / auf. Dies würde den Zähler jedes Mal um eins erhöhen, wenn eine Seite einen Treffer erhält, und die folgende Meldung im Protokoll anzeigen -

Site visits count : 1
Site visits count : 2
Site visits count : 3
Site visits count : 4
Site visits count : 5
..................

Stellen Sie sich eine Webseite vor, auf der Live-Spielstand, Börsenstatus oder Wechselkurs angezeigt werden. Für alle Arten von Seiten müssten Sie Ihre Webseite regelmäßig über die Schaltfläche "Aktualisieren" oder "Neu laden" mit Ihrem Browser aktualisieren.

Java Servlet erleichtert diese Aufgabe, indem es Ihnen einen Mechanismus bietet, mit dem Sie eine Webseite so erstellen können, dass sie nach einem bestimmten Intervall automatisch aktualisiert wird.

Die einfachste Möglichkeit, eine Webseite zu aktualisieren, ist die Verwendung der Methode setIntHeader()des Antwortobjekts. Es folgt die Signatur dieser Methode -

public void setIntHeader(String header, int headerValue)

Diese Methode sendet den Header "Refresh" zusammen mit einem ganzzahligen Wert, der das Zeitintervall in Sekunden angibt, an den Browser zurück.

Beispiel für die automatische Seitenaktualisierung

Dieses Beispiel zeigt, wie ein Servlet die automatische Seitenaktualisierung mithilfe von ausführt setIntHeader() Methode zum Einstellen Refresh Header.

// 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);
   }
}

Lassen Sie uns nun das obige Servlet kompilieren und die folgenden Einträge in web.xml erstellen

....
 <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>
....

Rufen Sie dieses Servlet nun unter der URL http: // localhost: 8080 / Refresh auf, die alle 5 Sekunden die aktuelle Systemzeit wie folgt anzeigt. Führen Sie einfach das Servlet aus und warten Sie, bis das Ergebnis angezeigt wird.

Auto Page Refresh using Servlet

Current Time is: 9:44:50 PM

Das Senden einer E-Mail mit einem Servlet ist einfach genug, sollte aber zunächst erfolgen JavaMail API und Java Activation Framework (JAF) auf Ihrem Computer installiert.

  • Sie können die neueste Version von JavaMail (Version 1.2) von der Standard-Website von Java herunterladen.

  • Sie können die neueste Version von JAF (Version 1.1.1) von der Standard-Website von Java herunterladen.

Laden Sie diese Dateien herunter und entpacken Sie sie. In den neu erstellten Verzeichnissen der obersten Ebene finden Sie eine Reihe von JAR-Dateien für beide Anwendungen. Sie müssen hinzufügenmail.jar und activation.jar Dateien in Ihrem CLASSPATH.

Senden Sie eine einfache E-Mail

Hier ist ein Beispiel zum Senden einer einfachen E-Mail von Ihrem Computer. Hier wird davon ausgegangen, dass Ihrlocalhostist mit dem Internet verbunden und in der Lage, eine E-Mail zu senden. Stellen Sie gleichzeitig sicher, dass alle JAR-Dateien aus dem Java Email API-Paket und dem JAF-Paket in CLASSPATH verfügbar sind.

// 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();
      }
   }
}

Lassen Sie uns nun das obige Servlet kompilieren und die folgenden Einträge in web.xml erstellen

....
 <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>
....

Rufen Sie nun dieses Servlet unter der URL http: // localhost: 8080 / SendEmail auf, die eine E-Mail an die angegebene E-Mail-ID [email protected] sendet und die folgende Antwort anzeigt:

Send Email

Sent message successfully....

Wenn Sie eine E-Mail an mehrere Empfänger senden möchten, werden die folgenden Methoden verwendet, um mehrere E-Mail-IDs anzugeben:

void addRecipients(Message.RecipientType type, Address[] addresses)
throws MessagingException

Hier ist die Beschreibung der Parameter -

  • type- Dies würde auf TO, CC oder BCC gesetzt. Hier steht CC für Carbon Copy und BCC für Black Carbon Copy. Beispiel Message.RecipientType.TO

  • addresses- Dies ist das Array der E-Mail-ID. Sie müssten die InternetAddress () -Methode verwenden, um E-Mail-IDs anzugeben.

Senden Sie eine HTML-E-Mail

Hier ist ein Beispiel zum Senden einer HTML-E-Mail von Ihrem Computer. Hier wird davon ausgegangen, dass Ihrlocalhostist mit dem Internet verbunden und in der Lage, eine E-Mail zu senden. Stellen Sie gleichzeitig sicher, dass alle JAR-Dateien aus dem Java Email API-Paket und dem JAF-Paket in CLASSPATH verfügbar sind.

Dieses Beispiel ist dem vorherigen sehr ähnlich, außer dass wir hier die setContent () -Methode verwenden, um Inhalte festzulegen, deren zweites Argument "text / html" ist, um anzugeben, dass der HTML-Inhalt in der Nachricht enthalten ist.

In diesem Beispiel können Sie so viel HTML-Inhalt senden, wie Sie möchten.

// 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();
      }
   }
}

Kompilieren Sie das obige Servlet und führen Sie es aus, um eine HTML-Nachricht mit einer bestimmten E-Mail-ID zu senden.

Anhang per E-Mail senden

Hier ist ein Beispiel zum Senden einer E-Mail mit Anhang von Ihrem Computer. Hier wird davon ausgegangen, dass Ihrlocalhost ist mit dem Internet verbunden und in der Lage, eine E-Mail zu senden.

// 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();
      }
   }
}

Kompilieren Sie das Servlet und führen Sie es aus, um eine Datei als Anhang zusammen mit einer Nachricht zu einer bestimmten E-Mail-ID zu senden.

Benutzerauthentifizierungsteil

Wenn es erforderlich ist, dem E-Mail-Server zur Authentifizierung Benutzer-ID und Kennwort bereitzustellen, können Sie diese Eigenschaften wie folgt festlegen:

props.setProperty("mail.user", "myuser");
 props.setProperty("mail.password", "mypwd");

Der Rest des E-Mail-Versandmechanismus bleibt wie oben erläutert.

Die Webanwendungsstruktur mit dem Unterverzeichnis WEB-INF ist Standard für alle Java-Webanwendungen und wird durch die Servlet-API-Spezifikation angegeben. Gegeben ein Verzeichnisname der obersten Ebene von myapp. So sieht diese Verzeichnisstruktur aus:

/myapp
   /images
   /WEB-INF
      /classes
      /lib

Das Unterverzeichnis WEB-INF enthält den Bereitstellungsdeskriptor der Anwendung mit dem Namen web.xml. Alle HTML-Dateien sollten im obersten Verzeichnis myapp gespeichert werden . Für Administratorbenutzer finden Sie das ROOT-Verzeichnis als übergeordnetes Verzeichnis.

Servlets in Paketen erstellen

Das Verzeichnis WEB-INF / classes enthält alle Servlet-Klassen und andere Klassendateien in einer Struktur, die ihrem Paketnamen entspricht. Zum Beispiel, wenn Sie einen vollständig qualifizierten Klassennamen von habencom.myorg.MyServlet, dann muss sich diese Servlet-Klasse im folgenden Verzeichnis befinden -

/myapp/WEB-INF/classes/com/myorg/MyServlet.class

Im Folgenden finden Sie ein Beispiel zum Erstellen einer MyServlet-Klasse mit dem Paketnamen 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.
   }
}

Servlets in Paketen kompilieren

Es gibt nicht viel anderes, um eine im Paket verfügbare Klasse zu kompilieren. Der einfachste Weg ist, Ihre Java-Datei in einem vollständig qualifizierten Pfad zu halten, wie oben erwähnt. Die Klasse wird in com.myorg gespeichert. Sie müssten dieses Verzeichnis auch in CLASSPATH hinzufügen.

Angenommen, Ihre Umgebung ist ordnungsgemäß eingerichtet, gehen Sie hinein <Tomcat-installationdirectory>Verzeichnis / webapps / ROOT / WEB-INF / classes und kompilieren Sie MyServlet.java wie folgt

$ javac MyServlet.java

Wenn das Servlet von anderen Bibliotheken abhängt, müssen Sie diese JAR-Dateien auch in Ihren CLASSPATH aufnehmen. Ich habe nur die JAR-Datei servlet-api.jar eingefügt, da ich keine andere Bibliothek im Hello World-Programm verwende.

Diese Befehlszeile verwendet den integrierten Javac-Compiler, der mit dem Sun Microsystems Java Software Development Kit (JDK) geliefert wird. Damit dieser Befehl ordnungsgemäß funktioniert, müssen Sie den Speicherort des von Ihnen verwendeten Java SDK in die Umgebungsvariable PATH aufnehmen.

Wenn alles gut geht, würde die obige Zusammenstellung produzieren MyServlet.classDatei im selben Verzeichnis. Im nächsten Abschnitt wird erläutert, wie ein kompiliertes Servlet in der Produktion bereitgestellt wird.

Bereitstellung gepackter Servlets

Standardmäßig befindet sich eine Servlet-Anwendung im Pfad <Tomcat-Installationsverzeichnis> / webapps / ROOT, und die Klassendatei befindet sich im <Tomcat-Installationsverzeichnis> / webapps / ROOT / WEB-INF / classes.

Wenn Sie einen vollständig qualifizierten Klassennamen von haben com.myorg.MyServletDann muss sich diese Servlet-Klasse in WEB-INF / classes / com / myorg / MyServlet.class befinden und Sie müssen die folgenden Einträge in erstellen web.xml Datei im Verzeichnis <Tomcat-Installationsverzeichnis> / 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>

Über den Einträgen, die in <web-app> ... </ web-app> -Tags erstellt werden sollen, die in der Datei web.xml verfügbar sind. Es könnten bereits verschiedene Einträge in dieser Tabelle verfügbar sein, aber egal.

Sie sind fast fertig. Lassen Sie uns nun den Tomcat-Server mit <Tomcat-Installationsverzeichnis> \ bin \ startup.bat (unter Windows) oder <Tomcat-Installationsverzeichnis> /bin/startup.sh (unter Linux / Solaris usw.) starten und schließlich eingeben http://localhost:8080/MyServletim Adressfeld des Browsers. Wenn alles gut geht, erhalten Sie folgendes Ergebnis:

Hello World

Das Testen / Debuggen von Servlets ist immer schwierig. Servlets beinhalten in der Regel eine große Menge an Client / Server-Interaktionen, wodurch Fehler wahrscheinlich, aber schwer zu reproduzieren sind.

Hier sind einige Hinweise und Vorschläge, die Ihnen beim Debuggen helfen können.

System.out.println ()

System.out.println () kann einfach als Marker verwendet werden, um zu testen, ob ein bestimmter Code ausgeführt wird oder nicht. Wir können auch variable Werte ausdrucken. Zusätzlich -

  • Da das Systemobjekt Teil der Java-Kernobjekte ist, kann es überall verwendet werden, ohne dass zusätzliche Klassen installiert werden müssen. Dies umfasst Servlets, JSP, RMI, EJBs, normale Beans und Klassen sowie eigenständige Anwendungen.

  • Das Anhalten an Haltepunkten stoppt die normale Ausführung und benötigt daher mehr Zeit. Während das Schreiben in System.out den normalen Ausführungsfluss der Anwendung nicht wesentlich beeinträchtigt, ist es sehr wertvoll, wenn das Timing entscheidend ist.

Es folgt die Syntax zur Verwendung von System.out.println () -

System.out.println("Debugging message");

Alle durch die obige Syntax generierten Nachrichten werden in der Webserver-Protokolldatei protokolliert.

Nachrichtenprotokollierung

Es ist immer eine gute Idee, die richtige Protokollierungsmethode zu verwenden, um alle Debug-, Warn- und Fehlermeldungen mithilfe einer Standardprotokollierungsmethode zu protokollieren. Ich benutze log4J , um alle Nachrichten zu protokollieren.

Die Servlet-API bietet auch eine einfache Möglichkeit zur Ausgabe von Informationen mithilfe der log () -Methode wie folgt:

// 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
}

Der ServletContext protokolliert seine Textnachrichten in der Protokolldatei des Servlet-Containers. Bei Tomcat befinden sich diese Protokolle im Verzeichnis <Tomcat-Installationsverzeichnis> / logs.

Die Protokolldateien geben einen Hinweis auf neu auftretende Fehler oder die Häufigkeit von Problemen. Aus diesem Grund ist es gut, die Funktion log () in der catch-Klausel von Ausnahmen zu verwenden, die normalerweise nicht auftreten sollten.

JDB-Debugger verwenden

Sie können Servlets mit denselben JDB-Befehlen debuggen, die Sie zum Debuggen eines Applets oder einer Anwendung verwenden.

Um ein Servlet zu debuggen, debuggen wir sun.servlet.http.HttpServer und beobachten sorgfältig, wie HttpServer Servlets als Antwort auf HTTP-Anforderungen aus dem Browser ausführt. Dies ist dem Debuggen von Applets sehr ähnlich. Der Unterschied besteht darin, dass bei Applets das eigentliche Programm, das debuggt wird, sun.applet.AppletViewer ist.

Die meisten Debugger verbergen dieses Detail, indem sie automatisch wissen, wie Applets debuggt werden. Bis sie dasselbe für Servlets tun, müssen Sie Ihrem Debugger helfen, indem Sie Folgendes tun:

  • Stellen Sie den Klassenpfad Ihres Debuggers so ein, dass er sun.servlet.http.Http-Server und zugehörige Klassen finden kann.

  • Legen Sie den Klassenpfad Ihres Debuggers so fest, dass er auch Ihre Servlets und Supportklassen finden kann, normalerweise server_root / servlets und server_root / classes.

Normalerweise möchten Sie server_root / servlets nicht in Ihrem Klassenpfad haben, da dadurch das Neuladen von Servlets deaktiviert wird. Diese Aufnahme ist jedoch zum Debuggen nützlich. Damit kann Ihr Debugger Haltepunkte in einem Servlet festlegen, bevor der benutzerdefinierte Servlet-Loader in HttpServer das Servlet lädt.

Sobald Sie den richtigen Klassenpfad festgelegt haben, starten Sie das Debuggen von sun.servlet.http.HttpServer. Sie können Haltepunkte in jedem Servlet festlegen, das Sie debuggen möchten, und dann mithilfe eines Webbrowsers eine Anfrage an das HttpServer für das angegebene Servlet senden (http: // localhost: 8080 / servlet / ServletToDebug). Sie sollten sehen, dass die Ausführung an Ihren Haltepunkten gestoppt wird.

Kommentare verwenden

Kommentare in Ihrem Code können den Debugging-Prozess auf verschiedene Weise unterstützen. Kommentare können im Debugging-Prozess auf viele andere Arten verwendet werden.

Das Servlet verwendet Java-Kommentare und einzeilige (// ...) und mehrzeilige (/ * ... * /) Kommentare können verwendet werden, um Teile Ihres Java-Codes vorübergehend zu entfernen. Wenn der Fehler verschwindet, schauen Sie sich den gerade kommentierten Code genauer an und finden Sie das Problem heraus.

Client- und Server-Header

Manchmal, wenn sich ein Servlet nicht wie erwartet verhält, ist es hilfreich, die rohe HTTP-Anforderung und -Antwort zu überprüfen. Wenn Sie mit der Struktur von HTTP vertraut sind, können Sie die Anforderung und Antwort lesen und genau sehen, was genau mit diesen Headern geschieht.

Wichtige Tipps zum Debuggen

Hier ist eine Liste weiterer Debugging-Tipps zum Servlet-Debugging -

  • Denken Sie daran, dass server_root / classes nicht neu geladen wird und server_root / servlets wahrscheinlich.

  • Bitten Sie einen Browser, den Rohinhalt der angezeigten Seite anzuzeigen. Dies kann helfen, Formatierungsprobleme zu identifizieren. Dies ist normalerweise eine Option im Menü Ansicht.

  • Stellen Sie sicher, dass der Browser die Ausgabe einer vorherigen Anforderung nicht zwischenspeichert, indem Sie ein vollständiges Neuladen der Seite erzwingen. Verwenden Sie in Netscape Navigator Shift-Reload. Verwenden Sie mit Internet Explorer die Umschalt-Aktualisierung.

  • Stellen Sie sicher, dass die init () -Methode Ihres Servlets einen ServletConfig-Parameter verwendet und sofort super.init (config) aufruft.

Bevor wir fortfahren, möchte ich drei wichtige Begriffe erläutern:

  • Internationalization (i18n) - Dies bedeutet, dass eine Website verschiedene Versionen von Inhalten bereitstellen kann, die in die Sprache oder Nationalität des Besuchers übersetzt wurden

  • Localization (l10n) - Dies bedeutet, dass einer Website Ressourcen hinzugefügt werden, um sie an eine bestimmte geografische oder kulturelle Region anzupassen.

  • locale- Dies ist eine bestimmte kulturelle oder geografische Region. Es wird normalerweise als Sprachsymbol bezeichnet, gefolgt von einem Landsymbol, das durch einen Unterstrich getrennt ist. Zum Beispiel steht "en_US" für das englische Gebietsschema für die USA.

Es gibt eine Reihe von Punkten, die beim Aufbau einer globalen Website beachtet werden sollten. Dieses Tutorial würde Ihnen keine vollständigen Details dazu geben, aber es würde Ihnen ein gutes Beispiel dafür geben, wie Sie Ihre Webseite der Internet-Community in verschiedenen Sprachen anbieten können, indem Sie ihren Standort, dh das Gebietsschema, unterscheiden.

Ein Servlet kann eine geeignete Version der Site basierend auf dem Gebietsschema des Anforderers abrufen und eine geeignete Site-Version entsprechend der lokalen Sprache, Kultur und Anforderungen bereitstellen. Es folgt die Methode des Anforderungsobjekts, das das Gebietsschemaobjekt zurückgibt.

java.util.Locale request.getLocale()

Gebietsschema erkennen

Im Folgenden finden Sie wichtige Methoden für das Gebietsschema, mit denen Sie den Standort, die Sprache und natürlich das Gebietsschema des Anforderers ermitteln können. Alle unten aufgeführten Methoden zeigen den im Browser des Anforderers festgelegten Ländernamen und Sprachnamen an.

Sr.Nr. Methode & Beschreibung
1

String getCountry()

Diese Methode gibt den Länder- / Regionalcode in Großbuchstaben für dieses Gebietsschema im 2-Buchstaben-Format nach ISO 3166 zurück.

2

String getDisplayCountry()

Diese Methode gibt einen Namen für das Land des Gebietsschemas zurück, der für die Anzeige für den Benutzer geeignet ist.

3

String getLanguage()

Diese Methode gibt den Sprachcode für dieses Gebietsschema im ISO 639-Format in Kleinbuchstaben zurück.

4

String getDisplayLanguage()

Diese Methode gibt einen Namen für die Sprache des Gebietsschemas zurück, der für die Anzeige für den Benutzer geeignet ist.

5

String getISO3Country()

Diese Methode gibt eine dreistellige Abkürzung für das Land dieses Gebietsschemas zurück.

6

String getISO3Language()

Diese Methode gibt eine aus drei Buchstaben bestehende Abkürzung für die Sprache dieses Gebietsschemas zurück.

Beispiel

Dieses Beispiel zeigt, wie Sie eine Sprache und ein zugehöriges Land für eine Anfrage anzeigen -

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>"
      );
   }
}

Spracheinstellung

Ein Servlet kann eine Seite ausgeben, die in einer westeuropäischen Sprache wie Englisch, Spanisch, Deutsch, Französisch, Italienisch, Niederländisch usw. geschrieben ist. Hier ist es wichtig, den ContentLanguage-Header so einzustellen, dass alle Zeichen richtig angezeigt werden.

Der zweite Punkt besteht darin, alle Sonderzeichen mithilfe von HTML-Entitäten anzuzeigen, z. B. "& # 241;" steht für "ñ" und "& # 161;" steht für "¡" wie folgt:

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&ntilde;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&ntilde;ol:" + "</h1>\n" +
               "<h1>" + "&iexcl;Hola Mundo!" + "</h1>\n" +
            "</body>
         </html>"
      );
   }
}

Länderspezifische Daten

Sie können die Klasse java.text.DateFormat und ihre statische Methode getDateTimeInstance () verwenden, um das für das Gebietsschema spezifische Datum und die Uhrzeit zu formatieren. Das folgende Beispiel zeigt, wie Datumsangaben für ein bestimmtes Gebietsschema formatiert werden:

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>"
      );
   }
}

Länderspezifische Währung

Sie können die Klasse java.txt.NumberFormat und ihre statische Methode getCurrencyInstance () verwenden, um eine Zahl, z. B. einen langen oder doppelten Typ, in einer länderspezifischen Währung zu formatieren. Das folgende Beispiel zeigt, wie die für ein bestimmtes Gebietsschema spezifische Währung formatiert wird:

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>"
      );
   }
}

Länderspezifischer Prozentsatz

Sie können die Klasse java.txt.NumberFormat und ihre statische Methode getPercentInstance () verwenden, um den länderspezifischen Prozentsatz abzurufen. Das folgende Beispiel zeigt, wie der Prozentsatz für ein bestimmtes Gebietsschema formatiert wird.

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>"
      );
   }
}

Bisher haben Sie erfahren, wie Servlet den Bereitstellungsdeskriptor (Datei web.xml) zum Bereitstellen Ihrer Anwendung auf einem Webserver verwendet. Servlet API 3.0 hat ein neues Paket namens javax.servlet.annotation eingeführt. Es bietet Annotationstypen, die zum Annotieren einer Servlet-Klasse verwendet werden können. Wenn Sie Anmerkungen verwenden, ist der Bereitstellungsdeskriptor (web.xml) nicht erforderlich. Sie sollten jedoch tomcat7 oder eine spätere Version von tomcat verwenden.

Anmerkungen können die entsprechende XML-Konfiguration in der Webbereitstellungsdeskriptordatei (web.xml) ersetzen, z. B. Servletdeklaration und Servletzuordnung. Servlet-Container verarbeiten die mit Anmerkungen versehenen Klassen zur Bereitstellungszeit.

Die in Servlet 3.0 eingeführten Annotationstypen sind -

Sr.Nr. Anmerkung & Beschreibung
1

@WebServlet

Servlet deklarieren.

2

@WebInitParam

Angeben eines Initialisierungsparameters.

3

@WebFilter

So deklarieren Sie einen Servlet-Filter.

4

@WebListener

So deklarieren Sie einen WebListener

5

@HandlesTypes

So deklarieren Sie die Klassentypen, die ein ServletContainerInitializer verarbeiten kann.

6

@HttpConstraint

Diese Annotation wird in der ServletSecurity-Annotation verwendet, um die Sicherheitsbeschränkungen darzustellen, die auf alle HTTP-Protokollmethoden angewendet werden sollen, für die ein entsprechendes HttpMethodConstraint-Element NICHT in der ServletSecurity-Annotation vorkommt.

7

@HttpMethodConstraint

Diese Annotation wird in der ServletSecurity-Annotation verwendet, um Sicherheitsbeschränkungen für bestimmte HTTP-Protokollnachrichten darzustellen.

8

@MultipartConfig

Anmerkung, die für eine Servlet-Klasse angegeben werden kann und angibt, dass Instanzen des Servlets Anforderungen erwarten, die dem MIME-Typ mit mehreren Teilen / Formulardaten entsprechen.

9

@ServletSecurity

Diese Anmerkung wird in einer Servlet-Implementierungsklasse verwendet, um Sicherheitsbeschränkungen anzugeben, die von einem Servlet-Container für HTTP-Protokollnachrichten erzwungen werden sollen.

Hier haben wir einige der Anmerkungen ausführlich besprochen.

@ WebServlet

Das @WebServlet wird verwendet, um die Konfiguration eines Servlets mit einem Container zu deklarieren. Die folgende Tabelle enthält die Liste der Attribute, die für die WebServlet-Annotation verwendet werden.

Sr.Nr. Attribut & Beschreibung
1

String name

Name des Servlets

2

String[] value

Array von URL-Mustern

3

String[] urlPatterns

Array von URL-Mustern, für die dieser Filter gilt

4

Int loadOnStartup

Der ganzzahlige Wert gibt Ihnen den Hinweis zur Startreihenfolge

5

WebInitParam[] initParams

Array von Initialisierungsparametern für dieses Servlet

6

Boolean asyncSupported

Von diesem Servlet unterstützte asynchrone Operation

7

String smallIcon

Kleines Symbol für dieses Servlet, falls vorhanden

8

String largeIcon

Großes Symbol für dieses Servlet, falls vorhanden

9

String description

Beschreibung dieses Servlets, falls vorhanden

10

String displayName

Anzeigename dieses Servlets, falls vorhanden

Mindestens ein URL-Muster MUSS in einem der beiden deklariert sein value oder urlPattern Attribut der Anmerkung, aber nicht beide.

Das value Das Attribut wird für die Verwendung empfohlen, wenn nur das URL-Muster festgelegt wird urlPattern Attribut sollte verwendet werden.

Beispiel

Das folgende Beispiel beschreibt die Verwendung der Annotation @WebServlet. Es ist ein einfaches Servlet, das den Text anzeigtHello 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>");         
   }   
}

Kompilieren Simple.java wie gewohnt und legen Sie Ihre Klassendatei in <Tomcat-Installationsverzeichnis> / webapps / ROOT / WEB-INF / classes ab.

Versuchen Sie nun, ein Servlet aufzurufen, indem Sie einfach http: // localhost: 8080 / Simple ausführen . Sie sehen die folgende Ausgabe auf der Webseite.

Hello servlet

@WebInitParam

Die Annotation @WebInitParam wird zum Angeben eines Initialisierungsparameters für ein Servlet oder einen Filter verwendet. Es wird in WebFilter- oder WebSevlet-Annotationen verwendet. Die folgende Tabelle enthält die Liste der Attribute, die für die Annotation von WebInitParam verwendet werden.

Sr.Nr. Attribut & Beschreibung
1

String name

Name des Initialisierungsparameters

2

String value

Wert des Initialisierungsparameters

3

String description

Beschreibung des Initialisierungsparameters

Beispiel

Das folgende Beispiel beschreibt die Verwendung der Annotation @WeInitParam zusammen mit der Annotation @WebServlet. Es ist ein einfaches Servlet, das den Text anzeigtHello Servlet und der Stringwert Hello World! die aus dem genommen werden init Parameter.

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>");         
   }   
}

Kompilieren Simple.java wie gewohnt und legen Sie Ihre Klassendatei in <Tomcat-Installationsverzeichnis>; / webapps / ROOT / WEB-INF / classes ab.

Versuchen Sie nun, ein Servlet aufzurufen, indem Sie einfach http: // localhost: 8080 / Simple ausführen . Sie sehen die folgende Ausgabe auf der Webseite.

Hello Servlet

Hello World!

@ Webfilter

Dies ist die Anmerkung, die zum Deklarieren eines Servlet-Filters verwendet wird. Es wird vom Container zur Bereitstellungszeit verarbeitet und der entsprechende Filter auf die angegebenen URL-Muster, Servlets und Dispatcher-Typen angewendet.

Das @WebFilterAnnotation definiert einen Filter in einer Webanwendung. Diese Anmerkung wird für eine Klasse angegeben und enthält Metadaten zum deklarierten Filter. Der mit Anmerkungen versehene Filter muss mindestens ein URL-Muster angeben. In der folgenden Tabelle sind die Attribute aufgeführt, die für die WebFilter-Annotation verwendet werden.

Sr.Nr. Attribut & Beschreibung
1

String filterName

Name des Filters

2

String[] urlPatterns

Stellt ein Array von Werten oder URL-Mustern bereit, für die der Filter gilt

3

DispatcherType[] dispatcherTypes

Gibt die Dispatcher-Typen (Request / Response) an, für die der Filter gilt

4

String[] servletNames

Bietet ein Array von Servlet-Namen

5

String displayName

Name des Filters

6

String description

Beschreibung des Filters

7

WebInitParam[] initParams

Array von Initialisierungsparametern für diesen Filter

8

Boolean asyncSupported

Von diesem Filter unterstützte asynchrone Operation

9

String smallIcon

Kleines Symbol für diesen Filter, falls vorhanden

10

String largeIcon

Großes Symbol für diesen Filter, falls vorhanden

Beispiel

Das folgende Beispiel beschreibt die Verwendung der @ WebFilter-Annotation. Es ist ein einfacher LogFilter, der den Wert von Init-param anzeigttest-paramund den aktuellen Zeitstempel auf der Konsole. Das heißt, der Filter funktioniert wie eine Schnittstellenschicht zwischen der Anforderung und der Antwort. Hier verwenden wir "/ *" für urlPattern. Dies bedeutet, dass dieser Filter für alle Servlets gilt.

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*/ 
   } 
}

Kompilieren Simple.java wie gewohnt und legen Sie Ihre Klassendatei in <Tomcat-Installationsverzeichnis> / webapps / ROOT / WEB-INF / classes ab.

Versuchen Sie nun, ein Servlet aufzurufen, indem Sie einfach http: // localhost: 8080 / Simple ausführen . Sie sehen die folgende Ausgabe auf der Webseite.

Hello Servlet
  
Hello World!

Öffnen Sie nun die Servlet-Konsole. Dort finden Sie den Wert desinit Parameter testparam und die current timestamp zusammen mit Servlet-Benachrichtigungsnachrichten.