Grundlagen

1. Was ist ein Servlet?
2. Lebenszyklus eines Servlets
• Initialisierung eines Servlets
• Service-Methoden
• Beendigung eines Servlets
3. Grundstruktur eines HTTP-Servlets
4. Datenbankanbindung über Servlets
• Verbindungsaufbau
• SELECT
• INSERT / DELETE / UPDATE
• Fehlerbehandlung
• Transaktionen
• Verbindungsabbau

Was ist ein Servlet?

Der Einsatz von Servlets macht überall dort Sinn, wo sich der Inhalt einer HTML-Seite häufig ändert, der Inhalt einer HTML-Seite von Nutzereingaben abhängig ist oder in Datenbanken vorhandene Daten über ein Web-Interface zugänglich sein sollen.

Servlets sind grundsätzlich protokollunabhängig und können somit Anforderungen der unterschiedlichsten Art verarbeiten. Am häufigsten werden sie aber für Web-Anwendungen eingesetzt, die das HTTP-Protokoll verwenden. Neben dem Package javax.servlet wird deshalb zusätzlich noch das Package javax.servlet.http von der Java™ Servlet API zur Verfügung gestellt, welches speziell HTTP-spezifische Methoden bereitstellt.

Die Beschreibung der Funktionalität der Java™ Servlet Technologie wird im Weiteren am HTTP-Servlet erklärt, da dieses die breiteste Anwendung findet und auch im Beispielprojekt des elektronischen Produktkataloges eingesetzt wird.

Lebenzyklus eines Servlets

Erhält ein solcher Web-Server die Anforderung eines Clients für ein bestimmtes Servlet, so prüft er zunächst, ob bereits eine Instanz dieses Servlets existiert. Sollte dies nicht der Fall sein, so wird die entsprechende Servlet-Klasse geladen, davon eine Instanz erzeugt und deren Initialisierung ausgeführt, bevor dann schließlich die eigentliche Service-Methode des Servlets aufgerufen werden kann, welche die Client-Anforderung bearbeitet und die dynamisch generierte HTML-Seite zurückgibt. Die Beendigung eines Servlets erfolgt ebenfalls duch den Web-Server, indem er die Finalisierungsmethode des Servlets aufruft.

Initialisierung eines Servlets

Ein erneutes Aufrufen der Methode init() ist durch den WEB-Server nur nach erneutem Laden des Servlets möglich. Hierzu muß der Web-Server aber zunächst die Methode destroy() des Servlets aufrufen, um es zu beenden.

Hinweis: Beim Auftreten eines Fehlers während der Initialisierung sollte mit dem Auslösen einer UnavailableException reagiert werden.

Service-Methoden eines Servlets

Die Hauptaufgabe der Service-Methoden besteht dabei unter anderem aus dem Extrahieren der Informationen aus der Client-Anforderung, dem Zugriff auf externe Ressourcen und der Generierung einer Antwort für den Client, wobei die Auswertung der Client-Anforderung und der Zugriff auf externe Ressourcen aber nicht zwingend erforderlich ist. Beispielsweise könnte ein Servlet als einzigen Service eine HTML-Seite generieren, deren Inhalt die aktuelle Server-Zeit darstellt. In solch einem Falle wäre ein Extrahieren der Informationen aus der Client-Anforderung unnötig, da zur Ermittlung der Server-Zeit keinerlei Informationen seitens des Client erforderlich sind. Der Aufruf der Service-Methoden des Servlets erfolgt durch den Web-Server nach entsprechender Anforderung eines Clients.

Beim HTTP-Servlet stehen folgende Service-Methoden zur Verfügung:

• doGet(HttpServletRequest req, HttpServletResponse resp)
• doPost(HttpServletRequest req, HttpServletResponse resp)
• doPut(HttpServletRequest req, HttpServletResponse resp)
• doDelete(HttpServletRequest req, HttpServletResponse resp)
• doTrace(HttpServletRequest req, HttpServletResponse resp)
• doOptions(HttpServletRequest req, HttpServletResponse resp)

Beendigung eines Servlets

