Zurück   Weiter

18 Servletprogrammierung

Nachdem zu Beginn des Bekanntwerdens von Java die Programmiersprache fast ausschliesslich zur Programmierung von Applets eingesetzt wurde, hat sich die Verwendung von Java in der Zwischenzeit mehr und mehr von der Client-Seite auf die Server-Seite verlagert. Auf der Serverseite werden dabei sogenannte Servlets ausgeführt, die wie auch cgi-Programme HTML-Code erzeugen und an den aufrufenden Browser zurücksenden. Hierzu ist es nötig in den Webserver eine Servletengine zu integrieren. Diese Servletengine ist in der Lage die Servlets auszuführen.

18.1 Jakarta-Tomcat

Jakarta-Tomcat ist ein Open-Source Projekt unter der Obhut von Apache. Tomcat ist die Referenzimplementierung der von Sun Microsystems veröffentlichten Servlet- und JSP-Spezifikationen. Jakarta-Tomcat kann kostenlos vom Internet heruntergeladen werden. In diesem Kurs wird die Version 4.0.1 verwendet.

18.1.1 Die Installation unter Windows

Ab der Version 4 ist für die Installation unter Windows ein Installer für Tomcat vorhanden. In diesem Kurs wird die Version 4.01 verwendet. Die Installerdatei ist 'jakarta-tomcat-4.0.1.exe', welche von der Apache Homepage heruntergeladen werden kann. Der mit einem Doppelklick gestartete Installer

Tomcat Installation 01

durchsucht den Rechner nach einer bereits installierten JVM, die zur seiner Ausfüführung von Tomcat benötigt wird.

Tomcat Installation 02

Zur Fortführung der Installation müsesn die Lizenzbedingungen im nächsten Dialog akzeptiert werden.

Tomcat Installation 03

Im nächsten Dialog können einige Installationspotionen ausgewählt werden. Ich empfehle die Default-Einstellungen beizubehalten. Nur bei der Installation auf einem produktive Server sollte man den NT-Service noch zusätzlich anwählen.

Tomcat Installation 04

Nachdem der Installationspfad gewählt wurde

Tomcat Installation 05

started die eigentliche Installation.

Tomcat Installation 06

Nach Beendigung der Installation

Tomcat Installation 07

enthält das Startmenu die erforderlichen Einträge um Tomcat zu starten und anzuhalten.

Tomcat Installation 08

Nach dsem Starten kann man mit der URL "http://localhost:8080" im Browser testen, ob die Installation erfolgreich war

Tomcat Installation 09

und sich die Servlet-Beispiel

Tomcat Installation 10

und JSP-Beispiel ansehen.

Tomcat Installation 11

18.1.2 Webapplikationen

In einer Servlet-Engine wie Tomcat werden HTML-Seiten, Servlets, JSP's und alles was sonst noch dazugehört in einer Webapplikation zusammengesfasst. Es gibt verschiedene Möglichkeiten solche Webapplikationen zu installieren und zu konfigurieren. In diesem Kurs wird nur auf die einfachste Möglichkeit eingegangen um die Beispiele und Aufgaben testen zu können.

18.1.3 Das Default-Verzeichnis der Webapplikationen

Im Installationsverzeichnis von Tomcat befindet sich ein Verzeichnis mit dem Namen "webapps". Dieses Verzeichnis wird beim Starten der Servlet-Engine nach vorhandenen Applikationen durchsucht. Diese werden dann automatisch gestartet. Eine Webapplikation entspricht einem Verzeichnis mit einer vorgegebenen Struktur. Der Name der Applikation entspricht dem Namen des Verzeichnisses.

18.1.4 Die Struktur einer Webapplikation

