So, schönen Tag.
Ich begrüße Sie zur Fortsetzung der Vorlesung Angewandte Informatik 2.
Letztes Mal haben wir uns mit einigen Themen beschäftigt.
Ich muss kurz das Mikro ein bisschen runterstellen, ich glaube das ist
etwas zu laut.
Letztes Mal haben wir uns mit einigen Themen noch beschäftigt, die mit
XML zu tun hatten.
Mit XSL, mit der Präsentation von Dokumenten, die in XML beschrieben
sind.
Ich hatte Ihnen einiges erzählt zu der XSLT, zur Transformation von
XML -Dokumenten in andere Dokumente, andere baumartig strukturierte
Objekte und hatte Ihnen auch kurz skizziert, wie man daraus
Präsentationen erstellen kann.
Entweder indem man direkt HTML oder XHTML Dokumente erzeugt oder indem
man aus dem, was dort als Struktur entstanden ist, sogenannte
Formatting Objects erstellt und dann genau angibt, was oder wie diese
Formatting Objects darzustellen sind.
Wir sind dann in das Kapitel 3 eingestiegen und haben uns mit Client
-Server -Technologien beschäftigt.
Insbesondere mit serverlastigen Implementationen und wir werden uns
auch noch eine andere Client-lastige Art anschauen, die mit JavaScript
möglich ist.
Das Wesentliche dabei ist, dass Sie feststellen, wie man es eigentlich
erreichen kann, dass ein Web-Auftritt nicht nur statisch über solche
HTML oder XHTML Dokumente erzeugt wird, die man irgendwann einmal
geschrieben hat, sondern dass solche Dokumente dynamisch erzeugt
werden.
Das geht eben nur durch entsprechende Programme, wie Servlets, Active
Server Pages und Ähnliches.
Grundlage ist das Hypertext Transfer-Protokoll, das ja erst das World
Wide Web ermöglicht hat.
Ich hatte Ihnen ganz kurz gesagt, wie das aufgebaut ist.
Darauf kommen wir noch an ein paar Stellen zurück.
Wir hatten uns dann ganz kurz angesehen, dass es Verfahren gibt, mit
denen man die Auslieferung von Dokumenten im World Wide Web
beschleunigen kann, effizienter machen kann, dadurch, dass man
Dokumente an vielen Stellen verfügbar macht oder abrufbar macht, aber
auf eine Art und Weise, die der normale Anwender gar nicht sieht.
Ich hatte Ihnen dann angefangen, etwas über das Common Gateway
Interface zu erzählen, die Grundlage dafür, dass man überhaupt
zwischen Client und Server in Bezug auf Webseiten kommunizieren kann,
Informationen austauschen kann, Skripte anstoßen kann und so weiter.
Wir hatten uns dann ein Beispiel angeschaut, bei dem man dieses
übliche Hello World Beispiel einmal ausgeführt hat, beziehungsweise
ein ähnliches.
Hier wird nicht Hello World gemacht, sondern Hello und dann irgendein
Name, der eingegeben wird.
Das Interessante dabei war, dieses war die letzte Folie, da gehe ich
jetzt wieder rauf.
Hier sehen wir eine Möglichkeit, wie man Informationen aus einer HTML
-Seite abruft vom Server, beziehungsweise wie man etwas beim Server
anstößt.
Wir haben hier folgende Möglichkeiten angedeutet auf dieser Folie.
Ein Form-Element innerhalb von HTML, das es erlaubt, eine Aktion
anzustoßen auf dem Server.
Die Aktion bezieht sich auf ein Skript, in diesem Fall ein Perl
-Skript, ein kleines Perl-Programm, das auf dem Server liegt.
Und die Methode für diesen Aufruf soll ein GET sein, also das zugrunde
liegende Protokoll ist HTTP.
Die GET-Methode wird verwendet und es wird dann im HTML-Dokument
hingeschrieben, Name, daneben ein Eingabefeld, das ist dieses Input
-Type Text und der Name dieses Feldes, das Attribut Name bekommt hier
den Wert Name.
Dann wird ein weiteres Feld hier, also es ist so, ich kann hier ein
Attribut erstellen oder eine Variable erstellen, das ist das, was hier
durch Name gleich Name gemacht wird.
Wir sehen das hier unten in dem, was daraus erzeugt wird.
Es wird eine Variable erzeugt, die an das Skript Hallo.pl
weitergegeben werden soll und der Wert, der dort angegeben wird,
dieses Wort Michael, das wird halt eingegeben in dieses Input-Feld.
Das heißt, der Name dieses Feldes wird in diesem Fall das kleine Name,
der Name einer Variablen und der Wert der Variablen ist der Text, der
dort eingegeben wird.
Und daneben gibt es noch ein weiteres Feld, das aber kein Eingabefeld
ist, in das Sie Text eingeben können, sondern hier haben Sie ein
Submit -Feld, das heißt, sobald dieses Feld aktiviert wird, dadurch,
dass Sie mit der Maus darauf klicken, wird die Aktion angestoßen,
diesen Inhalt an den Webserver zu übertragen.
Das heißt, es wird ein Aufruf an den Webserver erzeugt, der diese Form
hat, die hier unten angegeben ist.
Dann steht hier die URI, die übertragen wird, es wird das Skript
aufgerufen, wie es in der Form der Aktion dort angegeben ist und
daneben der Parameter für diesen Aufruf und dahinter, wie üblich, die
Angabe des Protokolls, das eingesetzt wird.
Ich hatte letztes Mal schon darauf hingewiesen, GET bezieht sich
darauf, oder ist die Methode, bei der die Information für den Aufruf
vollständig in dieser URI, hier vorne in dem CGI-Bin, Hallo PL, Name
gleich Michael, das ist die Information, die gebraucht wird, sowohl
das Programm wird angestoßen, als auch der Parameter wird hier in
dieser Zeile übergeben.
Und genau diesen Aufruf sehen Sie in der URL-Zeile Ihres Browsers,
wenn Sie auf den Submit-Button in der HTML-Seite raufklicken, dann
wird entsprechend dieser HTTP-Aufruf erzeugt und Sie können das in der
URL -Zeile genau sehen, dass diese Seite aufgerufen wurde.
Es gibt halt eine Alternative dazu, das ist nicht GET zu verwenden,
sondern POST.
Wenn Sie POST verwenden, dann wird die Information, die gleiche
Information wie vorher, auf andere Art und Weise übertragen.
In diesem Fall wird also nicht der Query-String, so als URL mit Aufruf
des Programms und anschließend die Parameter, Namen und Werte erzeugt,
sondern die Information, die übertragen wird, die Dateninformation,
die folgt in dem Rumpfteil des HTTP-Requests direkt hinter dem Header.
Das heißt, wir haben hier den Header, bei dem jetzt als erstes nicht
GET steht, sondern POST.
Und es steht jetzt nur der Aufruf des Programms dort, also dieses
Scripts hallo.pl und der Protokollname.
Dahinter können noch ein paar mehr Informationen folgen, die jetzt
irrelevant sind.
Aber zu dem Header gehört auch noch, dass hier Content-Length gleich
12 steht, nämlich die Länge des Datenteils, die Länge des Rumpfes ist
gerade 12 Byte.
Und dieser Datenteil enthält halt die Daten, die vom Programm hallo.pl
gelesen werden müssen oder verwendet werden müssen, um richtig
ausgeführt zu werden.
Wir hatten ja gesehen, was das hallo.pl machen soll.
Das war ja vorher schon angegeben worden.
Das soll halt hallo, in dem Fall Michael, schreiben, beziehungsweise
den Wert der variablen Name.
Und das Wichtige ist, in diesem Fall natürlich haben wir hier eine
Länge 12 Byte, aber im Prinzip kann dieser Datenteil beliebig groß
sein.
Das, was Sie über eine Zeile in der UR11 bei einem Query Screen
übertragen können, ist in der Größe begrenzt.
Da können Sie nicht beliebig viel reinschreiben.
Außerdem ist alles, was Sie bei der Get-Methode machen, im Prinzip für
den Benutzer sichtbar.
Wenn Sie das über Post machen, dann ist erstmal diese Begrenzung nicht
da.
Sie können ja beliebig viel reinschreiben in diese Body, dieses HTTP
-Requests.
Und das, was Sie schicken ist, oder was geschickt wird durch diesen
Fondsaufruf, das, was geschickt wird, ist für den Benutzer nicht
sichtbar.
Weil es ja nicht in der Browserzeile zu sehen ist.
Das ist durchaus ein sinnvoller Unterschied.
Nicht, dass man irgendwas vereinblichen will vor dem Benutzer.
Nur was bringt es dem Benutzer, wenn er da einen ewig langen String in
seinem Fenster sieht?
Es ist viel sinnvoller, das zu beschränken und die Inhalte halt in den
Rumpf dieses HTTP-Requests zu verschicken.
Welche Methode der Datenübermittlung man macht, kann man in dem
Programm, also in dem hallo.pl, abfragen.
Je nachdem, was dort gemacht wird, werden die Informationen ja anders
übertragen, muss das Programm anders darauf reagieren.
Also hier ist nochmal dieses CGI-Beispiel oder dieses Perl-Beispiel
angegeben.
Wir haben jetzt aber als erstes eine Variable Request Method.
Und da wird also als erstes abgefragt, wie die Request-Methode ist.
Das heißt, es wird eine Umgebungsvariable abgefragt.
In der Umgebungsvariable werden alle möglichen Parameter dieses HTTP
-Aufrufs abgespeichert.
Und in der Umgebungsvariable Request Method, die hier angegeben ist,
da kann man halt den Wert rausholen.
Der Wert ist entweder Get oder Post.
Und jetzt kann man den Wert abfragen.
Wenn der also gerade Get ist, dann steht die Information für diesen
Aufruf in dem Query-String drin.
Das heißt, dann kann der Wert aus dem Query-String, aus der
Umgebungsvariable Query-String, direkt rausgeholt werden.
Das wäre dann Form-Info-Gleich-Env-Query-String.
Andernfalls wäre das halt die Methode Post.
Und dann ist es wichtig zu sehen, wie lang ist denn der Inhalt dieses
Rumpfes.
Das heißt, wie viele Bytes müssen jetzt von dem Programm gelesen
werden.
Deswegen Wert der variablen Content-Length.
Und dann wird aus dem Input-Strom gelesen, also das Programm, hallo
.pl.
Das kann ja lesen aus Standard-In und liest dort diese Bytes, die in
der umgebungsvariablen Content-Length standen und weist den Wert zu,
der dort gelesen wurde, der lokalen Variablen Form-Info.
Und dann kann man daran gehen, die Form-Info, genau wie wir das in dem
Programm voriges Mal schon gesehen haben, zu verwenden.
Man weiß, das ist in diesem Fall eine Variable und ein Name.
Und das wird also hier entsprechend aufgeteilt anhand dieses Zeichens
gleich.
Wie gesagt, hatte ich letztes Mal schon angedeutet, irgendwo steht in
der Form-Info ein Gleichheitszeichen.
Der linke Teil ist der Variablen-Name, der rechte Teil der Wert.
Wird zumindest so interpretiert.
Und wenn also dieser als Variablen-Name interpretierte Teil gerade
Name ist, dann wird halt Hallo und der Wert dieser Variablen
ausgegeben, nämlich der Wert, der hier auf der rechten Seite gestanden
hat.
Und wenn das nicht so eine Variable ist, wird diese gesamte Form-Info
ausgegeben mit einem Fragezeichen dahinter.
Also, nur, dass man nochmal sieht, was man hier machen kann.
Ein sehr einfaches Beispiel.
Sie werden sicherlich in konkreten Anwendungen das wesentlich
komplizierter machen.
Nur solche komplizierteren Beispiele passen nicht auf eine Folie.
Das ist eine Methode, dass Sie ein Programm wie ein Perl-Script zum
Beispiel verwenden, um Inhalte, die der Benutzer übertragen hat, zu
verwenden und daraus eine entsprechende Antwort zu erzeugen.
Das heißt, dadurch habe ich abhängig von dem, was der Benutzer
eingegeben hat, Informationen erzeugt, die auf dem Browser angezeigt
werden.
Es gibt dafür noch eine ganze Reihe weiterer Möglichkeiten.
Eine Möglichkeit sind die sogenannten Server-Side-Includes.
Ich habe Ihnen hier zwei Links angegeben, wo Sie dazu alles Mögliche
nachlesen können.
Aber ich kann Ihnen das Wesentliche auch kurz, ein paar Punkte dazu
kurz nennen.
Was sind Server-Side-Includes?
Sie haben ein HTML-Dokument.
Also hier steht irgendwie HTML.
Und dann gibt es sogenannte Server-Side-Includes.
Das heißt, Sie haben hier irgendwo ein Tag.
Da steht dann hier dieses spitze Klammer, Ausrufezeichen, zwei Striche
und ein Nummernzeichen.
Und alles, was dahinter steht, wird jetzt von dem HTTP-Protokoll
interpretiert, als etwas, was der Server auswerten muss.
Der Server schickt ja die HTML-Seite in dem HTTP-Response an den
Client, der diesen HTTP-Request rausgeschickt hatte.
Und beim Rausschicken wird zunächst mal diese Seite, die geschickt
werden soll, durchgesehen.
Und dann steht hier solch ein Teil drin, irgendwie beendet mit zwei
Strichen und einem spitzen Klammer, so wie das hier steht.
Und das, was dort drin steht, wie gesagt, muss vom Server ausgewertet
werden.
Server -Side-Includes.
Das heißt, der Server soll Informationen dort reinschreiben.
Was für Informationen könnten das sein?
Also hier ist ein Beispiel.
Sie haben hier ein dynamisches, sogenanntes dynamisches HTML mit SSI.
Also dynamisch, weil Sie halt jedes Mal, wenn Sie diese Seite
aufrufen, andere Ergebnisse kriegen.
Was soll gemacht werden?
Es soll Datum, Uhrzeit auf dem Server-Rechner ausgegeben werden.
Das können Sie natürlich nicht auf einer statischen Seite explizit
hinschreiben.
Das muss ja aktuell immer dort eingebettet werden.
Damit das gemacht wird, brauchen Sie halt eine entsprechende
Möglichkeit.
Das wird hier über dieses Server-Side-Include gemacht.
Also hier wird einfach ein Echo-Befehl ausgeführt auf einer Variablen.
Und dieser Variablen, die hier ausgewertet wird, ist eine Variable auf
Server -Seite.
DateLocal ist also das aktuelle Datum auf der Server-Seite.
Und wenn Sie dieses aufrufen, dann wird also zunächst mal stehen,
Datum, Uhrzeit auf dem Server-Rechner.
Im Doppelpunkt dahinter steht das Datumsformat mit Datum, Uhrzeit.
Und unten drunter steht noch etwas, Ihr www-Browser.
Und dann wird hier noch eine Variable angegeben.
Bar http-useragent.
http-useragent ist ein Parameter, der bei dem HTTP-Request automatisch
übertragen wird.
Das fügt der Browser automatisch ein.
Und das heißt, hier kann der Server abfragen, was ist eigentlich der
Browser, der von dem anfragenden Benutzer verwendet wird, der auf dem
Client gerade läuft, aus dem diese Frage erzeugt wurde.
Und kann also auf der Seite schreiben, Ihr www-Browser, meinetwegen
Firefox oder Internet Explorer oder was immer.
Und dann wird in diesem Beispiel ein Perl-Skript ausgeführt.
Hier steht also dieser übliche Dummy-Name.
Irgendetwas, was immer gerade ausgeführt werden soll.
Also Sie können da beliebig viel machen.
Und auch so etwas ist also ein Server-Site-Include.
Auch hier muss der Server etwas machen.
Das ist also ein exec-Befehl an den Server.
Und dieser exec-Befehl soll also ein CGI-Skript anstoßen.
Und das CGI-Skript ist dieses blafaser.pl.
Das heißt, Sie haben hier eine Reihe von Möglichkeiten, Seiten
entsprechend dynamisch mit Inhalt zu füllen.
Und das genauere dazu finden Sie auf den URL-Seiten.
Hier sind nochmal die einzelnen Befehle aufgeführt.
Das eine, was Sie gesehen haben gerade eben, war das Echo.
Sie schreiben einfach das, was als Wert einer Variablen ermittelt
wird, als Text an die Stelle.
Das andere ist ein exec, dass Sie ein Skript ausführen.
Entweder ein CGI-Skript oder irgendein anderes Programm.
Sie können also eine Kommandozeile dort hinschreiben.
Oder es wird hier eine Fehlermeldung gemacht oder ein
Dateigrößenformat oder was immer wird hier angegeben.
Also die Konfiguration wird hier etwas konfiguriert.
Dann kann es sein, dass Sie die Feilgröße angeben wollen.
F-Size bedeutet also, dass Sie dann hinter F-Size schreiben müssen.
Feil gleich und entsprechend den Namen der Datei.
Dann wird die Dateigröße dort angegeben.
Oder Sie wollen den Zeitstempel der Datei haben.
Das heißt, Sie wollen den Zeitpunkt der letzten Modifikation angeben.
So etwas finden Sie auf vielen Webseiten.
Sie können am Ende unten reinschreiben, Zeitpunkt der letzten
Änderung.
Das wird also ganz einfach über ein Server-Site include realisiert.
Das wird vom Server automatisch ausgeführt.
Und damit hat man dann diesen Zeitstempel der Datei dort explizit mit
reingeschrieben.
Oder include, da könnte man irgendwas reinschreiben, also ein Bild
oder was immer.
Nur, dass Sie sehen, es gibt dort eine Reihe verschiedener
Möglichkeiten, solche Inhalte auf Server-Seite zu erzeugen und beim
Aufruf einer HTTP-Seite bei Erzeugung der HTTP-Response in diese HTML
-Seite mit einzufügen.
Das ist aber nicht das Einzige.
Es gibt dafür noch mehr Möglichkeiten.
Es gibt sogenannte Java-Servlets und Java-Server-Pages.
Das ist etwas, was von Sun entwickelt wurde und auf Java basiert und
im Prinzip die Möglichkeiten von CGI-Skripten und Server-Site-Includes
über Java zur Verfügung stellt.
Es gibt ja immer so die verschiedenen Standards, die entwickelt
werden.
Es gibt halt die Java-basierten Dinge und halt andere Dinge, die etwas
allgemeiner verwendbar sind.
Der Vorteil hierbei ist, dass man halt auf die Möglichkeiten von Java
-Programmen hier zurückgreifen kann.
Java-Programme sind ja in gewissen Grenzen plattformunabhängig und
deswegen gut portierbar.
Sie kennen alle die Vorteile von Java, dass es halt objektorientiert
ist, was bei diesen anderen nicht unbedingt in dem Fall immer
gewährleistet sein muss.
Sie haben eine effizientere Ausführung, weil bei CGI-Skripten ist es
so, dass wir bei jedem Aufruf eines CGI-Skripts einen neuen Prozess
starten.
Das ist zeitaufwendig.
Bei Java-Server-Pages, insbesondere bei Java-Servlets, ist es so, dass
diese Servlets einmal gestartet werden und dann können sie durch
mehrere aufeinanderfolgende Aufrufe angesprochen werden und müssen
nicht immer wieder als neuer Prozess gestartet werden.
Was Sie brauchen, wenn Sie so ein Servlet machen, ist ein entsprechend
servletfähiger Web-Server.
Ein Standard-Web-Server, auf dem also solche Java-Servlets ausgeführt
werden können, ist der Apache Tomcat, den Sie als eine Ergänzung eines
Apache -Web-Servers installieren können.
Und darauf kann man solche Java-Servlets ausführen.
Ich habe noch ein paar kleinere Beispiele, ich will aber, wie immer,
Ihnen nicht zu viel erzählen darüber.
Java-Servlets können also folgendes machen.
Schauen wir uns an, was dieses Beispiel hier alles enthält.
Wir haben eine Package, in der alles Mögliche drinstehen soll und
entsprechend die ganzen APIs, die gebraucht werden innerhalb dieses
Java -Programms.
Und dieses Servlet ist also ein Objekt, das erbt von der Klasse HTTP
Servlet.
Und in diesem Fall haben wir also eine Methode doGet.
Diese Methode doGet soll also ein HTTP-Request erzeugen.
Wir haben hier Request und Response drin.
Der Inhalt dieser Methode sieht so aus, dass wir bei der Response als
Inhalt Text plain reinschreiben.
Sie erinnern sich vielleicht, das hatten wir gesehen bei dem einen
kleinen Beispiel über HTTP-Responses, dass man angeben muss, von
welcher Art der Inhalt ist, den man hier abliefert.
Als Antwort auf ein Request.
Und hier wird also etwas geschrieben.
Da muss also erstmal ein Response über ein Get-Writer, ein Output
-Stream, aufgemacht werden.
Und da kann ich halt mit dem üblichen Printline hier Hello World
schreiben.
Also das ist ein einfaches Servlet, um Hello World zu schreiben.
Sicherlich nicht das typische Beispiel für ein Servlet, weil das
völlig statisch ist.
Aber es soll nur andeuten, welcher Art hier etwas getan werden kann.
Und aufrufen kann man es halt, wenn man entsprechend die Domain kennt,
auf der dieses Servlet steht, dann wird man dort halt in dem
Verzeichnis Servlets entsprechend diese Klasse, dieses Objekt
aufrufen, eben dieses Servlet, das dieses Hello World schreiben soll.
Sie können, das ist hier nicht geschehen, also diese Bemerkung hier
unten, die Variable Request, kann dazu verwendet werden, um eingehende
Daten auszulesen.
Das ist klar, mit dem HTTP-Request werden eine ganze Reihe Inhalte
mitgeliefert, Informationen mitgeliefert, auf die ich vorher schon
hingewiesen habe.
Und die kann man natürlich innerhalb dieses Servlets verwenden.
Das ist hier nicht geschehen, sondern hier wird nur diese Response
erzeugt.
Da wird gar nichts verwendet, weil ich ja nur einen statischen Text
reinschreibe.
Und man kann natürlich alles mögliche in diese Response reinschreiben,
mit den Möglichkeiten, die man in Java-Programmen zur Verfügung hat.
Und natürlich die Möglichkeiten, die in dieser API für Servlets
vorgesehen sind.
Hier habe ich jetzt genau das Request mitverwendet.
Hier haben wir wieder so eine Methode, doGet, wobei wir auch wieder
hier Request und Response als Variablen drin haben und wie vorher
Response, SetContentType, Text, Plain.
Und beim Schreiben verwenden wir die Request-Variable und verwenden
dort den Parameter, also GetParameterName.
Das heißt, wir gehen davon aus, dass wir in der Parameterliste eine
Variable mit Namen Name haben.
Und wenn also im QueryString dieser Parameter auftaucht, wird der
entsprechende Wert ausgegeben.
Das heißt, das, was wir vorher schon gesehen hatten, wenn in einem
String oder in dem QueryString diese Parameterliste mit dem
entsprechenden Wert steht, dann wird dieser entsprechende Name hier
hinter dem Hallo ausgegeben.
Also immer wieder das gleiche Beispiel, nur dieses Beispiel gibt eben
wieder die Interaktion, die man natürlich gerade über solche Servlets
darstellen will.
Das Hello World Beispiel ist eigentlich nicht sinnvoll, weil wir dort
ja nur eine statische Seite erzeugen.
Noch ein Beispiel, hier wollen wir ein bisschen mehr machen.
Es ist ja so, dass wir bei solchen Queries in der Regel nicht nur
einen Parameter reinschreiben werden, sondern eine ganze Reihe.
Also wenn Sie sich irgendwelche Queries anschauen, ist klar, man kann
eine beliebige Anzahl von Parametern reinschreiben.
Und dazu gibt es halt Standardmethoden.
Also ich kann mir zum Beispiel den Request anschauen.
Und in dem Request gibt es jetzt in diesem QueryString eine Reihe von
Parametern, eine Reihe von Variablen.
Und jetzt werden einfach alle Parameternamen hier extrahiert.
Und das wird eine Liste, All Names, eine Aufzählung.
Und jetzt kann ich in dieser Aufzählung der Parameternamen, die ich
gerade herausgezogen habe, natürlich etwas machen.
Ich kann also diese in üblicher Art und Weise verwenden, dass ich über
alle Elemente dieser Enumeration iteriere und einfach jetzt etwas
schreibe.
Also ich möchte in diesem Beispiel etwas machen.
Ich möchte die Parameternamen und die Werte alle aufschreiben.
Also hier wird von All Names, das ist das was hier die Enumeration
war, wird das nächste Element rausgeholt.
Und es wird der Wert als String dargestellt und wird entsprechend
gedruckt auf dem Ausgabestrom.
Und dahinter wird halt eine neue Zeile geschrieben.
Und dann wird wieder ein String erzeugt, ein String Array erzeugt.
Es wird also ein String Array erzeugt, weil es manchmal auch sein
kann, dass man mehrere Werte hinter einen solchen Parameter schreibt.
Also getParameterValues für thisName.
Da wird also der Name des Parameters hingegeben als Parameter für
diesen Aufruf.
Und es werden alle Werte, die dort stehen, im Weiteren verwendet.
Wir haben jetzt hier wieder einen solchen String.
allValues hat eine bestimmte Länge.
Wenn dieser Wert oder dieses Array die Länge 1 hat, ist es der
Standardfall, wir haben nur einen Wert angegeben.
Für den Fall wird dieser Wert genommen, thisValue gleich allValues
Null, also das was an dieser ersten Position steht.
Und jetzt kann es natürlich sein, dass dieser Wert die Länge 0 hat.
Es wäre ein leerer String als einziges Argument für diesen Namen.
Das heißt, das ist ein Parameter, für den überhaupt kein Wert
abgeliefert wurde.
Also wenn der Wert die Länge 0 hat, wird einfach hingeschrieben in die
Ausgabe leer.
Andernfalls, wenn die Länge nicht 0 ist, wenn also tatsächlich
mindestens ein Zeichen gestanden hat, dann wird genau der Wert
thisValue herausgeschrieben.
Wenn jetzt die Länge nicht 1 war, dann wird einfach für alle Werte,
die dort stehen in diesem Array, der entsprechende Wert ausgegeben.
Also da wird jeweils hingeschrieben ein I, der Wert der Laufvariablen
I.
Dahinter wird ein Punkt und eine Klammer zugeschrieben.
Und dann wird der entsprechende Parameterwert dort reingeschrieben.
Das heißt, wir haben dann irgendeinen Parameterwert in der Ausgabe
stehen.
Also hier bei dem Beispiel wäre das vielleicht unser Name gewesen oder
was immer.
Und darunter würde dann stehen, da ich mit I gleich 0 anfange, würde
ich hier stehen haben 0 Punkt Klammer zu, 1 Punkt Klammer zu und
entsprechend jeweils die Werte bis zu dem letzten Wert, der dort
gelesen wurde.
Das ist entsprechend ganz einfach die Liste der Werte zu diesem einen
Parameter.
Und dann wäre das das, was dieses Servlet erzeugen soll.
So, das also als weiteres Beispiel.
Jetzt haben wir auch bei den SSEs und bei den Perl Scripts haben wir
gesehen, da kann man Umgebungsvariablen verwenden, man kann Query
Springs verwenden.
Die CGI-Umgebungsvariablen können auch in den Servlets abgerufen
werden durch entsprechende Methoden.
Sie können also den Inhalt der Umgebungsvariablen auch im Java Servlet
auslesen, indem Sie diese Methode GetQueryString aufrufen.
Dann wird halt gerade diese Umgebungsvariable QueryString, wobei das
hier, da fehlt das Unterstreichen, diese Variable wird dort
ausgelesen, genauso GetRemoteUser würde den Wert dieser
Umgebungsvariablen auslesen, PathInfo und so weiter, da würden alle
diese möglichen Umgebungsvariablen von CGI, also von diesem Common
Gateway Interface, hier über Methoden zur Verfügung stehen.
Und als weiteres, ein Punkt, den wir bisher noch nicht angesprochen
haben, auf den wir gleich kommen werden, Sie können innerhalb dieser
Servlets auch Cookies erzeugen.
Was Cookies sind, werde ich gleich noch genauer sagen.
Sie können also hier drin ein Cookie erzeugen, in dem zum Beispiel
User drinsteht und 123.
Also diese beiden Werte würden dort drinstehen.
Eine Variable, User und dahinter der Wert 123.
Und Sie würden bei der Antwort an den anfragenden Client in der HTTP
-Response ein Cookie anfügen, das also lokal auf dem Client
gespeichert werden soll und diese Information, also hier User 123,
enthalten soll.
Warum schreibe ich irgendetwas bei den Benutzern rein?
Also Sie wissen alle, Sie können bei Ihrem Browser oder im Browser
werden Cookies gespeichert.
Man kann das unterbinden.
Warum verwendet man solche Cookies?
Einfach, um es dem Server zu ermöglichen, bestimmte Informationen
abzulegen, lokal beim Client.
Die dann beim nächsten Aufruf der gleichen URL wieder im HTTP-Request
mitgeschickt werden.
Und das heißt, wenn das nächste Mal die gleiche URL vom Client
abgesandt wird, dann wird die Cookie-Information mitgeliefert und der
Server kann diese Cookie-Information auswerten und weiß irgendetwas
über den Benutzer oder was immer er sich gemerkt hat in diesem Cookie,
über den letzten Besuch auf dieser Seite.
Gut, das also ganz kurz.
Sie haben also eine ganze Reihe von Möglichkeiten in diesen Java
-Servlets.
Und Sie können hier auch, das waren also jetzt die ganzen Servlet
-Möglichkeiten, in Java-Server-Pages, also Java-Server-Pages sind im
Prinzip, Java-Server-Pages sind Seiten, die haben die Endung JSP, sind
aber im Prinzip HTML-Seiten, in denen Sie sogenannte Scriptlets drin
haben, da können Sie also diese, im Prinzip werden dort Servlets
erzeugt, da können Sie also dann über diese Art von Tags in einem HTML
-Dokument Servlets im Prinzip anstoßen und ganz ähnlich zu den Server
-Site -Includes können Sie hier über Java-ähnliche Strukturen oder
sprachliche Formulierungen auf Server-Seite Aktionen anstoßen.
Diese JSPs, also diese werden beim Aufruf zu Servlets umgeformt und
dieses Servlet liefert dann die gesamte Seite als Ergebnis, wertet
dabei diese eingesprengelten Scriptlets, wie es hier angegeben ist,
aus und erzeugt entsprechend die Informationen, die dort angestoßen
werden.
Und auch hier steht wieder etwas, dass einige Variablen als
vordefiniert verwendet werden, aber wenn man solch eine Java-Server
-Page schreiben muss, ist es klar, das habe ich Ihnen oft genug
gesagt, müssen Sie auf die entsprechenden Dokumentationen gehen und
sehen, was Sie dort alles an Variablen zur Verfügung haben.
Das sind hier nur so einige der Standard-Dinge, auf die man zugreifen
kann.
Dieses Beispiel hier, eine Seite, auf der dieses Scriptlet drin ist,
würde also umgeformt werden zu einem Servlet, bei dem unter anderem so
eine Anweisung drinsteht, dass z.B.
der Client Hostname, da wird dann der Remote Host entsprechend
aufgeschrieben.
Das, was hier steht, ist also genau das, was jetzt im letzten Beispiel
steht, hier wurde eine JSP-Expression, also so eine Java-Server-Page
-Expression eingesetzt und dass diese Art von Instruktionen an Ort und
Stelle ausgewertet wird, habe ich Ihnen schon deutlich gesagt.
Es ist etwas, was genau den Server-Side-Includes entspricht
und man kann auf diese Art und Weise dynamische Seiten erzeugen.
Hier nochmal zwei Beispiele.
Hier wird eine Variable definiert.
In diesem Fall haben wir eine solche Java-Server-Page-Expression oder
so einen Ausdruck.
Da wird eine Variable deklariert, eine Variable AccessCount und
initialisiert auf 0.
Und Sie wollen praktisch beim Aufruf der Seite als Wert angeben, wie
oft auf die Seite schon zugegriffen wurde.
Und zwar Anzahl der Zugriffe seit Reboot.
Dann wird hier entsprechend bei einem konkreten Aufruf der Seite, beim
Zugriff auf die Seite, der AccessCount um 1 erhöht und ausgegeben.
Anderes Beispiel.
Sie können zufallsmäßig irgendetwas erzeugen.
Sie wollen hier zufällig Kopf oder Zahl angeben.
Können Sie also durch Aufruf einer Funktion Math.random einen
Zufallswert erzeugen und entsprechend den Wert Kopf oder Zahl
schreiben.
Also nur nochmal als Beispiel dafür, was man mit solchen Server-Side
-Includes oder in diesem Fall eben nicht Server-Side-Includes, sondern
Java -Server-Pages alles machen kann.
Sie können die Möglichkeiten von Java hier ziemlich weitgehend
ausnutzen.
Insbesondere können Sie auch Java Beans erzeugen.
Ich gehe hier nicht auf die Java Beans jetzt genauer ein.
Beans hat eine Möglichkeit, wie man Programme als aktive Objekte
innerhalb von Java-Umgebungen verwenden kann.
Was wird hier gemacht?
Hier wird ein Bean aufgerufen innerhalb einer Java-Server-Page.
Und dieses Bean bekommt also einen Namen, Quad.
Und der Inhalt steht innerhalb, also der Name dieses Programms, dieser
Bean, oder das Programm ist abgelegt, unter HAL.quadrat.
Sie erinnern sich, HAL, das war vorher ein Package, in dem alle
möglichen Klassen abgelegt wurden.
Und jetzt wird hier Bezug genommen auf Methoden, die jetzt verwendet
werden sollen in dieser Java-Server-Page.
Es steht hier SetProperty, das heißt, es wird auf eine Set-Methode
zugegriffen in dieser Bean.quad.
Die Property ist Zahl, also es wird aufgerufen, eine Methode, SetZahl.
Und als Wert wird der Wert von Value reingegeben, im Prinzip wird hier
16 reingegeben.
Das ist also der Wert, der als Argument für diesen Aufruf gegeben
werden soll.
Und dann steht hier ein GetProperty, da wird auf eine Methode
zugegriffen, in diesem Bean, Quad, wiederum.
Property ist Quadzahl, also wird hier GetQuadZahl aufgerufen, das wird
ohne Parameter aufgerufen.
Wir wissen gar nicht, was das für Methoden sind, stehen nämlich auf
der nächsten Folie.
Hier steht in der Methode, also in diesem Java-Bean, steht folgendes
drin.
Wir haben die Klasse Quadrat, das wäre Halbpunkt Quadrat, was wir
aufgerufen haben.
Und da drin steht also jetzt die Methode SetZahl, da wird als
Parameter eine Zahl erwartet.
Und das Ergebnis ist also dieser Wert des Parameters.
Und es gibt eine Methode GetQuadZahl ohne Parameter.
Und die liefert zurück einen String, eine Zeichenkette, und zwar
liefert die zurück gerade Zahl mal Zahl.
Wobei das hier in dem Fall ein Parameter ist, der hier oben angegeben
wurde.
Also es ist ein bisschen kompliziert, soll nur ein bisschen andeuten,
wie vielfältig die Dinge sind, die man mit solchen Java Server Pages
machen kann.
Dieses Bean liefert, wie man hier sieht, dadurch, dass ich zunächst
mal einen Wert erzeugt habe, das SetZahl gemacht habe, zum Wert 16 auf
der vorigen Seite.
Hier hatten wir SetZahl 16 aufgerufen über diese Aktion und haben dann
über diese Aktion über GetQuadZahl den Wert im Prinzip geholt.
Und GetQuadZahl liefert eben gerade den quadrierten Wert, der vorher
da aufgerufen wurde, würde also entsprechend 16 zum Quadrat abliefern.
Eine etwas skurrile Anwendung.
Ich hätte auch irgendeine andere Anwendung hier hinschreiben können.
Aber es sollte einfach nur andeuten, dass man hier etwas mehr machen
kann, als das mit diesen ServerSideIncludes möglich war.
Kurzer Vergleich.
Was sind die Vorteile von Java Servlets gegenüber CGI?
Ich habe hier eine Plattformunabhängigkeit über diese ganze Java
Umgebung.
Ein Punkt ist, dass ich etwas effizienter arbeiten kann, da bei
Aufrufen des selben Skripts nicht immer wieder ein neuer Prozess mit
neuem Adressraum gestartet wird, sondern jeweils nur ein neuer Thread
erzeugt wird.
Und ich habe dadurch also die Möglichkeit auf dem gleichen Adressraum
immer wieder zuzugreifen und kann dadurch persistente Daten verwenden.
Und natürlich habe ich hier das Objektmodell.
Perl ist allerdings auch eine objektorientierte Sprache, insofern ist
der Vorteil gegenüber Perl nicht so sehr groß.
Aber ich habe halt die ganzen Programmiermöglichkeiten von Java zur
Verfügung und das ist schon ein Vorteil gegenüber den Dingen, die ich
mit den ServerSideIncludes machen kann.
Aber es gibt gute Anwendungen in beiden Richtungen.
Man muss sehen, was man in der konkreten Anwendungsumgebung einsetzen
will.
Auf Microsoft-Seite gibt es dann die Active Server Pages und auch die
sind wieder etwas, was den anderen Standards entgegengesetzt wird.
Active Server Pages basieren immer auf dem Microsoft Internet
Information Server.
Wenn man den nicht verwendet, kann man Active Server Pages nicht
sinnvoll einsetzen.
Also wenn Sie Active Server Page Technologie verwenden wollen, müssen
Sie den Microsoft Internet Information Server verwenden.
Und Sie können mit diesen Active Server Pages auch wieder eine ganze
Reihe von Aktionen auf dem Server starten.
Sie haben hier Möglichkeiten zur Verfügung, zum Beispiel auf das
Component Object Modell zuzugreifen.
Das heißt, Sie können auf eine Reihe von Objekten zugreifen, die Ihnen
alle möglichen Methoden und Anwendungen liefern.
Das ist sowas in eingeschränkter Form eine Art Broker, um Dienste
anzubieten.
Etwas, was wir später noch kennenlernen werden und in dem Namen CORBA,
den Component Object Request Broker, der aber ein wesentlich
allgemeiner ist als diese Möglichkeiten hier mit den Active Server
Pages.
Und das, was man hier machen kann, ist ein bisschen vergleichbar mit
den Java Server Pages und Servlets, bietet ein paar andere
Möglichkeiten.
Ich glaube aber, ich brauche wirklich auf die Einzelheiten hier nicht
einzugehen.
Sie haben gesehen, dass es viele Möglichkeiten gibt, HTML Seiten
dynamisch zu gestalten, dadurch, dass ich dort Inhalte einbaue.
Inzwischen wird man immer mehr auf noch etwas andere Technologien
eingehen oder ausweichen.
Ich werde darauf aber auch noch kommen, hier steht das .NET und das
wird also alles weiterentwickelt, wobei ich hier wirklich nicht viel
mehr machen möchte außer diesem kleinen Beispiel.
Hier haben wir also ein kleines Beispiel drin, ein Language Virtual
Basic Script.
Und hier wird eine Seite erzeugt, die folgendes macht.
In dem Titel steht einfach nur Beispiel und in dem Rumpf dieser Seite
wird im Prinzip abgefragt, ob die aktuelle Stunde größer ist als 18
oder kleiner als 6.
Das heißt, wenn Sie diese Seite aufrufen und lokal bin ich zwischen 18
und vor 6 Uhr, dann steht auf der Seite, es ist Nacht und ansonsten
steht dort, es ist Tag.
Also etwas, was auf Serverseite natürlich nur abgerufen wird.
Wenn solche Skripte zur Verfügung stehen an verschiedenen Stellen,
können Sie sehen, ist bei dem Server gerade Nacht oder Tag.
Was immer das für einen Sinn macht.
Ich hatte gerade eben PHP erwähnt, auch etwas, was bei dynamischen
Webseiten ganz wichtig ist.
PHP ist vor allen Dingen wichtig, weil Sie mit PHP eine gute
Möglichkeit haben, um auf Datenbanken zuzugreifen.
Und die Vielfalt von Daten, die in Webseiten eingebaut werden können,
wird eben häufig in Datenbanken verwaltet.
Dazu finden Sie dicke Bücher über PHP.
Ich kann also nur Ihnen, wie immer, kurze Sachen hier angeben.
Das hier, was hier steht, ist eine völlig untypische Art, PHP zu
verwenden.
Hier wird nämlich wieder nur Hello World geschrieben.
Sie sehen hier nur, wie so ein PHP-Aufruf in einer HTML-Seite
aussieht.
Sie haben hier, ähnlich wie diese Server-Site-Includes, einfach so
einen Teil als Tag eingefügt.
In diesem Fall mit Fragezeichen PHP.
Und dann wird hier halt irgendetwas geschrieben.
Also erstmal in einer Variablen zugewiesen.
Und dann wird das über ein Echo in die Ausgabe übernommen.
Ganz einfaches Beispiel.
Das Wesentliche ist die Unterstützung von Datenbanken.
Insbesondere wird MySQL verwendet.
Eine einfache Query-Sprache.
Wer von Ihnen hat schon mal MySQL verwendet?
Einige von Ihnen, insofern kennen Sie das, aber nur wenige.
Ist eine einfache Möglichkeit, Datenbanken zu implementieren.
Und ich mache jetzt einfach ein kurzes Beispiel dafür, wie man mit PHP
auf eine MySQL-Datenbank zugreifen kann.
Wir nehmen hier an, dass wir so eine MySQL-Datenbank haben, in der
eine Tabelle existiert mit fünf Feldern, ein Identifikator eines
Assistenten, also eines Assis, ein Vorname, ein Nachname, eine Adresse
und eine E-Mail-Adresse und entsprechenden Einträgen.
Und jetzt wird in diesem PHP-Skript, das jetzt gleich kommt, der 0.,
also der erste Eintrag, der Tabelle abgefragt.
Schauen wir uns an, wie das gemacht wird.
Wir haben diese PHP-Anfrage und es wird zunächst mal auf eine
Datenbank zugegriffen.
Auf dem localhost wird anonym zugegriffen, auf eine Datenbank D1.
Das $DB wird als eine Variable.
Der Variablen wird dieser Wert hier zugewiesen.
Es wird also verbunden mit dem localhost, Benutzer anonym, und es wird
jetzt auf die Datenbank D1 zugegriffen und hier als Variable dieses DB
übergeben.
Das heißt, das Connect wird hier bei diesem Aufruf der Datenbank
gemacht.
Dann wird ein Variable $result erzeugt, die als Wert gerade bekommen
soll das Ergebnis dieses Queries.
Und dieses Query ist halt ein Select, den ersten Eintrag, also Select
die Einträge aus der Tabelle Assis in dieser hier immer noch diese
Verbindung $DB dahinter und jetzt wird gedruckt der Vorname und es
wird ausgedruckt der Vorname, danach wird etwas formatiert, also
dieses %s//n geschrieben mit den üblichen Bedeutungen und es wird das
Ergebnis des SQL-Aufrufes hier abgeliefert, nämlich von dem 0.
Eintrag der Eintrag-Vorname und das wird halt entsprechend dann dort
als nächstes geschrieben und entsprechend wird der Eintrag zu dem
Attribut -Nachname abgeliefert, zum Attribut-Adresse, zum Attribut-E
-Mail.
Ein sehr einfaches Beispiel für eine solche Anfrage, das heißt wir
haben einmal eine Query und können dann das Ergebnis zu einer Anfrage
an die Datenbank, das in der Variablen $result angegeben ist, das
können wir weiter analysieren und können also über dieses MySQL-Result
aus der Variablen oder aus diesem Ergebnis des Aufrufs die
entsprechenden Parameter rausholen.
Das ist also ein einfaches Beispiel für so ein PHP-Skript.
Hier könnte man natürlich auch alle Einträge ausgeben, nicht nur den
0.
Eintrag, dann würde man entsprechend weitere Befehle verwenden, hätte
hier diese Art des PHP-Skripts drin.
Ich will das im Einzelnen gar nicht erläutern.
Ich habe genug dazu gesagt.
Wenn Sie PHP einsetzen, müssen Sie sich sowieso das Skript genauer
angucken.
Das Wesentliche ist halt, dass Sie Anfragen auf die Datenbank
schreiben können und die entsprechend dann aus dem Ergebnis, das
$result war das Ergebnis der Anfrage, können Sie halt auf
unterschiedliche Art und Weise die Inhalte rausziehen.
Also hier steht nochmal, was man halt dort machen kann, wenn Sie eine
PHP, so einen SQL-Query, wenn Sie das mit einem Query-String aufrufen,
Sie haben einen Aufruf zu einer PHP-Datei in der URL Ihres Browsers,
machen Sie einen Query-String, greifen dort auf einen PHP-Skript zu
oder auf eine PHP-Datei mit dem entsprechenden Query-String, der die
Variablen dort auflistet, dann werden halt durch PHP die
entsprechenden Variablen Wertpfade erzeugt und wenn Sie jetzt einen
neuen Assi in die Datenbank eintragen wollen, dann muss man das
natürlich in irgendeiner Art und Weise machen, z.B.
über eine HTML-Datei, über die Sie die Daten eingeben wollen.
Dafür gibt es die Möglichkeit der HTML-Forms, das haben wir bereits
ein paar Mal gesehen und man kann dann über dieses HTML-Form, den man
dann daraus einen PHP-Aufruf macht, die Daten in die Datenbank
übernehmen.
Und hier ist das dargestellt, wir haben hier als Form eine Methode
post, greifen zu auf die Datenbank hier php3 und schreiben dort in die
Form -Definition rein, dass dort Vorname stehen soll, daneben wird ein
Text eingegeben, das kennen Sie schon und der Name des Parameters, der
hier verwendet werden soll, ist vor, dahinter steht dann halt
Nachname, hier wird als Parameter dieses Nach verwendet, dann haben
Sie hier dieses Adresse, die Mail-Adresse und schließlich noch ein
Submit -Knopf, der in diesem Fall tatsächlich Knopf heißen soll und
wenn man darauf klickt, werden diese Werte an die Datenbank übertragen
mit diesen Werten für die entsprechenden variablen Namen.
Gut, das zeigt so ein bisschen, wie man das machen kann.
Hier ist dann der Aufruf angegeben, der erzeugt wird, der Query
String.
Hier sind einfach irgendwelche Dummy-Werte angegeben und jetzt müssen
natürlich diese Werte eingefügt werden und jetzt wird also was
gemacht.
Wir fügen jetzt in die Datenbank tatsächlich den Wert ein.
Also Insert into Assis, das ist der SQL-Aufruf.
In die Tabelle Assis soll etwas eingefügt werden, nämlich gerade in
die entsprechenden Attribute, zugleich zu den Attributen Vorname,
Nachname, Adresse und E-Mail.
Etwas, was übergeben wurde, diesem PHP-Skript, über die Werte der
Parameter vor, nach, Adresse und Mail.
Und dann kann man danach ein Query machen, kann das entsprechend hier
aufrufen.
Das ist entsprechend dann der Aufruf dieses Queries.
Dadurch füge ich dann entsprechend diesen Wert ein.
Hier wird das ja nur einer Variablen zugewiesen, hier wird dann
tatsächlich dieser Query erzeugt.
Also Sie haben hier auf die Art und Weise, wie Sie bei Datenbanken
normalerweise auch Zugriffe machen können, auf Datenbankinhalte über
diese einfache Query-Sprache, können Sie direkt in PHP solche Anfragen
formulieren und damit Datenbankinhalte in HTML-Seiten integrieren oder
auch Werte in Datenbanken eintragen.
Das, was wir hier jetzt mehrfach gesehen haben über Servlets, über
Java -Server-Pages, über CGI-Skripte, SSIs und so weiter, hat alles zu
tun mit dem Thema dynamische Webseiten.
Hätte ich auch vorne hinschreiben können als Überschrift über das
ganze Kapitel.
Es geht darum, dass man Inhalte von Webseiten an die aktuellen
Rahmenbedingungen eines HTTP-Aufrufs anpasst.
Ich möchte etwas personalisieren, also anpassen an den Benutzer.
Ich habe unterschiedliche Browser zur Verfügung.
Unterschiedliche Browser haben unterschiedliche Arten, Informationen
darzustellen.
Deswegen ist es sinnvoll, solche Informationen zu verwenden bei der
Präsentation von Webseiten.
Es kann sein, dass ich etwas weiß über die Eigenschaften eines
Benutzers, entweder über Cookies weitergegeben oder auf andere Art und
Weise.
Ich weiß vielleicht etwas über Datum und Ort der Anfrage.
Ich weiß, ob das ein Student oder ein Mitarbeiter oder ein Professor
ist bei einer Anfrage auf irgendetwas in der Universität.
Und beim Server weiß man natürlich auch etwas über die lokalen
Informationen, das, was aktuell in Datenbanken drinsteht.
Und das, was hier eben im Wesentlichen gemacht wird, ist, dass ich
eine Webseite personalisiere, wobei Personalisieren sich tatsächlich
beziehen kann auf einen Menschen, aber auch auf alle Randbedingungen,
die beim Aufruf gerade existieren.
Wenn ich personalisieren will, muss ich die lokalen Informationen auch
irgendwo zur Verfügung haben.
Und dafür gibt es halt unterschiedliche Möglichkeiten.
Das eine waren diese Umgebungsprofile oder Umgebungsvariablen.
Dann gibt es Cookies und es gibt tatsächlich auch noch sogenannte
Profile, die auch abgespeichert werden.
Ich wollte noch eine kurze Bemerkung zu dynamischen Webseiten machen.
Manchmal finden Sie unter dem Begriff dynamische Webseiten auch
einfach nur die Darstellung, dass Sie eine Seite haben, auf der
irgendetwas sich bewegt.
Wenn wir also eine Webseite, auf der meinetwegen irgendetwas blinkt,
bereits eine dynamische Seite.
Das ist hier aber nicht gemeint.
Oder wenn Sie meinetwegen irgendeinen, Sie können ja Inhalte auch
animieren, Sie können sich irgendetwas irgendwie bewegen lassen auf
einer Webseite.
Das wird von einigen, wird manchmal in der Literatur als dynamische
Webseite bezeichnet, ist aber nicht das, was wir hier meinen.
Wir meinen hiermit dynamisch, dass sich die Inhalte anpassen an das,
was lokal bei dem Aufruf an Informationen zur Verfügung steht.
Und jetzt schauen wir uns an eine Möglichkeit, eine
Standardmöglichkeit, das sind die Cookies.
Cookies sind also kleine Informationseinheiten, die dazu dienen,
Informationen mitzugeben mit einem HTTP-Request.
Das HTTP-Protokoll ist in dem Sinne zustandslos, dass zunächst einmal
jeder Aufruf einer URL im Prinzip zum gleichen Ergebnis führt,
beziehungsweise es gibt keine Möglichkeit, Informationen aus früheren
Aufrufen zu verwenden.
Wir können nicht irgendwelche Informationen aus früheren Aufrufen, die
in irgendeiner früheren Response gewesen sind, so direkt dort wieder
reinschreiben.
Es sei denn, Sie haben da drin irgendeine URL sich aus einer HTML
-Seite rausgeholt und dann als nächsten HTTP-Aufruf gemacht.
Das ist aber nicht gemeint.
Also zunächst einmal ist das HTTP-Protokoll zustandslos.
Die Cookies sind eine Möglichkeit, wie man Informationen über einen
HTTP -Zugriff verbinden kann mit einer URL einer HTML-Seite.
Und das funktioniert so, dass Sie also ein HTTP-Request schicken vom
Client zum Server.
Schicken Sie jetzt ein HTTP-Request, da wird also ein Request
geschickt und dazu wird ein Cookie mitgeschickt, der vorher mit dieser
URL verbunden wurde.
Also mit einem HTTP-Aufruf, mit einem Request, werden die zu dieser
URI gehörenden Cookies mitgeschickt und dadurch hat der Server die
Möglichkeit, diese Informationen auszuwerten.
Das heißt, ich kann damit gewisse Daten auf dem Rechner des Anwenders
speichern und beim nächsten Aufruf wieder auslesen.
Dadurch ist es möglich, wenn Sie auf eine Webseite gehen, dass Sie
sofort erkannt werden als ein bestimmter Benutzer, der schon früher
mal dort gewesen ist.
Das funktioniert also über Cookies.
Und auf diese Art und Weise hat man also eine Möglichkeit, auf Daten
zu reagieren, die beim Client gespeichert wurden, aus früheren
Aufrufen.
Das Ganze wird also in den entsprechenden Verzeichnissen vom Browser
verwaltet und das wird von den Browsern unterschiedlich gemacht.
Jeder Browser erlaubt die Verwendung von Cookies, es sei denn, der
Benutzer hat sie explizit deaktiviert.
So, jetzt kurzes Beispiel dazu.
Was ist ein Cookie?
Ich habe eine HTML-Seite und in der HTML-Seite steht jetzt ein Script
drin.
Das ist also ein JavaScript.
Darauf war ich gar nicht eingegangen.
JavaScript ist also auch sowas ähnliches wie diese ganzen anderen
Server -Site-Includes usw.
Aber hier JavaScript ist etwas, was auf der Anwender-Seite ausgeführt
wird.
Auf der Client-Seite, nicht auf der Server-Seite.
Und jetzt wird also hier ein JavaScript ausgeführt.
Und hier wird zugegriffen auf eine zunächst mal definierte Variable
gespeichert.
Und der wird zugewiesen, der wird zu Beginn nichts gespeichert.
Ein String.
Und jetzt wird abgefragt, ob ein Cookie für dieses Dokument existiert.
if document.cookie heißt, ist ein Cookie für dieses Dokument
vorhanden.
Wenn das vorhanden ist, dann wird der Wert dieses Cookies, document
.cookie, wird der Variablen gespeichert zugewiesen.
Wird also dieser Anfangswert, nichts gespeichert, überschrieben durch
den Wert dieses Cookies.
Ansonsten wird ein Cookie neu erzeugt.
Dann steht also hier document.cookie.
Erhält dann einen neuen Wert.
Da wird einfach reingeschrieben eine Zeichenfolge Zeitstempel gleich.
Und dahinter wird reingeschrieben das Datum der letzten Modifikation
dieses Dokuments.
Und dann soll außerdem noch ein Alert gemacht werden.
Also es soll ein Hinweis gegeben werden.
Und in diesem Alert, das sehen wir gleich, was da passiert, wird
document.lastmodified, das was hier vorne gerade stand, nochmal
hingeschrieben.
Also der Wert dieser Variablen.
Und dazu wird noch ein Bindestrich geschrieben und der Wert dieser
Variablen gespeichert.
Abhängig davon, ob jetzt vorher schon ein Cookie vorhanden war oder
nicht, wird dort also jetzt entweder nichts gespeichert stehen, oder
das, was dort vorher drin war, müsste also eigentlich drinstehen.
Zeitstempel gleich und irgendein Wert.
Und das ist das Ende dieses Skriptes.
Und dann auch schon das Ende des Kopfes unserer HTML-Datei.
Im Body steht gar nichts weiter drin.
Das ist das Ganze, was wir hier machen wollen.
Und hier ist nochmal angegeben, wenn wir so einen Cookie lesen wollen,
brauchen wir nur den Wert einer Variablen zuzuweisen.
Und wir schreiben einfach entsprechend dem Wert der Variablen document
.cookie einen Wert zuweisen.
Jetzt muss ich mal sehen, ob es funktioniert, wenn ich das jetzt
aufrufe.
Ich hoffe, dass es funktioniert.
Wenn ich jetzt hier auf Ansicht gehe, müsste eigentlich jetzt...
Sie wissen, dass ich mehrfach Schwierigkeiten hatte, HTML-Seiten
aufzurufen, weil häufig die Aufrufe nicht funktioniert haben.
Irgendwas ist hier gerade eben passiert.
Gehen wir auf...genau...hier rauf.
Aha, hier habe ich ja einen völlig anderen Wert stehen.
Sie sehen, offensichtlich gibt es hier ein Cookie, das sich auf diesen
Pfad bezieht.
Ich habe hier einen bestimmten Pfad aufgerufen.
Und da steht jetzt Zähler gleich 12.
Jetzt muss ich aber erst mal Folgendes machen, damit das jetzt alles
richtig funktioniert.
Gehe ich mal hier auf Extras, gehe auf Einstellungen und lösche
erstmal alle Cookies.
So, jetzt können wir wieder zurückgehen zu unserer Präsentation.
Jetzt gehe ich nochmal hier rauf und Sie sehen, da jetzt kein Cookie
vorhanden war, wird jetzt...hier steht nichts weiter drin.
Es wird nur ein Alert erzeugt und da steht drin ein Datum Last
Modified.
Das ist Last Modified bezogen auf das Dokument, das ich aufgerufen
habe.
Sie sehen, das Dokument habe ich vor einem Jahr das letzte Mal
modifiziert.
Ich habe jetzt gar nicht reingeguckt in das Dokument, also diese HTML
-Seite nicht noch einmal modifiziert.
Deswegen ist das die letzte Modifikation vor einem Jahr gewesen.
Und es steht daneben nichts gespeichert, weil dieses Cookie noch nicht
vorhanden war.
Jetzt wird aber dieses Cookie erzeugt.
Und wenn ich jetzt wieder hingehe in mein Dokument, also jetzt dieses
Dokument nochmal aufrufe, wieder darauf klicke, dann sehen Sie, habe
ich jetzt ein Cookie da drin gehabt.
Da steht wieder hier vorne der Zeitstempel der letzten Modifikation.
Aber rechts daneben steht der Inhalt des Cookies, den wir gerade
vorher erzeugt haben durch den vorherigen Aufruf, nämlich Zeitstempel
gleich und da steht der gleiche Wert nochmal wie links.
Ich habe ja das Dokument nicht verändert, ich habe es ja nur
aufgerufen.
Also so entsteht hier solch ein Cookie.
Jetzt werde ich sicherheitshalber nochmal die Cookies löschen, weil
ich ja noch mehr Beispiele Ihnen zeigen will.
Und schauen wir mal weiter.
Bei Cookies ist es so, die werden abgelegt auf dem Client-Rechner und
dabei spielt natürlich eine Rolle, wie lange ist das, was dort steht,
eigentlich relevant.
Es könnte sein, dass Information, die man dort ablegen will, für einen
größeren Zeitraum interessant ist, kann aber auch sein, dass man sagt,
naja, also das, was da steht, will ich nur ein paar Minuten oder
vielleicht auch nur ein paar Tage aufbewahren.
Schauen Sie sich an, die Cookies, die auf Ihrem Rechner gespeichert
sind, da finden Sie immer irgendwelche Angaben darüber, wie lange die
existieren.
Und Sie finden dann, Sie können angeben, über die Variable expires
gleich können Sie angeben das Verfallsdatum.
Also hier, Sie können in das Cookie reinschreiben, expires gleich und
daneben ein explizites Datum reinschreiben, dann wird zu diesem Datum
dieser Cookie aus dem Verzeichnis gelöscht, ist dann nicht mehr
gültig.
Und wenn also der Verfallszeitpunkt erreicht ist, wird dieser Cookie
automatisch gelöscht.
Wenn Sie sich anschauen, was für Verfallszeitpunkte standardmäßig
drinstehen, sind die in der Regel sehr groß.
Also viele Anwendungen schreiben Cookies rein, die irgendwie ein Jahr
oder auch ein paar Jahre Verfallsdatum später haben.
So, hier wird wieder etwas gemacht.
Was soll hier gemacht werden?
Wir wollen das Ablaufdatum irgendwie reinschreiben.
Also hier wird wieder ein JavaScript erzeugt und es wird eine Variable
Ablauf definiert.
Und in dieser Variable Ablauf wird jetzt eine Variable, die vom Typ
Datum ist, wird das Datum aufgerufen.
Also es wird das aktuelle Datum erzeugt, geht in die Variable Ablauf
rein, das war die Initialisierung.
Und ich möchte gerne in drei Minuten, also drei Minuten lang soll
dieses Cookie gültig sein, deswegen nehme ich den Wert, den ich bei
Ablauf gerade bekommen habe, daraus die Zeit und addiere drei Minuten.
Das muss entsprechend dieser Form gemacht werden, weil ich halt in
tausendstel Sekunden das Ganze angebe.
Und entsprechend muss ich den Wert darauf schreiben, drei mal sechzig
Sekunden mal tausend Millisekunden.
Gut, und dann setze ich entsprechend bei Ablauf, also diese Variable
setTime in drei Minuten und wird also dieser Wert entsprechend neu
gesetzt und schreibe jetzt in diese Variable expires, den Wert rein,
der Variable Ablauf und in der Form green, which meantime
entsprechendes Format, um Zeiten anzugeben und schreibe entsprechend
meinen Cookie.
So, das ist das ganze Cookie, wobei noch ein Alert gemacht wird mit
Verfallsdatum, wird also angezeigt, was dort geschrieben wird und dann
schauen wir uns das wieder an.
Dazu muss ich wieder meinen Stift ändern, mal sehen, was hier
passiert.
Sie sehen, jetzt habe ich das aufgerufen, die Zeit stimmt nicht ganz.
Es steht hier drin, Verfallsdatum Donnerstag, 29.
Juni 2006, 13.17.09.
Es stehen noch ein paar weitere Informationen da drin, die aus dem
Skript kommen, das ich tatsächlich aufgerufen habe.
Ich habe Ihnen auf der Folie nicht alles angegeben, was in das Cookie
reingeschrieben wird.
In der konkreten Datei wird noch ein bisschen mehr gemacht.
Das heißt, hier steht jetzt folgendes, Cookie-Inhalt nachher, Uhrzeit
gleich Donnerstag, 29.
Juni 2006, 12.47.
Das stimmt ziemlich genau.
Und hier wird also nicht 3 Minuten das weitergemacht, sondern 30
Minuten weitergezählt.
Also entsprechend auf 13.17.
ist hier das Verfallsdatum eingestellt.
Also wird hier durch das Skript dieses Verfallsdatum erzeugt.
Ich habe ja nicht das auf der Folie aufgerufen, sondern entsprechend
die Datei, die ich in meinem Rechner hier vorher abgelegt hatte.
So, gut, jetzt gehen wir wieder zurück zu unserer Präsentation.
Wir hatten also jetzt gesehen, dass man Cookies mit
Verfallszeitpunkten versehen kann.
Jetzt möchte ich gerne über ein Cookie in der Lage sein,
festzustellen, wie oft ein bestimmter Nutzer auf eine Seite
zugegriffen hat.
Sie hatten vorher gesehen ein Beispiel, wo über ein Servlet es möglich
war, festzustellen, wie oft auf eine bestimmte Seite zugegriffen
wurde.
Nicht nur von einem Benutzer, sondern von beliebigen Benutzern.
Hier haben wir über ein Cookie die Möglichkeit festzustellen, wie oft
ein bestimmter Benutzer bzw.
ein Rechner oder ein Browser eine Seite aufgerufen hat.
Das kann man mit einem Cookie zählen, in dem in dem HTML-Code etwas
drinstehen muss.
Hier wird also zunächst mal eine Funktion deklariert und Sie sehen,
hier wird ein Document Cookie, wenn das schon vorhanden ist, wird
entsprechend ein Wert geholt.
Und zwar wird hinter dem Gleichheitszeichen, man kann hier innerhalb
eines Cookies navigieren, bestimmte Teile dort ansprechen.
Hier wird also geschaut, was hinter diesem Gleichheitszeichen steht.
Das wird um 1 erhöht, das heißt hier wird etwas draufgezählt.
Wert Start ist also...
Also, was wird hier gemacht?
Ich habe meinen Cookie, das ist eine Folge von Zeichen.
Und ich will jetzt irgendeinen Wert dort auslesen.
Der Wert Start ist irgendeine Position.
Das ist die Position des Gleichheitszeichens.
Und ich gehe um eine Position weiter, also auf das Zeichen danach,
plus 1.
Das andere ist Wert Ende.
Das heißt, da wird geguckt, irgendwo steht hier ein Semikolon.
Und das Semikolon soll gerade das Ende des Wertes andeuten.
Das heißt, ich suche nach einem solchen Teil in dem Cookie, nach dem
ersten Gleichheitszeichen.
Und das ist der Beginn meines Wertes, den ich lesen will.
Und ich gehe so lange weiter, bis ich ein Semikolon gefunden habe.
Das ist das Ende dieses Wertes.
Wenn dieses Semikolon gar nicht vorhanden ist, dann heißt das, da
stand kein Semikolon mehr drin.
Semikola werden verwendet, um Werte zu trennen in so einem Cookie.
Also ist das der letzte Wert gewesen.
Dann ist das Wert Ende gerade definiert durch die Länge meines
Cookies.
Das ist die rechteste Position meines Cookies.
Und dann hole ich aus dem Cookie einen Teilstring raus, nämlich genau
diesen Teilstring, der hier angegeben ist, von Wert Start bis Wert
Ende.
Und der Wert wird zurückgegeben, und das ist der Wert, der von der
Methode Wert holen rausgegeben wird.
Das heißt, Wert holen soll einen bestimmten Teilbereich meines Cookies
auslesen.
Und dann kann ich mit dem Wert alles Mögliche machen.
Und hier wird folgendes gemacht, dass der Wert neu gesetzt werden
soll.
Also hier haben wir alle möglichen Sachen wieder drin stehen.
Hier wird eine Auszeit definiert.
In dem Cookie wird hinter den Wert eines Bezeichners gleicherzeitig
geschrieben.
Es wird ein Wert daneben geschrieben, der Wert, der hier steht.
Und es wird anschließend auch noch ein Verfallsdatum hingeschrieben.
Das ist hier in dem Fall Semikolon, dann Expires gleich.
Und dann steht hier Auszeit...
Was hier in Anführungszeichen steht, ist immer gerade, da haben wir
das Anführungszeichen, Semikolon, Expires gleich, ist ein solcher
String.
Und dann steht dahinter als nächstes, da wird eine Zeit angegeben,
Auszeit.tgmdString.
Und anschließend wird hier noch nach dieser ganzen Verfallszeit das
gemacht, was ich eigentlich zeigen wollte.
Das mit der Verfallszeit hätte ich rausstreichen können.
Was ich Ihnen zeigen wollte, ist eigentlich dieser Zähler.
Ich will den Zählerstand hier rausholen.
Und der Zähler ist zunächst mal 0.
Und dann schaut man sich an, ob das Cookie bereits vorhanden ist.
Hier wird also das gemacht, was ich Ihnen eigentlich zeigen wollte,
die Anzahl persönlicher Seitenbesuche.
Falls dieser Cookie bereits vorhanden ist, wird der Wert von Zähler in
diesem Cookie um 1 erhöht.
Und dann wird der Wert dieses Zählers gesetzt mit der entsprechenden
Verfallszeit, die man sich vorher rausgeholt hat.
Und wenn das Cookie noch nicht vorhanden war, wird der Zähler auf 1
gesetzt und auch hier entsprechend in das Cookie der Wert
reingeschrieben.
Also, wir haben hier einmal eine Verfallszeit erzeugt.
Das war auf der vorigen Folie zu sehen.
Und jetzt wird dieser Zählerwert hier erhöht.
Das waren jetzt Funktionen, Zählerstand und die Funktion Wert holen
und die Funktion Wert setzen.
Drei Funktionen brauchten wir.
Und jetzt wird endlich etwas gemacht.
Hier steht jetzt Ende vom Head.
Da sind die Cookie-Definitionen hier soweit erstmal beendet.
Und jetzt wird der Body erzeugt, der Rumpf erzeugt, unsere HTML-Seite.
Und da steht jetzt eine Seite, die etwas über sie weiß.
Hier wird wieder ein JavaScript aufgerufen.
In einer Variablen X wird jetzt die Funktion Zählerstand aufgerufen.
Das heißt, da wird auf Cookie zugegriffen, der aktuelle Zählerstand
ausgelesen.
Und dann wird entsprechend geschrieben in das Dokument, dies ist Ihr
entsprechend X-ter Besuch, weil das X der Zählerstand ist.
Und dann soll da noch stehen, benutzen Sie doch mal die Reload
-Funktion Ihres Browsers.
Und das Ganze kann man sich jetzt angucken, was dort passiert.
Ich hoffe, dass das jetzt funktioniert.
Ansicht.
Sehen Sie, das funktioniert nicht richtig, weil nämlich der Cookie,
der hier vorher drin stand, nicht funktioniert.
Wenn da Not a Number steht, dann ist das natürlich nicht in Ordnung.
Das versuche ich jetzt zu reparieren, indem ich die Cookies lösche.
Also das Ding ist nicht perfekt.
Ich mache ein Reload und Sie sehen, dies ist der erste Besuch auf
dieser Seite.
Ich hatte die Cookies gelöscht.
Jetzt ist das der erste Besuch auf der Seite.
Und jetzt mache ich noch mal Reload und Sie sehen, das ist der zweite
Besuch.
Und ich gehe noch mal darauf, das ist der dritte Besuch, vierter
Besuch, fünfter, sechster und so weiter.
Ich kann hier beliebig hochzählen, kann also das Wiederladen dieser
Seite auf die Art und Weise hier dokumentieren.
Nur, dass Sie sehen, der Unterschied zu dem, was wir vorher gemacht
haben, war, da waren das Informationen über Dinge, die auf Server
-Seite abgelegt waren.
Auf Server-Seite stand etwas über die dort gerade aktuelle Zeit und
ähnliches.
Hier wird etwas auf Client-Seite gemacht und in diesem Fall über
Cookies, verbunden mit einer URL, werden Informationen abgelegt und
beim nächsten Aufruf wiederverwendet.
Auf die Art und Weise können wir also hier dynamisch Informationen
erzeugen.
Gut, ich glaube, das reicht als Informationen über diese einfachen
Cookies.
Ein paar Bemerkungen dazu.
Wir haben also jetzt Zugriffsinformationen auf HTML-Seiten
gespeichert.
Wir haben also zugegriffen auf der HTML-Seite und die Informationen
sind lokal abgelegt worden in einem Cookie.
Lokal auf Client-Seite, nicht auf Server-Seite.
Also der Server kann nicht auf irgendwelche weiteren Dinge zugreifen,
sondern es wird durch das HTTP-Protokoll einfach mit dem Request diese
Informationen mitgeliefert.
Und wer das nicht möchte, kann das einfach deaktivieren und dann
werden keine Cookies mitgeliefert oder abgespeichert.
Man kann explizit festlegen, bei welcher URL der Cookie mitgeschickt
werden soll und man kann, wie gesagt, den Cookie ausschalten.
Es gibt darüber hinaus noch eine Reihe anderer Möglichkeiten der
Personalisierung.
Natürlich werden Cookies von einigen Leuten abgeschaltet, deswegen
wäre das dumm, wenn man nur das über Cookies machen würde.
Eine andere Möglichkeit ist, Profile zu verwenden und wie man das
macht, werde ich Ihnen dann nächstes Mal erzählen.
Das ist ein ganz kritischer Bereich.
Sobald ich Profile verwende, geht es um persönliche Daten.
Auch das, was ich gerade eben beschrieben habe, die Cookies, das sind
ja eigentlich persönliche Informationen.
Und sobald es um persönliche Informationen geht, haben wir Probleme
mit dem Datenschutz und müssen sehen, wie man eigentlich dafür sorgt,
dass der Benutzer einerseits personalisierte Informationen bekommt,
andererseits aber den Zugriff auf seine persönlichen Daten nicht aus
der Hand gibt.
Und das werde ich Ihnen nächstes Mal erzählen.
Vielen Dank für heute.