|
|
Im Folgenden wird anhand eines Anwendungsbeispiels demonstriert, wie mittels eines Servlets auf einer Datenbank navigiert werden kann. Die Anwendung beinhaltet die folgenden Schritte:
Im Folgenden wird das Zusammenspiel der hierzu notwendigen Klassen erläutert. Zunächst wird der Aufbau der <HTML> <HEAD> <TITLE>Servlet-Verbindung Spielerdatenbank</TITLE> </HEAD> <CENTER> <H1> Servlet-Verbindung Spielerdatenbank</H1></CENTER> <LI> <A HREF="SpielerRegistrierung.html">Spielerregistrierun g Online!</A></LI> </UL> </BODY> </HTML> In dieser Liste wird das Servlet ohne Parameter gestartet. An späterer Stelle wird ersichtlich, dass ein Aufruf ohne Parameter dazu führt, dass die Liste aller Spieler angezeigt wird. Die Ausgabe des Startfensters ist in Abb. 13-9 angegeben.
Abb. 13.9: Startseite der Anwendung Möchte der Spieler sich beim System anmelden, so muss der entsprechende Link ausgewählt werden. Anschließend wird die im Folgenden beschriebene Webseite verwendet. Es sei darauf hingewiesen, dass im Folgenden der Aufruf des Servlets mit einem Parameter erfolgt. Mittels des Parameters kann das Servlet unterscheiden, in welchem Operationsmodus (Registrierung oder Anzeige) gearbeitet werden soll.
<HTML> <HEAD> <TITLE>Spielerregistrierung</TITLE> </HEAD> <CENTER><H1>Spielerregistrierung</H1></CENTER> <LI>Bitte geben Sie die notwendige Information ein.</LI> </OL> <CENTER><TABLE BORDER=0 CELLPADDING=5 WIDTH="95%" > <TR> <TD WIDTH="36%"><B>Vorname </B></TD> </TR> <TD WIDTH="43%"><B>Nachname</B></TD> </TR> <TD WIDTH="36%"><B>E-Mail </B></TD><TD WIDTH="50%"><INPUT type="text" name="Email"size="20"></TD> </TR> </TABLE></CENTER> <INPUT type="reset" value="Reset Form"name="B2"></CENTER> </FORM> </BODY> </HTML> In der HTML-Seite wird ein Formular aufgebaut, mit dessen Hilfe das Servlet gestartet werden kann (/servlets/SpielerDBServlet). Des Weiteren werden zwei Buttons angelegt, mit denen die Daten abgeschickt (Register) und zurückgesetzt (Reset) werden können. Die Ausgabe dieser Webseite ist in Abb. 13-10 angegeben.
Abb. 13.10: Anmeldung über eine Webseite Die Implementierung des Servlets verwendet die zwei Klassen SpielerDBServlet und Spieler. Die eigentliche Funktionalität des Servlets ist in der Klasse SpielerDBServlet realisiert. Die Klasse Spieler dient der Formatierung der Webseiten, die als Ergebnis an den Spieler zurückgesendet werden. Zunächst wird die Implementierung der Klasse SpielerDBServlet vorgestellt. Zu Beginn der Klasse werden zuerst die notwendigen Importierungen vorgenommen. Anschließend werden die Variablen definiert, die zum späteren Datenbankzugriff notwendig sind.
import javax.servlet.*; // data members Anschließend wird eine Variable angelegt, mit der später das Spiel gestartet werden kann, falls gewünscht. Die Funktion der init-Methode wurde im Rahmen dieses Kapitels bereits beschrieben.
Server derSchiffeServer; super.init(config); } Die nun folgende doGet-Methode realisiert den Datenbankzugriff und stellt die Namen der bereits enthaltenen Spieler fest bzw. regelt das Einfügen eines neuen Namens in die Datenbank.
public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException{ // Verbinden mit der Datenbank Class.forName("sun.jdbc.odbc.JdbcOdbcDriver"); displayStatement = dbConnection.prepareStatement("select * from SpielerDatabase"); registerStatement = dbConnection.prepareStatement("insert into SpielerDatabase" + "(Vorname, Nachname, Email)" + " values (?, ?, ?)"); } catch (Exception e){ cleanUp(); } In Abhängigkeit dessen, ob der Spieler den Parameter Register übergeben hat, wird nun anschließend der Spieler registriert und das Spiel gestartet oder die Liste aller Spieler ausgegeben.
String userOption = null; // hidden form field "Register" was present // Beim Registrieren wird der Server (Schiffe versenken) gestartet if(myThread == null) { myThread = new StartTheSchiffeServer(); } } else { // simply display the Players } // close database connectivity } Im Anschluss daran muss die Methode doPost implementiert werden. Da vorab unbekannt ist, ob doPost oder doGet verwendet werden, wird doPost auf doGet abgebildet.
public void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { doGet(request, response); } Hat der Spieler entschieden, sich die Namen und die Spielstände der anderen Spieler ausgeben zu lassen, so wird im Anschluss die Methode displaySpieler aufgerufen, die die Datenbankabfrage vornimmt und eine HTML-Datei erzeugt, die an den Spieler zurückgesendet wird.
public void displaySpieler(HttpServletRequest request, HttpServletResponse response){ Spieler aSpieler = null; response.setContentType("text/html"); Zuerst wird eine Instanz der Klasse Spieler erstellt, mit der die Ausgabe formatiert werden kann. Anschließend wird der MIME-Datentyp auf text/html gesetzt und ein Ausgabestrom erzeugt, mit dessen Hilfe das Ergebnis an den Client zurückgegeben werden kann.
// build the html page heading // build the html body // build the table heading // execute the query to get a list of the Players // build the table body Zuerst werden die statischen HTML-Daten aufgebaut, die Informationen wie Gewonnen oder Gespielt enthalten. Anschließend wird die Datenbankanfrage ausgeführt. Die Ergebnisse der Datenbankanfrage werden im Folgenden in eine HTML-Tabelle eingefügt. Hierzu wird eine while-Schleife verwendet, in der jede Datenbankzeile mittels der Klasse Spieler formatiert wird. Nach dem Einsetzen der Daten kann die Verbindung zur Datenbank geschlossen werden.
while (dataResultSet.next()){ aSpieler = new Spieler(dataResultSet); } // build the table bottom // build html page bottom // build complete html page // add the copyright statement Den Abschluss dieser Methode bildet das Schreiben der nun fertigen HTML-Seite auf den Stream, der anschließend geschlossen werden kann. Eine Antwort, die von dieser Methode generiert wurde, ist in Abb. 13-11 angegeben.
// now let's send this dynamic data } catch (Exception e){ cleanUp(); } } In der nun folgenden Registrierung müssen zuerst die Daten ausgewertet werden, die über das HTML-Formular an den Server geschickt wurden. Hierzu werden wiederum Funktionen der Klasse Spieler verwendet. Im Anschluss daran muss die HTML-Seite aufgebaut werden, die dem Client das Ergebnis der Operation anzeigt. Generell ist die Funktionalität, mittels derer die HTML-Seite aufgebaut wird, der der Methode displaySpieler sehr ähnlich. Auch hier wird ein Stream erzeugt, in den die fertige HTML-Seite geschrieben wird.
Abb. 13.11: Ausgabe einer Spielerliste
public void registerSpieler(HttpServletRequest request, HttpServletResponse response) { try { response.setContentType("text/html"); // create a new Spieler based on the form data // set sql parameters registerStatement.setString(FIRST_NAME_POSITION, aSpieler.getFirstName()); registerStatement.setString(EMAIL_POSITION, aSpieler.getEmail()); // execute sql // build confirmation page // add the copyright statement // now let's send this dynamic data } catch (Exception e){ cleanUp(); } } Die im Folgenden beschriebenen Methoden erfüllen Hilfsfunktionen, die bspw. die korrekte Beendigung der Aufrufe umsetzen.
public void cleanUp(){ try { System.out.println("Closing database connection"); } catch (SQLException e) { e.printStackTrace(); } } System.out.println("SpielerDBServlet: destroy"); } return "<i>Spielerregistrierung-Servlet, v.1 <br> (c) OpenJava 1999</i>"; } Den Abschluss der Klasse bildet die innere Klasse StartTheSchiffeServer, mittels derer nach einer erfolgreichen Registrierung das Spiel gestartet werden kann. Nach erfolgreicher Registrierung ergibt sich die in Abb. 13-12 dargestellte Ausgabe.
// inner class to start the server public StartTheSchiffeServer(){ super(); } try{ derSchiffeServer = new Server(); } catch (Exception ie){} } } }
Abb. 13.12: Erfolgreiche Registrierung Aufgabe der im Folgenden beschriebenen Klasse Spieler ist die Auswertung der Formularinformation bzw. der Aufbau von HTML-Tabellen zur Darstellung des Ergebnisses. Zuerst wird die Klasse definiert bzw. Variablen deklariert.
import java.sql.*; // data members // constructors } In den nun folgenden Konstruktoren wird in Abhängigkeit vom Argument eine Auswertung des Formulars bzw. der Datenbankantwort vorgenommen.
public Spieler(HttpServletRequest request){ lastName = request.getParameter("Nachname"); } try { // assign data members } catch (SQLException e){ e.printStackTrace(); } } Anschließend folgen die Methoden, mit denen auf einzelne Variablen zugegriffen werden kann. Es wurde bereits mehrfach erläutert, dass geschützte Variablen nur mit Zugriffsmethoden ausgelesen werden können. Auch wenn diese Methoden sehr kurz sind, erfüllen sie dennoch einen wichtigen Zweck.
// accessors return lastName; } return firstName; } return email; } return gespielt; } return gewonnen; } return verloren; } Den Abschluss der Klasse bilden Hilfsroutinen, die bspw. den Aufbau von Strings realisieren.
// methods String replyString = ""; } // returns data as HTML formatted un-ordered list String replyString = "<ul>"; } // returns data formatted for an HTML table row String replyString = ""; replyString += tdBegin + gespielt + tdEnd; } } |
|
|