Eine Webapplikation besteht aus statischen Elementen wie HTML-Seiten und Bildern, sowie aus JSP-Seiten, Servlets und weiteren Javaklassen und Java-Bibliotheken. Damit die Servlet-Engine alle erforderlichen Dateien findet, sind einige Verzeichnisnamen und die Aufteilung der Dateien in diese Verzeichnisse vorgeschrieben. Die statischen Elemente und die JSP-Seiten befinden sich direkt im Applikationsverzeichnis. Für die Javaklassen und Bibliotheken muss ein Verzeichnis "WEB-INF" angelegt werden. In diesem Verzeichnis benötigt man noch ein Verzeichnis "classes" für die eigenen Javaklassen und eventuel ein Verzeichnis "lib" für zusätzlich benötigte Klassenbilbiotheken. Als Beispiel gebe ich die Struktur für die Webapplikation "javakurs" an. Tomcat ist in diesem Fall in dem Verziechnis "D:\ApacheGroup\Tomcat4.0" installiert.

  D:
  +- ApacheGroup
     +- Tomcat4.0
        +- webapps
           +- javakurs
              +-WEB-INF
                +- classes
                +- lib

Um bequem arbeiten zu können, ist es am Einfachsten den Compiler anzuweisen, die Bytecode-Dateien direkt in das "classes" zu schreiben. In der Kommandozeile gibt man dazu die Option '-d [Verzeichnisname]' an. Im JBuilder öffnet man hierzu am Besten ein neues Projekt, wie es im folgenden Abschnitt beschrieben ist.

18.3 Servlets in JBuilder5 Personal entwickeln

Die Personal Edition von JBuilder besitzt keine Unterstützung zur Entwicklung von Webapplikationen. Diese ist nur in den Professional und Enterprise Editions gegeben. Allerdings kann sich auch mit der Personal Edition das Entwickeln etwas erleichtern. Starten wir mit der Erstellung eines neuen Projektes:

Servlet Project 01

Im nächsten Schritt

Servlet Project 02

setzen wir den 'Output Path' unseres Projektes auf 'classes' Verzeichnis unserer Webapplikation

Servlet Project 03

und fügen anschliessend den 'Required Libraries' die Servlet API hinzu.

Servlet Project 04



Servlet Project 05

Da der erforderliche Eintrag noch nicht vorhanden ist, müssen wir einen neuen Library Eintrag erstellen.

Servlet Project 06

Der einzige Library-Pfad, den wir hinzufügen müssen, ist die Datei 'servlet.jar' im 'Tomcat4.0/common/lib'-Verzeichnis.

Servlet Project 07

Die Dialoge müssen nun alle mit 'Ok' bestätigt werden, bis wieder der Project Wizard erreicht wird.

Servlet Project 08

Servlet Project 09

Servlet Project 10

Jetzt sind alle Vorbereitungen für das Erstellen von Servlets getroffen.

18.2 Die Klasse HttpServlet

Die Klasse javax.servlet.http.HttpServlet ist die Elternklasse aller Servlets. Jedes selber erzeugte Servlet muss von dieser Klasse abgeleitet sein, damit es von der Servletengine ausgeführt werden kann.

18.2.1 Die Methoden der Klasse HttpServlet

In der Klasse HttpServlet sind für alle HTTP-Operationen Methoden definiert. Diese Methoden können bei Bedarf überschrieben werden. In den meisten Anwendungen werden nur die Methoden doGet und doPost benötigt.

18.2.1.1 Die Methode doGet

doGet wird bei einer HTTP-GET-Operation ausgeführt. Diese Methode muss überschrieben werden, wenn ein Servlet direkt in einem Link aufgerufen wird oder GET als Methode in einem HTML-Formular definiert wurde.

18.2.1.2 Die Methode doPost

doPost wird bei einer HTTP-POST-Operation ausgeführt. Das Überschreiben dieser Methode wird bei der Angabe der Methode POST in einem HTML-Formular nötig.

18.2.1.3 Die Methode doPut

doPut wird bei einer HTTP-PUT-Operation ausgeführt. Diese Methode wird im Allgemeinen nicht benötigt.

18.2.1.4 Die Methode doDelete

doDelete wird bei einer HTTP-DELETE-Operation ausgeführt. Diese Methode wird im Allgemeinen nicht benötigt.

18.2.1.5 Die Methode doTrace

doTrace wird bei einer HTTP-TRACE-Operation ausgeführt. Diese Methode wird im Allgemeinen nicht benötigt.

18.2.1.5 Die Methode doOptions

doOptions wird bei einer HTTP-OPTIONS-Operation ausgeführt. Diese Methode wird im Allgemeinen nicht benötigt.

18.3 Die Klasse HttpServletRequest

