Projekt Systementwicklung Dr. Klaus Höppner Hochschule Darmstadt Wintersemester 2009/2010 1 / 32 Wie kommen Daten von einem Webserver? In der Praxis existieren verschiedene Wege, wie ein Server einem Client zu einer Anfrage per HTTP ein Resultat liefert: Statische Seite (HTML-Dokument) Ergebnis eines CGI-Skripts Ergebnis von durch den Webserver interpretierten Code (Server Side Includes SSI, Active Server Pages ASP, PHP) Ergebnis der Verarbeitung durch einen Applikationsserver (Java Server Pages JSP, Java Servlets) 2 / 32 Java-Applikationsserver Eine Referenzimplementation eines Java-Applikationsservers stellt Apache Tomcat dar. Dieser besteht aus einem Servlet-Container, in dem Webapplikationen als Servlets ausgeführt werden, Compiler und Laufzeitumgebung für Java Server Pages (JSP) Tomcat ist in Java geschrieben und daher auf diversen Plattformen lauffähig. In Produktionsumgebungen wird Tomcat meist mit dem Apache Webserver so kombiniert, dass statische Inhalte vom Webserver und dynamische Inhalte transparent über das Apache JServ Protocol (AJP) von Tomcat geliefert werden. 3 / 32 Handout S. 1
HTTP-Requests Beim Aufruf einer Seite schickt der Browser einen HTTP-Request an den Server. Hierbei gibt es zwei Methoden: GET Hier werden zu übermittelnde Daten (Formulareingaben) innerhalb des URL-Query-Strings übertragen. Vorteil (und gleichzeitig Nachteil): Es sind Bookmarks auf Formular-Daten möglich, Daten sind in der History des Browsers sichtbar. POST Hier werden Formular-Daten getrennt vom Query-String übertragen. Hierdurch sind die Daten nicht offen sichtbar, es können praktisch beliebig große Datenmengen (z. B. Bilddateien) übertragen werden. 4 / 32 Ausführung von Servlets Tomcat stellt den Container für die Servlets zur Verfügung. Daher muss für diese beim Aufruf keine eigene Laufzeitumgebung gestartet werden, Servlets sind daher i. A. schneller als CGI-Skripte. Die Zuordnung von einem URL-Pfad zu einem konkreten Servlet erfolgt anhand der Konfiguration in web.xml. Diese definiert Webapplikationen mit einem Servlet-Namen. Diesem Name wird zugeordnet: ein Java-Servlet-Klasse ein URL-Pfad Die Zuordnung erfolgt dann durch URL-Pfad Servlet-Name Servlet-Klasse 5 / 32 Aufbau eines Servlets Eigene Servlet-Klassen erben i. A. von javax.servlet.http.httpservlet. Diese Klasse besitzt zwei wesentliche Methoden, die überladen werden können: doget zur Behandlung von GET-Requests, dopost zur Behandlung von POST-Requests. Beide Methoden erhalten als Parameter: HttpRequest req mit Informationen über den Request, HttpResponse resp zum Füllen mit den Informationen, die zurück geliefert werden. 6 / 32 Handout S. 2
Beispiel-Servlet import java.io.*; import javax.servlet.servletexception; import javax.servlet.http.*; public class Servlet1 extends HttpServlet { @Override protected void doget(httpservletrequest req, HttpServletResponse resp) throws ServletException, IOException { resp.setcontenttype("text/html"); PrintWriter out = resp.getwriter(); out.println("<html>"); out.println("<body>"); out.println("hallo Welt!"); out.println("</body>"); out.println("</html>"); 7 / 32 Deployment der Klasse Damit das Servlet benutzt werden kann, muss es in Tomcat platziert und konfiguriert werden. Hierfür wird im Tomcat-Verzeichnis unterhalb von webapps ein Unterverzeichnis cnam erstellt, das wiederum die Unterverzeichnisse WEB-INF und WEB-INF/classes enhält. In WEB-INF wird dann die Mapping-Datei web.xml, in WEB-INF/classes die Class-Dateien platziert. 8 / 32 Deployment der Klasse (Forts.) <?xml version="1.0" encoding="iso-8859-1"?> <web-app xmlns="http://java.sun.com/xml/ns/j2ee" xmlns:xsi="http://www.w3.org/2001/xmlschema-instance" xsi:schemalocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd" version="2.4"> <display-name>hello World Application</display-name> <description>beispiel</description> <servlet> <servlet-name>helloservlet</servlet-name> <servlet-class>servlet1</servlet-class> </servlet> <servlet-mapping> <servlet-name>helloservlet</servlet-name> <url-pattern>/test1</url-pattern> </servlet-mapping> </web-app> 9 / 32 Handout S. 3
Analyse Nach Aufruf von http://localhost:8080/cnam/test1 wird festgestellt, dass die Pfadkomponente /test1 (bzgl. des Kontextes /cnam) zu dem Servlet-Namen HelloServlet gehört. Zu diesem Servlet-Namen gehört die Servlet-Klasse Servlet1. Da es sich um einen GET-Request handelt, wird von diesem Servlet die Methode doget aufgerufen. Für die Antwort wird zuerst bekannt gemacht, dass es sich um eine HTML-Seite handelt. Dann wird mit getwriter() ein PrintWriter für das Response-Objekt geholt. In diesen wird dann HTML-Code geschrieben. 10 / 32 Schaubild des Ablaufs 11 / 32 Reagieren auf übergebene Parameter protected void doget(httpservletrequest req, HttpServletResponse resp) throws ServletException, IOException { resp.setcontenttype("text/html"); String name = req.getparameter("name"); if (name==null) { name = "Unbekannter"; PrintWriter out = resp.getwriter(); out.println("<html>"); out.println("<body>"); out.format("hallo %s\n", name); out.println("</body>"); out.println("</html>"); 12 / 32 Handout S. 4
Die Klasse HttpRequest Die Klasse HttpServletRequest bietet folgende Methoden: String getrequesturi() liefert den Pfad-Anteil des URI, String getquerystring() liefert den Query-String, String getmethod() liefert die Requestmethode, z. B. GET, String getheader(string name) liefert den Header-Eintrag zu name, Enumeration getheadernames() liefert eine Aufzählung aller Header-Zeilen 13 / 32 Die Klasse HttpRequest (Forts.) Die URL http://localhost:8080/cnam/test2?name=klaus ergibt somit req.getheader("host") req.getrequesturi() req.getquerystring() localhost:8080 /cnam/test2 name=klaus Die Klasse HttpResponse 14 / 32 Was ein Servlet dem Client als Antwort zurück liefert, wird durch das Objekt der Klasse HttpResponse bestimmt, das Parameter von doget/dopost ist. Hier sind die folgende Methoden wichtig: void setcontenttype(string type) bestimmt den Typ der zurück gesendeten Daten, PrintWriter getwriter() liefert den Writer, in den die Antwortdaten geschrieben werden, OutputStream getoutputstream() dto., aber für binäre Daten. 15 / 32 Handout S. 5
Arbeiten mit Sessions Ein Server hat keine Gedächtnis... wenn ein Client eine URL anfordert (und hierdurch ein Servlet ausgeführt wird), weiß das Servlet nicht, dass derselbe Client kurz vorher eine andere URL angefordert hat. Dies führt oft zu Problemen. Beispiel: Wenn ein Client eine Datenabfrage machen will, soll zunächst die Berechtigung geprüft werden. Hierzu soll jede Anfrage zunächst auf eine Seite zum Einloggen mit Namen und Passwort umgeleitet werden. Nach Prüfen der eingegebenen Nutzerdaten soll dann ein Servlet tatsächlich die Daten liefern. Aber woher was das Servlet, dass der Client sich korrekt angemeldet hat (es sei denn, dieser schickt bei jeder Anfrage die Login-Daten von neuem)? 16 / 32 Die Klasse HttpSession Ein Gedächtnis über verschiedene Request hinweg kann durch Session-Objekte realisiert werden. Eine Session ist dabei realisiert durch: eine Session-ID, die die Session eindeutig identifiziert, (meistens) eine temporäre Datei auf dem Server, in der sich Daten gemerkt werden können, einen so genannten Cookie im Browser des Clients, in dem die Session-ID enthalten ist. 17 / 32 Die Klasse HttpSession (Forts.) Das Session-Management bei Java-Servlets wird durch die Klasse HttpSession realisiert. Für einen HttpRequest kann mit der Methode getsession() das Session-Objekt, das zu dem Request gehört, referenziert werden. Falls noch keine Session existiert, wird diese angelegt. Die Klasse besitzt folgende Methoden: String getid() die Session-Id, String getattribute(string name) liefert den Wert des Parameters name zur aktuellen Session, Enumeration getattributenames() liefert ene Aufzählung aller Session-Parameter. long getcreationtime()/getlastaccessedtime() die Zeit des Anlegens bzw. letzten Verwendung der Session in ms seit dem 1.1.1970 18 / 32 Handout S. 6
Beispiel public class MyServlet extends HttpServlet { @Override protected void dopost(httpservletrequest req, HttpServletResponse resp) throws ServletException, IOException { resp.setcontenttype("text/html"); PrintWriter out = resp.getwriter(); HttpSession session = req.getsession(); if (session.getattribute("items")==null) { session.setattribute("items", new ArrayList<String>()); List<String> items = (List<String>) session.getattribute("items"); if (req.getparameter("item")!=null) { items.add(req.getparameter("item")); 19 / 32 Beispiel (Forts.) out.println("<html>\n<body>"); out.println("<h1>einkaufsliste</h1>"); out.println("<table>"); for (String item : items) { out.format("<tr><td>%s</td></td>\n", item); out.println("</table>"); out.println("<form method=\"post\">"); out.println("<input type=\"text\" name=\"item\">"); out.println("<input type=\"submit\">"); out.println("</form>"); out.println("</body>\n</html>"); @Override protected void doget(httpservletrequest req, HttpServletResponse resp) throws... { dopost(req, resp); 20 / 32 Java Server Pages Die bisher vorgestellten Servlets haben HTML-Code erzeugt, der aus dynamischen und statischen Anteilen bestand. Da dieser HTML-Code über die normalen Ausgabebefehle von Java geschrieben wird, ist die Ausgabe des statischen Anteils eher unübersichtlich und mühsam. Ist der dynamische Anteil der erzeugten HTML-Seite eher gering, bieten sich anstelle von (oder ergänzend zu) Servlets Java Server Pages (JSP) an. Diese sehen aus wie HTML-Code, der mit speziellen Tags angereichtert werden kann, die Java-Code enthalten. 21 / 32 Handout S. 7
Beispiel 1 <%@ page import="java.util.date" %> <% Date d = new Date(); %> <html> <body> <p>es ist gerade <%= d %></p> </body> </html> oder kürzer <%@ page import="java.util.date" %> <html> <body> <p>es ist gerade <%= new Date() %></p> </body> </html> 22 / 32 Beispiel 2 <html> <body> <ul> <% int i=10; while (i!=0) { %> <li><%= --i %></li> <% %> </ul> </body> </html> 23 / 32 Tags in JSP In JSP existieren die folgenden Tags: <%... %> zum Einbetten von Java Code. Hier werden Ausdrücke normal mit Semikolon beendet. Anweisungsblöcke müssen nicht abgeschlossen sein (s. voriges Beispiel). <%@... %> für Direktiven, z. B. zum Einfügen anderer JSP-Dateien, oder zum Importieren von Java-Klassen bzw. -Paketen (s. erstes Beispiel). <%=... %> für einen Ausdruck (ohne Semikolon!), der ausgewertet und dessen Ergebnis in die Ausgabe geschrieben wird. 24 / 32 Handout S. 8
Verknüpfung von Servlets und JSP Man kann Servlets und JSP miteinander verbinden, indem ein Servlet Eingabedaten auswertet, verarbeitet und das Ergebnis berechnet, das Servlet das Ergebnis in den HTTP-Request zurück schreibt und diesen an eine JSP-Datei weiterleitet, in der JSP dann das Ergebnis aus dem HTTP-Request gelesen und dargestellt wird. Auf den folgenden Seiten wird nun die Einkaufsliste mit Servlet und JSP realisiert. 25 / 32 Einkaufsliste (Servlet) public class MyServlet extends HttpServlet { protected void dopost(httpservletrequest req, HttpServletResponse resp) throws... { HttpSession session = req.getsession(); if (session.getattribute("items")==null) { session.setattribute("items", new ArrayList<String>()); List<String> items = (List<String>) session.getattribute("items"); if (req.getparameter("item")!=null) { items.add(req.getparameter("item")); req.setattribute("items", items); RequestDispatcher view = req.getrequestdispatcher("result.jsp"); view.forward(req, resp); 26 / 32 Einkaufsliste (JSP) <%@ page import="java.util.list" %> <html> <body> <% List<String> items = (List<String>) request.getattribute("items"); %> <p>anzahl Items: <%= items.size() %></p> <ul> <% for (String item: items) { %> <li><%= item %></li> <% %> </ul> <form method="post"> <input type="text" name="item"> <input type="submit"> </form> </body> </html> 27 / 32 Handout S. 9
Das Entwurfsmuster Model-View-Controller Für Webanwendungen wird oft das MVC-Pattern (Model-View-Controller) verwendet. Dies unterteilt die Anwendung in drei Schichten: Modell-Schicht: großer Teil der Geschäftslogik, von der Webapplikation unabhängig. Z. B. DB-Abfragen, Parsen von XML. Meist normale Java-Klassen. Präsentations-Schicht für (HTML-)Ansicht des Resultats, oft ein JSP, bekommt Daten von Steuerungs-Schicht. Steuerungs-Schicht zuständig für Interpretation der Anfrage, Aufruf der notwendigen Methoden der Modell-Schicht, Interpretation der vom Modell erhaltenen Daten, Aufruf und Übergabe der darzustellenden Daten an Präsentationsschicht. 28 / 32 Schaubild HttpServlet doget(request: HttpRequest: resp: HttpResopnse) dopost(request: HttpRequest: resp: HttpResopnse) Client GET MyServlet {Controller doget(...) Auswertung Response Daten Daten Anfage Request Forward Daten Daten-Modell JSP-Datei {View 29 / 32 Beispiel Als einfaches Beispiel könnte man folgende Anwendung erstellen: eine Klasse WeltFormel, die für einen Planeten die Antwort auf die Frage aller Fragen berechnet (leider noch nicht implementiert), ein Servlet, dass einen HTTP-Request mit übermitteltem Planetennamen entgegennimmt, ein Welt-Objekt anlegt und dieses das Ergebnis der Weltformel berechnen lässt. eine JSP, die vom Servlet das Ergebnis bekommt und dieses per HTML darstellt. 30 / 32 Handout S. 10
Beispiel: Servlet import javax.servlet.http.httpservlet;... import welt.weltformel public class WeltFormelServlet extends HttpServlet { protected void doget(httpservletrequest req, HttpServletResponse resp) throws ServletException, IOException { String planet = (String) req.getparameter("planet"); WeltFormel welt = new WeltFormel(planet); int result = welt.calculate(); req.setattribute("result", result); RequestDispatcher view = req.getrequestdispatcher("result.jsp"); view.forward(req, resp); 31 / 32 Beispiel: JSP <html> <body> <% String = (String) request.getparameter("planet"); int result = (int) request.getattribute("result"); %> <p>die Antwort auf die Frage aller Fragen für den Planeten <%= planet %> lautet <%= result %>.</p> </body> </html> 32 / 32 Handout S. 11