Grundstruktur eines HTTP-Servlets

    import java.io.*;
    import javax.servlet.*;
    import javax.servlet.http.*;

    public class SomeServlet extends HttpServlet {

      public void init()
      throws ServletException {
        // optional

        // Aktionen, die bei der Initialsierung ausgeführt werden
      }

      public void doGet(HttpServletRequest request,
                        HttpServletResponse response)
      throws ServletException, IOException {
        // aus "request" können HTTP-Header und HTML-Formulardaten
        // des Clients ausgelesen werden

        // über "response" können HTTP-Response-Daten ermittelt werden
        // (z.B. Content Type spezifizieren, Cookies).

        PrintWriter out = response.getWriter();
        // "out" dient der Ausgabe der zu generierenden HTML-Seite
        // an den Browser
      }

      public void destroy() {
        // optional

        // Aktionen, die beim Beenden ausgeführt werden
      }
    }
    

Sowohl die Methode doGet(HttpServletRequest req, HttpServletResponse resp) als auch die Methode doPost(HttpServletRequest req, HttpServletResponse resp) besitzen zwei Übergabeparameter vom Typ HttpServletRequest und HttpServletResponse. Während die übergebene Variable vom Typ HttpServletRequest Methoden zum Extrahieren der Informationen aus der Client-Anforderung bereitstellt, stellt die Variable vom Typ HttpServletResponse Methoden zur Verfügung, welche beispielsweise die Spezifizierung des Medientyps (content type) und des PrintWriter zur Ausgabe der generierten HTML-Seite an den Client erlauben.

Das folgende Beispiel demonstriert ein HTTP-Servlet, welches eine HTML-Seite generiert, die die aktuelle Serverzeit und den Hostnamen des Client zum Inhalt hat.

    import java.io.*;
    import java.util.Date;
    import javax.servlet.*;
    import javax.servlet.http.*;


    public class ServerTime extends HttpServlet {

        public void doGet(HttpServletRequest request,
                          HttpServletResponse response)
        throws IOException, ServletException
        {
            // Medientyp festlegen und PrintWriter spezifizieren
            response.setContentType("text/html");
            PrintWriter out = response.getWriter();
            // Generierung der HTML-Seite
            out.println("<HTML><HEAD></HEAD><BODY>");
            out.println("Serverzeit: " + new Date() + "<BR>");
            // Ermitteln der Client-URL aus dem Request
            out.println("URL des Client: " + request.getRemoteHost());
            out.println("</BODY></HTML>");
        }

        public void doPost(HttpServletRequest request,
                           HttpServletResponse response)
        throws IOException, ServletException
        {
            // Übergabe an doGet(), falls Anforderung mittels POST
            doGet(request, response);
        }
    }
    

Datenbankanbindung über Servlets

Zum Zugriff auf relationale Datenbanken wird die JDBC™ 2.x API verwendet. Diese stellt Klassen und Methoden für den Zugriff auf eine sehr große Anzahl unterschiedlicher Datenbanksysteme zur Verfügung.

Verbindungsaufbau

    
    import java.sql.*;
    ...

    // Objekt für Datenbankzugriff
    private Connection conn = null;
    ...

    // Definition des Treibers
    DriverManager.registerDriver(new oracle.jdbc.driver.OracleDriver());
    // Connect-String definieren
    String cstr = "jdbc:oracle:thin:user/passwd@141.57.9.9:1521:IMNLehre"
    // Verbindungsaufbau herstellen
    conn = DriverManager.getConnection(cstr);

    ...
    

1. Treiber: Im vorliegenden Beispiel wird mittels jdbc:oracle:thin der Thin-Treiber von Oracle™ angesprochen, welcher den Datenbankzugriff über das Internet gestattet.
2. Nutzername/Passwort: Für user und passwd sind Nutzername und Passwort anzugeben, um sich an der Zieldatenbank erfolgreich anmelden zu können.
3. Name der Datenbank: Mit 141.57.9.9:1521:IMNLehre wird eine Datenbank namens IMNLehre angesprochen, die sich auf dem Host mit der IP 141.57.9.9 befindet und dort über Port 1521 erreichbar ist. Wird das Servlet auf dem gleichen Host ausgeführt, auf dem sich auch die Zieldatenbank befindet, so reicht an dieser Stelle die Angabe des Datenbanknamens. Die Angabe von Host-IP und Port-Nummer ist also nur dann erforderlich, wenn Servlet und Datenbank auf unterschiedlichen Hosts laufen.