Die Klasse HttpServletRequest repräsentiert den vom Benutzer abgesendeten Http-Request. Er enthält alle Informationen über den Inhalt, die Remote-Adresse und den Webserver die im HTTP-Request enthalten sind. Ebenso sind alle vom Benutzer übergebenenen Parameter in diesem Request enthalten.

18.4 Die Klasse HttpServletResponse

In der Klasse HttpServletResponse sind alle Methoden enthalten, die benötigt werden um die Antwort des Servlets auf den Request zu erzeugen. Wichtig ist es hierbei den Content-Type der Antwort anzugeben. Defaultmässig ist der Contenttype auf text/plain eingestellt. In den meisten Fällen wird aber text/html benötigt. Zum Ändern des Content-Type wird die Methode setContentType verwendet. Der im HttpServletResponse definierte PrintWriter stellt das virtuelle HTML-File dar, welches an den Benutzer zurückgeschickt wird. Der gewünschte HTML-Code wird mit den Methoden print und println in diesen PrintWriter hineingeschrieben.

18.5 Die Definition eines Servlets

Bei der Definition eines Servlets muss darauf geachtet werden, dass als Superklasse die Klasse HttpServlet oder eine Subklasse davon angegeben wird. Ein Konstruktor wird in der Regel nicht benötigt. Sollte man einen Konstruktor einfügen, so muss auf jeden Fall auch ein Konstruktor mit leerer Parameterliste definiert werden, damit von der Servletengine eine Instanz des Servlets erzeugt werden kann. Im Allgemeinen wird man entweder die Methode doGet oder doPost überschreiben. Sinnvoll ist es gleich zu Beginn der Methode den Content-Type der Antwort zu setzen. In der Entwicklungszeit ist es auch von Nutzen den eingefügten Sourcecode in einen try-catch-Block zu fassen und die Information über den aufgetretenen Fehler in den HTML-Code einzufügen. Die folgende Servlet-Definition kann als Rumpfservlet verwendet werden. Die im Servlet angegebene Methode doGet muss dabei bei Bedarf durch doPost ersetzt werden.

  import java.io.IOException;
  import java.io.PrintWriter;
  import javax.servlet.ServletException;
  import javax.servlet.http.HttpServlet;
  import javax.servlet.http.HttpServletRequest;
  import javax.servlet.http.HttpServletResponse;

  public class ServletName extends HttpServlet {
    public void doGet(HttpServletRequest request, HttpServletResponse response)
              throws ServletException, IOException {
      response.setContentType("text/html");
      PrintWriter out = response.getWriter();
      out.println("<HTML>");
      out.println("<HEAD><TITLE>Seitentitel</TITLE></HEAD>");
      out.println("<BODY>");
      try {
        // Hier den eigenen Sourcecode einfügen
      } catch(Throwable t) {
      if((t.getMessage() != null) && (t.getMessage().length() > 0)) {
          out.println(t.getMessage());
        } else {
          out.println(t);
        }
      }
      out.println("</BODY>");
      out.println("</HTML>");
      out.close();
    }
  }

Sourcecode

Aufgabe 30

18.6 Das Lesen von Parametern

Dynamische HTML-Seiten machen nur dort Sinn, wo eine Interaktion mit dem Benutzer stattfindet. Dazu ist es möglich den Benutzer Formulare ausfüllen zu lassen und die eingegebenen Daten als Parameter einzulesen. Anders als z.B. bei CGI-Programmierung wird bei Servlets nicht zwischen einem GET- und einem POST-Request bei der Behandlung von Parametern unterschieden. Die Namen der eingegebenen Parameter erhält man mit der Methode getParameterNames() der Klasse HttpServletRequest. Auf die dazugehörigen Daten kann man mit der Methode getParameterValues(String parameterName) von HttpServletRequest zugreifen.

import java.io.IOException;
import java.io.PrintWriter;
import java.util.Enumeration;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class ParameterServlet extends HttpServlet {
  public void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
    response.setContentType("text/html");
    PrintWriter out = response.getWriter();
    out.println("<HTML>");
    out.println("<HEAD><TITLE>Parameter Servlet</TITLE></HEAD>");
    out.println("<BODY>");
    try {
      Enumeration enum = request.getParameterNames();
      while(enum.hasMoreElements()) {
        String paramName = (String)enum.nextElement();
        String[] values = request.getParameterValues(paramName);
        for(int i = 0; i < values.length; i++) {
          out.println(paramName + ": " + values[i] + "<BR>");
        }
      }
    } catch(Throwable t) {
      out.println("<pre<");
      t.printStackTrace(out);
      out.println("</pre<");
    }
    out.println("</BODY>");
    out.println("</HTML>");
    out.close();
  }
}

Sourcecode http://www.zimberfamily.de/zimbers/ParameterServlet?FirstName=Thomas&LastName=Zimber&Kind=Yannic&Kind=Fanny

Aufgabe 31

18.7 Zugriff auf das Lokale System des Servers

Da ein Servlet auf dem gleichen System wie der Server ausgeführt wird, ist problemlos möglich auf lokale Dateien, das lokale Netzwerk und lokale Datenbanken des Serverrechners zuzugreifen. Diese müssen vom Internet aus nicht sichtbar sein. Im Gegensatzt dazu mussten bei Applets alle Dateien und Datenbanken, welche gebraucht wurden für das Internet sichtbar gemacht werden.

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.io.PrintWriter;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class FileReadServlet extends HttpServlet {
  public void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
    response.setContentType("text/html");
    PrintWriter out = response.getWriter();
    BufferedReader reader = null;
    try {
      reader = new BufferedReader(
        new FileReader("c:/www/javakurs/index.html")
      );
      String line = reader.readLine();
      while(line != null) {
        out.println(line);
        line = reader.readLine();
      }
    } catch(Throwable t) {
      out.println("<HTML>");
      out.println("<HEAD<<TITLE<</TITLE<</HEAD<");
      out.println("<BODY<");
      out.println("<pre<");
      t.printStackTrace(out);
      out.println("</pre<");
      out.println("</BODY<");
      out.println("</HTML<");
    } finally {
      try {
        reader.close();
      } catch(Exception ex) {}
    }
  }
}
Aufgabe 32

18.8 Sessionhandling

In Internet-Applikation ist es oft nötig sich Informationen über den Benutzer für die Zeit seines Benutzens der Applikation zu speichern. So muss z.B. bei einem Internet-Shop ein Warenkorb für den Benuzter mitgeführt werden. Die Zeit des Verweilens in einer Applikation eines Beutzers wird Session genannt. Die Java-Servlets bieten eine einfache Möglichkeit diese Sessions zu verwalten.

18.8.1 Die Klasse HttpSession

Die Zuordnung eines Benutzers zu einer Session wird durch eine eindeutige Session-ID realisiert. Diese Session-ID muss vom Benutzer bei jedem Request mitgeschickt werden. Mit Hilfe dieser Session-ID ist es möglich jedem Benutzer eindeutig ein Session-Objekt zuzuweisen und immer wieder darauf zuzugreifen. Dieses Session-Objekt wird durch die Klasse javax.servlet.http.HttpSession repräsentiert. Einer Instanz dieser Klasse kann man mit der Methode putValue(String key, Object value) beliebige Datenobjekte hinzufügen. String key gibt dabei den Namen an, mit dem auf das Objekt wieder zugegriffen werden kann. Die Datenobjekte werden im Speicher des Servlet-Engine-Rechners abgelegt. Zum Benutzer wird immer nur die Session-ID gesandt. Mit der Methode getValue(String key) können die Objekte über ihren Namen wieder ausgelesen werden. Wird ein Objekt nicht mehr gebraucht, kann es mit der Methode removeValue(String key) wieder gelöscht werden. So können alle Benutzerspezifischen Daten in einer Session verwaltet werden.

18.8.1.1 Erzeugen einer neuen Session