SELECT

    
    Vector result = new Vector();
    // Formulierung der Abfrage
    String sql = "SELECT ename, eid FROM emp";
    // Initialisierung des Statement-Objektes
    Statement sment = conn.createStatement();
    // Ausführung der Query und Zuweisung der Ergebnismenge
    ResultSet rs = sment.executeQuery(sql);
    // alle Zeilen der Ergebnismenge abarbeiten
    while (rs.next()) do {
        // Auslesen der Ergebnismenge
        result.addElement(rs.getString("ename"));
        result.addElement(rs.getString("pid"));
    }
    // Schließen der beiden Objekte
    rs.close();
    sment.close();
    

Zum Verarbeiten der einzelnen Datensätze der Ergebnismenge stellt das ResultSet-Objekt zahlreiche Methoden zur Verfügung. Im Beispiel wird mittels next() der Satzzeiger der Ergebnismenge um den Wert 1 erhöht. Dabei ist unbedingt zu beachten, daß der Satzzeiger zu Beginn vor dem ersten Datensatz der Ergebnismenge steht. Es muß also immer zuerst die next()-Methode aufgerufen werden, bevor auf den ersten Datensatz zugegriffen werden kann. Sollte die Ergebnismenge leer sein oder der Satzzeiger hinter dem letzen Datensatz positioniert sein, so liefert next() den Wahrheitswert FALSE zurück.

Der Zugriff auf den Inhalt der Datensätze des ResultSet-Objektes erfolgt im Beispiel über die Methode getString(String columnName). Hierbei wird der Wert des angegebenen Attributes als Zeichenkette zurückgegeben. Die Methoden zur Rückgabe anderer Datentypen werden hier ausführlich aufgelistet. Neben der dargestellten Möglichkeit, auf die Attribute eines Datensatzes über ihren Namen zuzugreifen, können diese auch über ihren Index angesprochen werden. Hierbei ist aber zu beachten, daß dieser Spaltenindex bei 1 beginnt, und nicht etwa bei 0. Für unser Beispiel wäre dann die Methode getString(int columnIndex) zu verwenden.

Nach Verarbeitung der Ergebnismenge sollten die Statement- und ResultSet-Objekte mittels der Methode close() wie im Beispiel geschlossen werden, um nicht mehr benötigte Ressourcen für andere Operationen freizugeben.

INSERT / DELETE / UPDATE

    // Formulierung der Anweisung
    String sql = "DELETE FROM emp WHERE ename LIKE 'Maier'";
    // Initialisierung des Statement-Objektes
    Statement sment = conn.createStatement();
    // Ausführung der Anweisung
    int cnt = sment.executeUpdate(sql);
    // Schließen des Statement-Objektes
    sment.close();
    

Im Beispiel ist außerdem zu erkennen, daß in einer SQL-Anweisung vorkommende Zeichenketten wie in Oracle™ üblich in Hochkommata eingeschlossen werden müssen.

Fehlerbehandlung

    public void Methodenname()
    throws SQLException {
      // Definition von Datenbankoperationen
    }
    

    try {
        // Definition von Datenbankoperationen
    }
    catch (SQLException e) {
        // Anweisungen zur Fehlerbehandlung
    }
    

Transaktionen

Zu diesem Zweck muß unbedingt mittels der Methode setAutoCommit(boolean autoCommit) des Connection-Objektes die Eigenschaft der automatischen Transaktionsbestätigung deaktiviert werden. Die Bestätigung einer Transaktion beziehungsweise deren Rücknahme beim Auftreten eines Fehlers erfolgt über die Methoden commit() beziehungsweise rollback(). Die Syntax für den Transaktionsbetrieb wird nachfolgend dargestellt.

    try {
      // automatische Transaktionsbestätigung deaktivieren
      conn.setAutoCommit(false);

      // mehrere voneinander abhängige Schreiboperationen

      //Bestätigung der vorgenommenen Änderungen
      conn.commit();
    }
    catch (SQLException e) {
      // Rücknahme der bisherigen Änderungen
      conn.rollback();

      // optional weitere Behandlung des Fehlers
    }
    

Verbindungsabbau

    conn.close();