Wenn ein Benutzer das erste Mal auf eine Applikation zugreift, muss für ihn eine neue Session-ID erzeugt werden. Diese Aufgabe übernimmt die Servlet-Engine. Mit dem Aufruf der Methode getSession(true) der Klasse Httprequest, wird überprüft ob für den Benutzer, der diesen Request abgesandt hat, schon eine Session existiert. Der Parameter true signalisiert der Servlet-Engine eine neue Session-ID zu erzeugen, falls der Benutzer zum ersten Mal die Seite aufruft. Zurück bekommt man in diesem Fall eine neue Instanz der Klasse HttpSession. Mit der Methode isNew() der Klasse HttpSession kann überprüft werden, ob die Session-ID neu erzeugt werden musste oder bereits vorhanden war. Übergibt man der Methode getSession den Wert false, so wird keine neue Session erzeugt. Der Rückgabewert ist, wenn es noch keine Session-ID für diesen Benutzer gibt, null.

18.8.2 Sessionhandling mit Cookies

Defaultmässig werden zum Erzeugen von Sessions Cookies an den Benutzer verschickt. Diese Cookies werden nur zum Sessionhandling benötigt und deshalb vom Benutzer auch nur an den eigenen Server wieder zurückgeschickt. In diesem Cookie ist nur die Session-ID gespeichert. Mit dem Aufruf von getSession(boolean) wird nicht nur die Session-ID eingelesen, sondern auch die zur Session gehörigen Daten aus dem lokalen Speicher gelesen.

import java.io.IOException;
import java.io.PrintWriter;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;

public class CookieSession extends HttpServlet {
  public void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
    response.setContentType("text/html");
    PrintWriter out = response.getWriter();
    out.println("<HTML>");
    out.println("<HEAD><TITLE>Sessions mit Cookies</TITLE></HEAD>");
    out.println("<BODY>");
    try {
      HttpSession session = request.getSession(true);
      Integer sessionCounter = new Integer(0);
      if(!session.isNew()) {
        sessionCounter = (Integer)session.getValue("session.counter");
        sessionCounter = new Integer(sessionCounter.intValue() + 1);
      }
      session.putValue("session.counter", sessionCounter);
      out.println("session.isNew = " + session.isNew() + "<BR>");
      out.println("sessionCounter = " + sessionCounter + "<BR>");
      out.println("session.getId = " + session.getId() + "<BR>");
      out.println("request.getRequestedSessionId = " + request.getRequestedSessionId() + "<BR>");
      out.println("request.isRequestedSessionIdValid = " + request.isRequestedSessionIdValid() + "<BR>");
      out.println("<A HREF=\"" + request.getRequestURI() + "\">Reload</A>");
    } catch(Throwable t) {
      out.println("<pre<");
      t.printStackTrace(out);
      out.println("</pre<");
    }
    out.println("</BODY>");
    out.println("</HTML>");
    out.close();
  }
}

Sourcecode http://www.zimberfamily.de/zimbers/CookieSession

18.8.3 Sessionhandling mit URL-Codierung

Sessionhandling mit Cookies ist eine sehr bequeme Sache. Allerdings gibt es Internet-Benutzer, welche die Cookie-Funktionalität des Browsers ausschalten. Somit ist mit Cookies kein Sessionhandling mehr möglich. Das es dann wirklich nicht mehr funktioniert lässt sich mit dem letzten Beispiel einfach ausprobieren, wenn in den Browser-Einstellung die Cookies ausgeschaltet werden. Eine weitere Möglichkeit eine Session-ID mitzuführen, ist sie als Parameter in die URL zu schreiben. Allerdings muss sie dann an alle Links in der generierten Seite angehängt werden. In der Klasse HttpServletResponse ist die Methode String encodeURL(String urlToEncode) definiert, die die Session-ID als Parameter an die URL anhängt. Um das folgende Beispiel auszuprobieren, müssen im Browser die Cookies ausgeschaltet werden.

import java.io.IOException;
import java.io.PrintWriter;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;

public class URLSession extends HttpServlet {
  public void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
    response.setContentType("text/html");
    PrintWriter out = response.getWriter();
    out.println("<HTML>");
    out.println("<HEAD><TITLE>Sessions mit URL-Encoding</TITLE></HEAD>");
    out.println("<BODY>");
    try {
      HttpSession session = request.getSession(true);
      Integer sessionCounter = new Integer(0);
      if(!session.isNew()) {
        sessionCounter = (Integer)session.getValue("session.counter");
        sessionCounter = new Integer(sessionCounter.intValue() + 1);
      }
      session.putValue("session.counter", sessionCounter);
      out.println("session.isNew = " + session.isNew() + "<BR>");
      out.println("sessionCounter = " + sessionCounter + "<BR>");
      out.println("session.getId = " + session.getId() + "<BR>");
      out.println("request.getRequestedSessionId = " + request.getRequestedSessionId() + "<BR>");
      out.println("request.isRequestedSessionIdFromCookie = " + request.isRequestedSessionIdFromCookie() + "<BR>");
      out.println("request.isRequestedSessionIdFromURL = " + request.isRequestedSessionIdFromUrl() + "<BR>");
      out.println("request.isRequestedSessionIdValid = " + request.isRequestedSessionIdValid() + "<BR>");
      String url = response.encodeUrl(request.getRequestURI());
      out.println("<A HREF=\"" + url + "\">Reload</A>");
    } catch(Throwable t) {
      out.println("<pre<");
      t.printStackTrace(out);
      out.println("</pre<");
    }
    out.println("</BODY>");
    out.println("</HTML>");
    out.close();
  }
}

Sourcecode http://www.zimberfamily.de/zimbers/URLSession1

Bei dieser Art Sessionhandling ist wichtig zu beachten, dass bei der Definition von Formularen die in der URL der ACTION definitierten Parameter nicht mit übertragen werden. in diesem Fall muss die Session-ID in einem HIDDEN-Field übergeben werden. Da der Name des Session-ID Parameters von der Servlet-Engine generiert wird, ist es nötig diesen auszulesen, um weiterhin das Sessionhandling der Servlet-Engine benutzen zu können.

import java.io.IOException;
import java.io.PrintWriter;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;

public class URLSession2 extends HttpServlet {
  public void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
    response.setContentType("text/html");
    PrintWriter out = response.getWriter();
    out.println("<HTML>");
    out.println("<HEAD><TITLE>Sessions mit URL-Encoding</TITLE></HEAD>");
    out.println("<BODY>");
    try {
      HttpSession session = request.getSession(true);
      Integer sessionCounter = new Integer(0);
      if(!session.isNew()) {
        sessionCounter = (Integer)session.getValue("session.counter");
        sessionCounter = new Integer(sessionCounter.intValue() + 1);
      }
      session.putValue("session.counter", sessionCounter);
      out.println("session.isNew = " + session.isNew() + "<BR>");
      out.println("sessionCounter = " + sessionCounter + "<BR>");
      out.println("session.getId = " + session.getId() + "<BR>");
      out.println("request.getRequestedSessionId = " + request.getRequestedSessionId() + "<BR>");
      out.println("request.isRequestedSessionIdFromCookie = " + request.isRequestedSessionIdFromCookie() + "<BR>");
      out.println("request.isRequestedSessionIdFromURL = " + request.isRequestedSessionIdFromUrl() + "<BR>");
      out.println("request.isRequestedSessionIdValid = " + request.isRequestedSessionIdValid() + "<BR>");
      String url = response.encodeUrl(request.getRequestURI());
      out.println("<FORM ACTION=\"" + request.getRequestURI() + "\" METHOD=GET>");
      if(url.indexOf(session.getId()) != -1) {
        String encodedUrl = response.encodeUrl(url);
        String paramName = getSessionParamName(encodedUrl, session.getId());
        out.println(
          "<INPUT TYPE=HIDDEN NAME=" + paramName +
          " VALUE=" + session.getId() + ">"
        );
      }
      out.println("<INPUT TYPE=SUBMIT VALUE=Reload>");
    } catch(Throwable t) {
      out.println("<pre<");
      t.printStackTrace(out);
      out.println("</pre<");
    }
    out.println("</BODY>");
    out.println("</HTML>");
    out.close();
  }

  private String getSessionParamName(String url, String sessionID) {
    System.out.println("url = " + url);
    int index = url.lastIndexOf(sessionID);
    String paramName = url.substring(0, index -1);
    System.out.println("paramName = " + paramName);
    index = paramName.lastIndexOf("&");
    if(index == -1) {
      index = paramName.lastIndexOf("?");
    }
    paramName = paramName.substring(index + 1);
    System.out.println("paramName = " + paramName);
    return paramName;
  }
}

Sourcecode http://www.zimberfamily.de/zimbers/URLSession2

Created with Vim Zurück Weiter