WEBVTT

00:03.240 --> 00:04.460
So, schönen Tag.

00:04.700 --> 00:07.800
Ich begrüße Sie zu einer weiteren Fortsetzung der Vorlesung angewandte

00:07.800 --> 00:08.720
Informatik 2.

00:09.420 --> 00:15.600
Sie werden bei der Aufzeichnung feststellen, dass der Ton wieder

00:15.600 --> 00:16.540
übersteuert ist.

00:16.820 --> 00:20.180
Wir haben hier leider im Raum, auf dem das zugesagt wurde, immer noch

00:20.180 --> 00:22.140
keine Überbrückung.

00:22.660 --> 00:27.140
Ich kann also nicht auf das richtige Signal hier zugreifen.

00:27.140 --> 00:29.040
Das ist leider sehr übersteuert.

00:30.080 --> 00:33.300
Trotzdem, denke ich, kann man mich verstehen, auch in der Aufzeichnung

00:33.300 --> 00:34.420
hier im Hörsaal sowieso.

00:34.740 --> 00:42.440
Und das ist ja das Wesentliche für diejenigen, die nicht im Raum sind.

00:42.620 --> 00:44.180
Sollte natürlich auch verständlich sein.

00:45.080 --> 00:48.820
Aber am meisten liegen natürlich die am Herzen, die hier tatsächlich

00:48.820 --> 00:52.080
auch zu sehen sind, denen ich in die Augen schauen kann, wenn ich eine

00:52.080 --> 00:52.760
Vorlesung halte.

00:52.880 --> 00:54.300
Das ist auch für mich wesentlich interessanter.

00:54.840 --> 00:59.300
So, ich habe jetzt hier als erstes nochmal diese Seite gezeigt.

01:00.200 --> 01:03.260
Einmal nochmal kurzen Hinweis auf die Prüfungsanmeldung.

01:03.440 --> 01:07.300
Das wissen Sie, dass Sie...

01:07.880 --> 01:09.260
Nein, das wollte ich gar nicht.

01:09.300 --> 01:12.460
Ich wollte auf die leere Prüfungen nochmal

01:12.460 --> 01:17.400
Studienprüfungsangelegenheiten, Hinweise zur Prüfungsanmeldung.

01:17.800 --> 01:21.380
Sie wissen, dass Sie sich anmelden können für die Prüfungen.

01:24.280 --> 01:25.480
Und hier sind...

01:25.980 --> 01:30.080
Aha, das ist also jetzt etwas klein zu sehen.

01:31.620 --> 01:34.480
Aber wir können das ja mal größer machen.

01:35.700 --> 01:37.520
Und hier auch etwas größer.

01:39.860 --> 01:42.120
So, also noch bis 29.06.

01:42.360 --> 01:44.640
Also nach zwei Wochen haben Sie Zeit, sich anzumelden für die

01:44.640 --> 01:45.040
Prüfungen.

01:45.480 --> 01:47.560
Sie wissen, dass Sie das auf unterschiedliche Art und Weise machen

01:47.560 --> 01:47.880
können.

01:47.880 --> 01:51.640
Die Wirtschaftsingenieure, Informationsleute können das über die

01:51.640 --> 01:52.780
Onlineanmeldung machen.

01:53.000 --> 01:55.720
Einige andere, die hier an der Vordesung teilnehmen, müssen das bei

01:55.720 --> 01:57.140
uns über das IFB-Terminum machen.

01:57.560 --> 02:00.240
Und die entfernten Hörer machen das sowieso auf andere Art und Weise.

02:01.300 --> 02:03.160
Das ist hier gar nicht angesprochen.

02:04.200 --> 02:08.360
Und wie gesagt, bis Ende der übernächsten Woche können Sie sich noch

02:08.360 --> 02:08.840
anmelden.

02:09.460 --> 02:16.080
Und dann kommt irgendwann, ganz genau am 25.07., am Mittwoch, nach

02:16.080 --> 02:19.120
Ende der Vorlesungszeit, kommt dann die Klausur.

02:20.440 --> 02:28.920
Worauf ich jetzt aber hinweisen wollte, kurz, war nochmal etwas zu den

02:28.920 --> 02:30.780
Terminen der Vorlesung.

02:31.340 --> 02:35.120
Und zwar sollte ja hier stehen, wann die einzelnen Termine sind.

02:36.180 --> 02:39.040
Genau, da ist noch ein falscher Termin drin.

02:39.800 --> 02:43.280
Heute ist der 14.06., also an dem Termin sind wir jetzt.

02:43.280 --> 02:45.540
Und hier halte ich jetzt meine Vorlesung.

02:45.880 --> 02:48.120
Dann hatte ich vorgehabt, am 21.06.

02:48.260 --> 02:49.260
die Vorlesung zu machen.

02:49.880 --> 02:52.000
Jetzt ist da ein wichtiger Workshop.

02:52.420 --> 02:58.440
Ich habe sowieso noch eine Doppelstunde Luft gehabt, gegenüber dem,

02:58.540 --> 03:01.280
was eigentlich bei einer Donnerstagsveranstaltung im Sommersemester

03:01.280 --> 03:02.340
möglich gewesen wäre.

03:02.960 --> 03:06.740
Deswegen ist es also kein so riesiger Schaden, wenn diese eine

03:06.740 --> 03:07.680
Doppelstunde wegfällt.

03:07.800 --> 03:11.500
Ich hätte Ihnen sicherlich noch einiges erzählen können, aber ich kann

03:11.500 --> 03:12.780
sie leider an dem Tag nicht halten.

03:12.780 --> 03:15.940
Und das steht auch an den möglichen Ausweichterminen.

03:16.100 --> 03:20.380
Also was da noch sein könnte, steht nichts mehr zur Verfügung, sodass

03:20.380 --> 03:23.020
wir das dann halt bei den restlichen Terminen belassen.

03:23.280 --> 03:26.720
Also der 21.06., nächste Woche ist keine Vorlesung.

03:26.820 --> 03:29.560
Die nächste Vorlesung in zwei Wochen am 28.06.

03:29.900 --> 03:34.900
Und dann gleich dreimal nacheinander, 28.06., 2.07., 5.07., dann

03:34.900 --> 03:38.380
nochmal eine Woche Pause und dann der 19.07.

03:38.520 --> 03:40.140
als letzte Veranstaltung.

03:40.140 --> 03:43.880
Es tut mir leid, dass es nicht anders geht, aber der Donnerstagstermin

03:43.880 --> 03:45.620
ist irgendwie ein ungünstiger Termin.

03:45.720 --> 03:48.340
Ich sollte mich vielleicht bemühen, zukünftig einen anderen Termin zu

03:48.340 --> 03:52.500
bekommen für die Vorlesung, an dem man also einen kontinuierlichen

03:52.500 --> 03:53.920
Betrieb machen kann.

03:54.040 --> 03:55.840
Das überschneidet sich mit so vielen Dingen.

03:56.840 --> 04:01.180
Und wenn man einigermaßen aktiv ist als Funktionär, dann hat man halt

04:01.180 --> 04:05.060
ab und zu einfach externe Verpflichtungen, sodass so etwas wie hier

04:05.060 --> 04:05.640
passieren kann.

04:06.300 --> 04:10.540
Also, jetzt wollen wir aber schnell sehen, dass wir zur Vorlesung

04:10.540 --> 04:11.120
kommen.

04:11.260 --> 04:12.840
Ich hatte es schon offen.

04:13.380 --> 04:17.920
Wir sind jetzt dabei gewesen, uns mit kleinen Server-Technologien zu

04:17.920 --> 04:19.940
beschäftigen im World Wide Web.

04:21.580 --> 04:25.640
Und wir hatten gesehen, dass es da verschiedene Dinge gibt.

04:26.340 --> 04:29.840
Einmal Client-lastige Dinge, aber dann auch Server-lastige.

04:30.560 --> 04:34.260
Und über die Client-lastigen erzähle ich gar nicht so viel.

04:34.260 --> 04:36.000
Über Applets wissen Sie schon einiges.

04:36.840 --> 04:41.400
Ich habe etwas erzählt über das HTTP-Protokoll, was dort eigentlich

04:41.400 --> 04:42.120
abläuft.

04:42.580 --> 04:45.800
Wir hatten gesehen, dass es dort einen Request und einen Response gibt

04:45.800 --> 04:47.180
mit gewisser Formatierung.

04:48.220 --> 04:55.340
Und jetzt hatten wir uns ein paar Dinge angeschaut, insbesondere hier

04:55.340 --> 04:58.520
diese Möglichkeiten, das Edge-Delivery von Akamai, interessante

04:58.520 --> 05:02.460
Technologie, weil man im Prinzip die Ressourcen des Internets

05:02.460 --> 05:07.100
virtualisiert und Server an einer ganz anderen Stelle zur Verfügung

05:07.100 --> 05:10.100
stellt, als der Nutzer eigentlich denkt.

05:10.520 --> 05:14.120
Also möglichst nah am Nutzer soll immer ein Server liegen, sodass man

05:14.120 --> 05:15.220
darauf zugreifen kann.

05:15.520 --> 05:18.460
Virtuell meint man auf einen großen Server zuzugreifen.

05:18.960 --> 05:23.140
Real sitzt er an irgendeiner Stelle, die dynamisch zugeordnet werden

05:23.140 --> 05:23.420
kann.

05:24.060 --> 05:26.400
Dann hatte ich Ihnen etwas erzählt über diese persistenten

05:26.400 --> 05:29.940
Verbindungen, die es ermöglichen, dass man auch bei einer Seite, in

05:29.940 --> 05:33.300
der man dringend viele Ressourcen nacheinander geladen werden müssen,

05:33.380 --> 05:37.060
über irgendwelche URLs, über irgendwelche Links, dass man diese ganzen

05:37.060 --> 05:41.620
Verbindungen, sofern sie an den gleichen Server gehen, über eine TCP

05:41.620 --> 05:42.980
-IP -Verbindung machen kann.

05:43.180 --> 05:47.060
Das sind dann die persistenten Verbindungen und dadurch spart man sich

05:47.060 --> 05:49.420
einiges an Übertragungszeit.

05:49.660 --> 05:52.980
Dann kamen wir auf das Common Gateway Interface, die Schnittstelle, um

05:52.980 --> 05:55.540
dynamische Seiten aufbauen zu können.

05:55.540 --> 05:58.880
Das heißt, ich mache irgendeine Anfrage, schreibe irgendwelche Dinge

05:58.880 --> 06:03.900
in eine HTML-Seite hinein und dann soll diese Anfrage tatsächlich

06:03.900 --> 06:07.740
irgendwo in einer Datenbank bearbeitet werden und eine HTML-Seite als

06:07.740 --> 06:10.040
Ausgabe wieder ausgegeben werden.

06:10.480 --> 06:13.700
Und das funktioniert halt über eine Schnittstelle, die sich Common

06:13.700 --> 06:14.940
Gateway Interface nennt.

06:15.220 --> 06:19.160
Und dahinter stecken dann halt irgendwelche Programme, die sich nach

06:19.160 --> 06:24.320
dieser Schnittstelle richten und dann diese Anfragen entsprechend

06:24.320 --> 06:25.380
auswerten und bearbeiten.

06:26.680 --> 06:31.860
Ich hatte Ihnen hier so kleinere Beispiele schon genannt und dieses

06:31.860 --> 06:35.160
hier genau ist die erste Folie, die wir letztes Mal noch nicht hatten.

06:35.720 --> 06:38.680
Ich wollte Ihnen noch ein Beispiel geben, was dort eigentlich jetzt

06:38.680 --> 06:44.060
genau abläuft, also welche Möglichkeiten habe ich, über diese

06:44.060 --> 06:46.520
Schnittstelle tatsächlich auf Inhalte zuzugreifen.

06:46.520 --> 06:51.920
Hier ist also die Vorstellung, oder das Szenario, das in diesem

06:51.920 --> 06:53.340
Beispiel behandelt wird.

06:53.960 --> 06:59.280
Die Idee, ich habe in dem Standardverzeichnis auf dem Server das

06:59.280 --> 07:04.880
Skript Hallo.pl, ein Perl-Skript und jetzt soll das angesprochen

07:04.880 --> 07:09.200
werden über eine Anfrage, wobei der Query String, der abgeschickt

07:09.200 --> 07:12.220
wird, Sie wissen, Query String ist halt irgendwie Name dieses

07:12.220 --> 07:16.880
Programms, dann dahinter ein Fragezeichen und dann kommt halt ein

07:16.880 --> 07:20.920
Attribut und Wert Paar.

07:21.220 --> 07:24.620
Das heißt, dieser Query String sieht natürlich ein bisschen länger aus

07:24.620 --> 07:30.660
und hat dann hier diese Anfragevariable Name gleich Wert und du musst

07:30.660 --> 07:33.180
das Perl-Skript damit sinnvolle Sachen machen.

07:34.600 --> 07:40.780
Und die Idee dieses Skriptes ist, dass wenn man so eine Anfrage macht,

07:40.820 --> 07:44.440
wo man diesen Wert angegeben hat, dass dann anschließend eine Seite

07:44.440 --> 07:49.280
erzeugt wird, auf der steht Hallo, und dann der Wert dieser Variable,

07:49.360 --> 07:49.880
dieser Name.

07:50.800 --> 07:52.860
Also soll man begrüßt werden auf dem Rechner.

07:53.340 --> 07:56.040
Einfaches Beispiel, passt gerade auf eine Folie drauf.

07:56.840 --> 07:57.900
Was passiert hier?

07:58.020 --> 08:03.020
Wir haben also hier unser Perl-Skript, steht so der übliche Syntactic

08:03.020 --> 08:05.720
Sugar vorne weg, um zu erklären, was es eigentlich für ein Programm

08:05.720 --> 08:06.220
ist.

08:06.220 --> 08:11.020
Und jetzt soll etwas geschrieben werden, also eine Antwort erzeugt

08:11.020 --> 08:11.240
werden.

08:12.240 --> 08:15.920
In der Antwort, in der Response, muss ein Header erzeugt werden, der

08:15.920 --> 08:20.700
halt sagt, dass das jetzt hier gerade so ein Text-Plane-Inhalt ist.

08:20.980 --> 08:22.820
Und jetzt ist die Frage, was kommt denn jetzt dahinter?

08:23.440 --> 08:26.680
Also geschrieben werden soll ja, da steht es, Hallo, und dahinter

08:26.680 --> 08:29.920
steht jetzt irgendwas Dollar-Value, das ist also ein Variablen-Wert.

08:30.360 --> 08:31.960
Und wo kommt dieser Variablen-Wert her?

08:31.960 --> 08:35.920
Es muss der Query-String bearbeitet werden, und es wird also dieser

08:35.920 --> 08:43.740
Dollar -Query-String, eine interne Variable, den Wert, der sich ergibt

08:43.740 --> 08:48.780
aus einer Umgebungsvariable, die jetzt gerade diesen Wert der

08:48.780 --> 08:51.040
Umgebungsvariable Query-String enthält.

08:51.280 --> 08:57.340
Also, mit dem Request habe ich einen Query-String bekommen.

08:57.340 --> 09:01.600
Dieser Query-String, in dem Fall, ist das also dieses Name-gleich

09:01.600 --> 09:02.600
-irgendein -Wert.

09:03.540 --> 09:07.660
Das ist eine Zeichenfolge, die wird jetzt dieser Variablen-Dollar

09:07.660 --> 09:09.080
-Query -String zugewiesen.

09:09.940 --> 09:14.180
Und jetzt hat diese Zeichenfolge eine gewisse Struktur.

09:15.300 --> 09:19.440
Diese Struktur deutet sich an durch dieses Gleichheitszeichen, das

09:19.440 --> 09:22.200
trennt nämlich die Variablen-Name von dem Wert.

09:22.200 --> 09:26.600
Also wird eine sogenannte Split-Funktion ausgeführt, um an dieser

09:26.600 --> 09:31.100
Stelle des Gleichheitszeichens diese Zeichenfolge aufzuteilen.

09:32.120 --> 09:36.920
Und aufgeteilt werden soll also dieser Query-String.

09:37.700 --> 09:41.360
Und diese Aufteilung soll auf zwei Variablen übertragen werden.

09:41.480 --> 09:47.540
Also der linke Wert geht auf eine interne Variable Dollar-Variable.

09:47.540 --> 09:51.760
Und der rechte Teil auf eine Variable Dollar-Value.

09:52.580 --> 09:58.140
Und wenn jetzt also dieser Variablen-Name, genau dieser String-Name

09:58.140 --> 10:04.800
ist, oder Name, kleingeschrieben, dann soll geschrieben werden, Hallo,

10:05.220 --> 10:08.500
und der Wert, der dort rechts stand.

10:08.880 --> 10:10.520
Genau das, was ich gerade eben gesagt hatte.

10:10.520 --> 10:11.800
Und dahinter ein Außenbezeichen.

10:12.300 --> 10:16.140
Und dieses Schrickstrich-N, also Backslash-N, ist ja gerade das

10:16.140 --> 10:17.260
Zeichen für die neue Zeile.

10:18.460 --> 10:21.580
So, nun kann es sein, dass ein anderer Query-String gegeben wurde, der

10:21.580 --> 10:22.780
gar nicht vorgesehen war.

10:22.900 --> 10:28.700
Wenn also nicht dieser Variablen-Name, Name, dort gestanden hat, dann

10:28.700 --> 10:31.000
wird halt irgendetwas geschrieben.

10:31.160 --> 10:35.260
Dann wird dieser Query-String nochmal hingeschrieben vollständig.

10:35.260 --> 10:39.360
Und dahinter ein Fragezeichen, wenn das Programm nicht weiß, was es

10:39.360 --> 10:40.280
damit anfangen soll.

10:40.520 --> 10:43.660
Hätte natürlich jede beliebige andere Aktion da hinschreiben können,

10:43.660 --> 10:45.880
aber irgendwas soll da hingeschrieben werden, das ist sicherlich eine

10:45.880 --> 10:49.580
sinnvolle Antwort darauf, aber man hätte auch was anderes machen

10:49.580 --> 10:50.200
können.

10:51.680 --> 10:55.160
Und das soll ja nicht nur verdeutlichen, dass hier halt so eine

10:55.160 --> 10:59.940
Anfrage umgewandelt wird, mit den Möglichkeiten dieser Perl-Language,

11:00.020 --> 11:04.300
um auf die Umgebungsvariablen zuzugreifen, um solche Name-Wertpaare

11:04.300 --> 11:05.820
aufzubrechen.

11:06.120 --> 11:08.480
Und dann ist halt das Programm beendet.

11:09.660 --> 11:13.260
So, jetzt wissen wir im Prinzip, wie sowas arbeitet.

11:13.400 --> 11:17.240
Jetzt ist die Frage, wie kommt eigentlich sowas in den Query-String

11:17.240 --> 11:17.820
hinein?

11:19.660 --> 11:23.280
Manchmal möchte man die Daten, die übertragen werden, nicht direkt als

11:23.280 --> 11:26.460
URL angeben, also ich glaube kaum, dass Sie Lust haben, Ihre Anfragen

11:26.460 --> 11:29.820
oder irgendwelche Skripte in die URL-Zeile eines Browsers

11:29.820 --> 11:33.060
reinzuschreiben, sondern Sie wollen das natürlich an einer anderen

11:33.060 --> 11:33.760
Stelle machen.

11:34.120 --> 11:40.740
Andere Stelle heißt, auf der Webseite, also in einer HTML-Seite, die

11:40.740 --> 11:42.320
auf dem Browser angezeigt wird.

11:42.620 --> 11:46.780
Und da gibt es halt eine spezielle Komponente, und diese Komponente

11:46.780 --> 11:49.140
nennen sich HTML-Forms.

11:49.220 --> 11:52.560
Und hier haben wir so ein Beispiel angegeben für einen Form-Tag.

11:53.600 --> 11:57.540
So ein Form hat verschiedene Attribute.

11:58.800 --> 12:04.240
Ein Attribut Action sagt also, welches Skript aufgerufen werden soll.

12:05.480 --> 12:08.340
Das, was hier als Form angegeben wird, wird dann vom Browser

12:08.340 --> 12:13.860
bearbeitet und kann also dann in eine Anfrage mit Query-String und so

12:13.860 --> 12:16.420
weiter überführt werden.

12:16.500 --> 12:21.500
Da muss man natürlich angeben, auf welches Skript sich diese Form

12:21.500 --> 12:23.300
beziehen soll.

12:23.300 --> 12:26.640
Dann wird angegeben, welche Methode eingesetzt werden soll.

12:26.780 --> 12:32.360
Je nachdem, ob ich GET oder POST anwende, wird der Inhalt entweder in

12:32.360 --> 12:40.000
die Query-String reingeschrieben oder hinterher an den Header des HTTP

12:40.000 --> 12:42.100
-Requests angehängt.

12:43.320 --> 12:45.420
Und was wird dort jetzt geschrieben?

12:45.420 --> 12:49.800
Auf der Webseite steht dann die Tag-Information.

12:51.680 --> 12:56.280
Im HTML-Code steht jetzt hier ein Text, Name, Doppelpunkt.

12:57.040 --> 12:58.640
Das erscheint also auf der Webseite.

12:59.140 --> 13:02.460
Und dann steht hier Input, Type gleich Text, Name gleich Name.

13:02.600 --> 13:05.900
Das heißt, jetzt habe ich hier auf der Webseite dann irgend so ein

13:05.900 --> 13:08.240
Fenster und da kann man das eintragen.

13:08.880 --> 13:12.940
Und das, was erwartet wird als Eingabe in diesem Feld, ist dann halt

13:12.940 --> 13:19.320
ein Text und das, was dort als Text eingegeben wird, soll einer

13:19.320 --> 13:21.380
Variablen zugewiesen werden.

13:21.980 --> 13:25.180
Und der Name dieser Variablen soll also dieses Name sein.

13:26.180 --> 13:29.700
Und dann gibt es noch eine weitere Input-Möglichkeit.

13:30.580 --> 13:31.860
Hier irgendein Button.

13:32.960 --> 13:37.220
Und da steht in dem Fall drauf, ich schreibe mal hier USA rein, also

13:37.220 --> 13:40.240
steht dieses Absenden, steht dort drauf, auf diesem Button.

13:41.500 --> 13:43.560
Also, Type gleich Submit.

13:44.860 --> 13:48.580
Und das heißt, wenn ich mit der Maus darauf gehe, da einen Doppelklick

13:48.580 --> 13:52.480
drauf mache, dann heißt das, der Inhalt, der dort reingeschrieben

13:52.480 --> 13:57.300
wurde, soll in einen Query-String übertragen werden, ein HTTP-Request

13:57.300 --> 14:03.260
soll gemacht werden an dieses CGI-Skript Hallo.pl mit den Werten, die

14:03.260 --> 14:04.840
hier eingetragen wurden.

14:05.760 --> 14:10.700
Also, hier steht es nochmal, in der Formumgebung können Eingabe-Felder

14:10.700 --> 14:14.840
definiert werden, welche durch das Absenden in einen Query-String

14:14.840 --> 14:15.880
umgeformt werden.

14:16.280 --> 14:22.340
Das heißt, das, was jetzt als HTTP-Request erzeugt wird, sieht dann so

14:22.340 --> 14:24.340
aus, wie hier angegeben.

14:24.780 --> 14:30.460
Das wäre mit Get, einfach jetzt die URL und Name gleich.

14:31.260 --> 14:35.000
Zum Beispiel, wenn einer dort Michael reingeschrieben hat, wäre das

14:35.000 --> 14:35.600
halt Michael.

14:36.960 --> 14:40.500
Einfach jetzt nur als Beispiel, wie man aus einer HTML-Seite

14:40.500 --> 14:45.480
Informationen übertragen kann auf den Server, die dann von dem

14:45.480 --> 14:46.340
ausgewertet wird.

14:46.400 --> 14:47.900
Hier ist das Auswerten sehr einfach.

14:48.380 --> 14:51.140
Da wird einfach nur der Wert sofort wieder zurückgegeben an der HTML

14:51.140 --> 14:51.660
-Seite.

14:52.140 --> 14:54.680
Man könnte natürlich beliebige andere Dinge dort noch in dem Programm

14:54.680 --> 14:55.360
gemacht haben.

14:55.540 --> 14:56.940
Aber das war halt dieses kleine Beispiel.

14:57.760 --> 15:00.320
So, jetzt hatte ich die Methode Get angegeben.

15:00.580 --> 15:03.780
Es gibt auch noch die Methode Post, die hat es ganz kurz angesprochen.

15:04.420 --> 15:06.620
Man kann als Alternative eben auch Post verwenden.

15:07.180 --> 15:13.080
Und in dem Fall, wenn ich Post nehme, dann steht der Inhalt nicht im

15:13.080 --> 15:16.660
Header mit drin, sondern steht unten drunter, direkt hinter dem

15:16.660 --> 15:17.260
Header.

15:18.120 --> 15:23.060
Und wenn ich das mit Post machen wollte, dann müsste halt der HTTP

15:23.060 --> 15:26.260
-Request so aussehen, wie hier angedeutet ist.

15:26.640 --> 15:32.140
Dann würde nur in der URL hier oben nur das Skript angesprochen werden

15:32.140 --> 15:35.300
mit dem Post vorneweg.

15:36.040 --> 15:41.200
Und ich müsste dann noch sagen, wie lange der Inhalt ist, der jetzt

15:41.200 --> 15:44.460
hinter diesem Request-Header noch kommt.

15:44.580 --> 15:49.160
Und das sind in dem Fall genau zwölf Zeichen, Name gleich Michael.

15:49.920 --> 15:54.240
Also dieser Datenteil ist halt zwölf Byte in dem Fall lang.

15:55.260 --> 15:58.000
Und Sie können sich vorstellen, dass das durchaus Vorteile haben kann,

15:58.080 --> 16:03.040
wenn man das mit der Post-Methode macht, weil dann nämlich die Inhalte

16:03.040 --> 16:06.920
halt nicht alle in den String reingeschrieben werden müssen, der halt

16:06.920 --> 16:10.800
übertragen wird, sondern dann habe ich irgendwelche Inhalte, die unten

16:10.800 --> 16:13.360
drinstehen in diesem Request.

16:13.360 --> 16:18.240
Der Unterschied ist, dass Sie bei der Post-Methode halt dann einen

16:18.240 --> 16:23.360
deutlich kürzeren Query-String sehen im Query-String-Fenster Ihres

16:23.360 --> 16:23.900
Browsers.

16:24.300 --> 16:26.220
Das, was da erzeugt wird, ist dann wesentlich kürzer.

16:26.720 --> 16:29.060
Der ganze Inhalt, der hinterher kommt, der wird dort nicht mehr

16:29.060 --> 16:32.180
aufgeschrieben, während er bei der Get-Methode halt in dem String

16:32.180 --> 16:32.980
direkt drinsteht.

16:34.240 --> 16:36.580
Das Ganze kann natürlich im Programm abgefragt werden.

16:36.840 --> 16:38.440
Man muss ja darauf reagieren können.

16:38.680 --> 16:40.640
Das Skript bekommt ja nur irgendeine Anfrage.

16:40.640 --> 16:44.900
Also wenn ich darauf reagieren möchte, dann müsste man zunächst mal

16:44.900 --> 16:48.860
abfragen, ob die Methode, mit der dieser Request aufgebaut wird, oder

16:48.860 --> 16:49.600
welche das ist.

16:49.700 --> 16:54.760
Das heißt, dann muss ich erstmal die umgebungsvariable Request-Method

16:54.760 --> 16:59.100
abfragen und die enthält dann halt entweder Post oder Get.

16:59.100 --> 17:09.260
Wenn das gerade das Get ist, dann ist der Inhalt dieses Form-Info, in

17:09.260 --> 17:13.500
dem Fall gerade der Inhalt dieses Query-Strings, wie wir das gerade

17:13.500 --> 17:14.820
eben vorher schon gesehen haben.

17:16.080 --> 17:18.980
Ansonsten wäre es halt etwas anders.

17:20.140 --> 17:23.140
Dann müsste ich mir anschauen, die Größe.

17:23.440 --> 17:25.800
Ich muss wissen, wie groß ist das, was als Inhalt gegeben wird.

17:25.800 --> 17:32.720
Und dann holen wir aus der Umgebungsvariable Content-Length.

17:33.320 --> 17:36.200
Content-Length ist spezifiziert in dem Request.

17:37.100 --> 17:42.060
Und dann liest man halt noch so und so viele Bytes weiter aus dem

17:42.060 --> 17:47.380
Eingabestrom, also aus dem Eingabestrom, in dem Fall Standed-In, liest

17:47.380 --> 17:52.780
man Size, viele Bytes weiter und schreibt die rein in die Variable

17:52.780 --> 17:54.240
Form -Info.

17:54.240 --> 17:59.100
Entweder ist der Wert von Form-Info entweder gekommen aus dem Query

17:59.100 --> 18:02.460
-String oder aus dem Teil hinter dem Request.

18:03.120 --> 18:06.380
Und anschließend steht hier im Prinzip genau das gleiche wie vorher,

18:07.060 --> 18:09.900
als wir noch nicht unterschieden haben nach Get oder Post.

18:10.600 --> 18:18.080
Der einzige Unterschied ist, dass wir hier jetzt dieses, hier ist

18:18.080 --> 18:20.960
nicht mehr stehen haben Query-String, sondern Form-Info.

18:21.860 --> 18:25.460
Also das ist ein kleiner Unterschied, ansonsten das was hier logisch

18:25.460 --> 18:30.720
steht, ist das gleiche wie bei dem Beispiel ohne diese Unterscheidung

18:30.720 --> 18:31.520
in Post und Get.

18:32.400 --> 18:35.960
Okay, kleines Beispiel zur Nutzung so eines Failscripts.

18:37.140 --> 18:44.300
Und jetzt komme ich zu einer weiteren Möglichkeit, wie man Inhalte in

18:44.300 --> 18:49.740
HTML -Seiten hineinbringen kann, die zunächst mal bei Erzeugung der

18:49.740 --> 18:54.300
Seite, beim Aufschreiben der Seite nicht bekannt waren, sogenannte

18:54.300 --> 18:55.700
Server -Site-Includes.

18:56.460 --> 18:58.940
Ich möchte dazu bemerken, dass die Techniken, die ich jetzt hier

18:58.940 --> 19:02.600
vorstelle, sich darauf beziehen, dass sie explizit HTML-Seiten

19:02.600 --> 19:05.800
schreiben, in die sie solche dynamischen Inhalte hineinbringen wollen.

19:06.420 --> 19:10.200
Wenn sie für die Erstellung ihrer Webseiten ein Content-Management

19:10.200 --> 19:14.560
-System verwenden, dann werden sie mit solchen Dingen eigentlich gar

19:14.560 --> 19:19.620
nicht mehr konfrontiert, sondern dann läuft so etwas über dynamische

19:19.620 --> 19:22.780
Techniken im Hintergrund, die sie explizit gar nicht beeinflussen.

19:23.300 --> 19:25.400
Und ich halte es schon für sinnvoll, dass man einfach mal sieht,

19:25.460 --> 19:28.620
welche prinzipiellen Möglichkeiten es gibt, wenn man direkt solche

19:28.620 --> 19:29.960
HTML -Seiten schreibt.

19:31.360 --> 19:36.240
Und was man dann konkret später einsetzt, ist ja auch die Frage, in

19:36.240 --> 19:38.340
was für einer Umgebung arbeitet man eigentlich.

19:39.860 --> 19:42.420
Gut, was ist das hier für eine Möglichkeit?

19:43.480 --> 19:46.100
Ich habe als erstes ein paar Links angegeben.

19:46.940 --> 19:51.560
Ich habe den oberen Link gestern versucht aufzurufen, da kam keine

19:51.560 --> 19:51.980
Antwort.

19:52.940 --> 19:56.080
Also eigentlich wollte ich hier ein Tutorial, habe ich eine Tutorial

19:56.080 --> 20:01.100
-Seite einmal gefunden gehabt, die anscheinend nicht mehr da ist.

20:01.200 --> 20:06.000
Sie finden, wenn Sie suchen nach SSIs und Tutorials, kommen Sie immer

20:06.000 --> 20:06.740
auf diese Seite.

20:07.560 --> 20:11.380
Auch bei Google waren Sie darauf geführt, leider ist die zurzeit nicht

20:11.380 --> 20:11.900
aktiv.

20:12.400 --> 20:14.840
Die Seite unten drunter, diese hier, die ist aktiv.

20:14.980 --> 20:19.640
Da findet man also einen Vortrag, im Prinzip eine Präsentation, über

20:19.640 --> 20:23.760
die vielfältigen Möglichkeiten dieser Server-Site-Includes, von denen

20:23.760 --> 20:25.740
ich Ihnen hier nur einen kleinen Ausschnitt präsentiere.

20:26.740 --> 20:29.380
Also bei dem Abschnitt, den ich Ihnen in diesem Kapitel präsentiere,

20:29.440 --> 20:32.420
ich Ihnen viele Techniken, wo ich nur einen kleinen Ausschnitt gebe,

20:32.500 --> 20:34.740
was man so beispielhaft machen kann.

20:34.740 --> 20:39.040
Und Sie werden in Übungen Gelegenheit haben, sich damit genauer zu

20:39.040 --> 20:39.980
beschäftigen, bzw.

20:40.300 --> 20:45.100
ich erwarte oder rege an, dass Sie sich einfach mal in diese Links

20:45.100 --> 20:49.440
hineinklicken und sehen, was es dort an weiteren Informationen gibt.

20:51.480 --> 20:54.900
Das ist etwas, was Sie sowieso lernen müssen, wie man sich

20:54.900 --> 21:00.000
Informationen angeregt durch gewisse Anfangsinformationen dann

21:00.000 --> 21:01.480
vollständig selbst besorgt.

21:01.480 --> 21:04.000
Wenn man das im Studium nicht gelernt hat, ist man nicht gut

21:04.000 --> 21:08.220
vorbereitet auf die Anforderungen einer späteren Berufstätigkeit, wo

21:08.220 --> 21:10.160
Sie sich immer wieder neue Dinge aneignen müssen.

21:10.900 --> 21:13.880
Und da finden Sie irgendeinen Hinweis und müssen dann sehen, wie Sie

21:13.880 --> 21:15.600
die vollständigen Informationen kriegen.

21:16.940 --> 21:18.860
Also, worum geht es?

21:19.020 --> 21:24.760
Es geht um eine Erweiterung zu CGI.

21:25.340 --> 21:30.440
Es geht darum, dass Sie bestimmte Möglichkeiten haben, auch ohne ein

21:30.440 --> 21:33.860
Skript, weil CGI sagt, wir müssen mal ein Skript dahinter stehen

21:33.860 --> 21:37.980
haben, damit wir dynamische Inhalte reinbringen können in HTML-Seiten.

21:39.060 --> 21:43.900
Hier können Sie direkt über Befehle im HTML-Dokument

21:47.700 --> 21:49.860
dynamische Inhalte in das Dokument reinbringen.

21:50.160 --> 21:51.200
Wie kann das funktionieren?

21:51.300 --> 21:59.540
Wir hatten gerade eben gesehen, da war eine HTML-Seite bei dem

21:59.540 --> 22:03.360
Postscript, bei der Möglichkeit, mit Forms zu arbeiten.

22:03.860 --> 22:07.400
Da hat man ein CGI-Skript angesprochen, also man hat hier irgendwelche

22:07.400 --> 22:10.640
Inhalte reingeschrieben in eine Seite und dann wurden die übertragen

22:10.640 --> 22:14.120
auf irgendeinen Server und der hat wieder etwas zurückgeschickt und

22:14.120 --> 22:17.140
hat dann eine neue Seite erzeugt, wo diese dynamischen Inhalte drin

22:17.140 --> 22:17.520
waren.

22:18.120 --> 22:20.180
Oder irgendetwas als Ergebnis erzeugt wurde.

22:21.260 --> 22:27.640
Jetzt ist die Idee, ich rufe irgendeine Seite auf und wenn das Server,

22:27.740 --> 22:31.060
also das war jetzt hier mein großer Server, dieser Server liefert

22:31.060 --> 22:35.320
jetzt eine HTML-Seite und in der HTML-Seite stehen an bestimmten

22:35.320 --> 22:41.980
Stellen Informationen drin, Befehle drin, die bereits vom Server

22:41.980 --> 22:43.240
ausgewertet werden.

22:43.680 --> 22:45.780
Der schickt also nicht einfach das Ding rüber, sondern wenn er das

22:45.780 --> 22:50.900
rüberschickt, wertet der sofort diese Teile aus und setzt dort gewisse

22:50.900 --> 22:51.980
Inhalte rein.

22:52.600 --> 22:55.940
Das heißt, es geht um Dinge, die vom Server bereits bei der

22:55.940 --> 22:59.560
Auslieferung des Dokuments in das Dokument reingeschrieben werden.

22:59.960 --> 23:02.200
Jetzt schauen wir uns das gleich mal an, was da passiert.

23:02.840 --> 23:04.820
Also ich habe hier kein explizites Skript.

23:05.820 --> 23:14.760
Es wird einfach vom Server bei der Antwort auf ein HTTP-Request diese

23:14.760 --> 23:18.900
HTML -Seite ausgewertet und dann werden dort Dinge reingeschrieben.

23:19.480 --> 23:25.380
Auf der HTML-Seite müssen dann solche Tags stehen, die als Beginn, so

23:25.380 --> 23:31.320
eine spitze Klammer, Ausrufezeichen, zwei Bindestriche und ein

23:31.320 --> 23:35.620
Hashmark oder Nummernzeichen halt haben und am Ende halt nochmal zwei,

23:36.260 --> 23:38.380
also diesen rechten Pfeil da am Ende.

23:38.840 --> 23:41.300
Das ist also einfach diese Syntax, die man dafür braucht.

23:41.300 --> 23:42.440
Und ich gebe Ihnen gleich ein Beispiel.

23:43.180 --> 23:47.940
Sie haben hier eine HTML-Seite, die die übliche einfache Struktur hat,

23:48.100 --> 23:49.580
also irgendein Header.

23:50.520 --> 23:54.120
Und da wird jetzt genau das HTML mit SSI Ihnen vorgestellt.

23:54.840 --> 23:59.300
Und in unserem Rumpf, da steht jetzt an irgendeiner Stelle etwas drin,

23:59.500 --> 24:02.020
was nicht Standard-HTML-Tags sind.

24:02.140 --> 24:04.400
Und die sind hier schön grün hervorgehoben.

24:05.300 --> 24:09.280
Ich möchte zum Beispiel auf der HTML-Seite, die bei mir auf dem

24:09.280 --> 24:14.240
Browser dargestellt wird, die Uhrzeit, das Datum und die Uhrzeit des

24:14.240 --> 24:15.360
Server -Rechners haben.

24:17.220 --> 24:20.340
Also die Seite wird ja vom Server geliefert und ich möchte wissen,

24:20.420 --> 24:22.260
welche Uhrzeit ist gerade beim Server.

24:23.000 --> 24:27.160
Und das kann ich so machen, dass der Server, in dem Fall, also er soll

24:27.160 --> 24:32.140
da ein Echo machen, der soll also hier an diese Stelle reinschreiben,

24:33.840 --> 24:36.840
den Wert der Umgebungsvariable DateLocal.

24:38.040 --> 24:46.580
Das ist also das aktuelle Datum, also Datum und Uhrzeit auf dem Server

24:46.580 --> 24:47.020
-Rechner.

24:48.740 --> 24:52.080
Das weiß natürlich nur der Server, das weiß nicht der Client.

24:52.740 --> 24:56.660
Und auf diese einfache Anweisung ersetzt dann der Server beim

24:56.660 --> 25:06.680
Ausliefern der Seite diesen Teil durch einen Wert, der dann halt dort

25:06.680 --> 25:08.080
reingeschrieben wird.

25:09.240 --> 25:14.420
Und außerdem, das ist eine etwas witzige Anweisung, ich rufe eine

25:14.420 --> 25:19.480
Seite auf und auf der Seite soll draufstehen, welchen UEW-Browser ich

25:19.480 --> 25:19.880
nutze.

25:22.040 --> 25:23.740
Woher weiß das der Server?

25:23.740 --> 25:27.960
Wieso weiß der Server, ob ich jetzt Mozilla Firefox verwende oder den

25:27.960 --> 25:28.740
Internet Explorer?

25:29.240 --> 25:33.780
Mit dem HTTP-Request wird die Information mitgeliefert, welcher

25:33.780 --> 25:36.300
Browser diese Anfrage gestellt hat.

25:36.740 --> 25:41.260
Der Wert steht in einer Umgebungsvariable drin, die vom HTTP-Protokoll

25:41.260 --> 25:44.580
ausgewertet wird und bei der Erstellung der Antwort kann er also

25:44.580 --> 25:50.940
zugreifen auf diese Variable und schreibt dann an diese Stelle einfach

25:50.940 --> 25:55.540
den Namen des Browsers rein.

25:55.960 --> 25:59.620
Also auch eine einfache Möglichkeit sowas reinzuschreiben.

25:59.980 --> 26:03.260
Dazu brauche ich nicht über die CGI-Schnittstelle zu gehen, das wird

26:03.260 --> 26:07.720
direkt vom HTTP-Protokoll mit den Server-Side-Includes hier erledigt.

26:08.260 --> 26:12.000
Ich kann aber durchaus auch auf ein CGI-Skript zugreifen, wenn ich das

26:12.000 --> 26:17.240
möchte und kann also direkt hier sagen, es soll bitte an dieser Stelle

26:17.240 --> 26:24.260
ein CGI-Skript aufgerufen werden, das jetzt irgendeinen Blablabla

26:24.260 --> 26:27.880
-Namen hat, also es kommt gar nicht drauf an, was das ist, dieser

26:27.880 --> 26:29.380
Standard -Name-Blabla-Phase.

26:31.200 --> 26:34.660
Also irgendein Skript wird aufgerufen und das Ergebnis der Anwendung

26:34.660 --> 26:37.340
dieses Skripts soll dann an diese Stelle reingeschrieben werden.

26:38.440 --> 26:42.740
Und das ist schon das Ende dieses einfachen Dokuments, d.h.

26:42.840 --> 26:46.620
mit den Server-Side-Includes habe ich, ohne dass ich explizit nochmal

26:46.620 --> 26:52.840
kommunizieren muss mit dem Server, also nicht dieses von meinem Client

26:52.840 --> 26:57.680
auf den Server erstmal ein Request schicken, dann kommt hier

26:57.680 --> 27:01.180
irgendwann eine HTML-Seite, dann habe ich hier also meine HTML-Seite

27:01.180 --> 27:05.040
stehen und dann habe ich hier drin noch irgendwelche Forms und mache

27:05.040 --> 27:07.080
dann also hier irgendein...

27:07.080 --> 27:09.580
das war also nur auf der HTML-Seite, dann mache ich hier nochmal

27:09.580 --> 27:12.580
konkret irgendwelche Form-Einträge, das war das, was ich mir jetzt

27:12.580 --> 27:16.940
vorgestellt hatte, und ich habe dann auf dieser Seite ein CGI-Skript

27:16.940 --> 27:20.400
und dann kommt das Ergebnis wieder an die HTML-Seite.

27:20.940 --> 27:25.740
Das hat mich bei dem SSI halt einfacher, da habe ich nur einmal eine

27:25.740 --> 27:30.400
Kommunikation, ich schicke meinen Link im Prinzip an meinen Server und

27:30.400 --> 27:36.780
bekomme sofort die mit SSI angereicherten Informationen in meiner

27:36.780 --> 27:38.620
dynamischen HTML-Seite zurück.

27:39.500 --> 27:42.440
Und solche Inhalte kann ich natürlich nicht als Autor von vornherein

27:42.440 --> 27:47.480
reingeschrieben haben, die müssen zum Zeitpunkt der Erzeugung des

27:47.480 --> 27:51.520
Responses auf dieser HTTP-Anfrage erzeugt werden.

27:52.240 --> 27:56.020
Gut, also ein sehr einfacher Mechanismus, wie Sie dynamische Inhalte

27:56.020 --> 27:56.720
einbauen können.

27:57.880 --> 28:01.200
Und welche Möglichkeiten Sie da haben, ist hier kurz angedeutet, Sie

28:01.200 --> 28:05.640
können einfach nur ein ECHO machen, das habe ich Ihnen angedeutet, Sie

28:05.640 --> 28:11.320
können EXEC machen, Sie können gewisse Konfigurationen machen, also

28:11.320 --> 28:15.960
etwas über Dateigrößenformat, Fehlermeldung, Zeitformate hier

28:15.960 --> 28:21.840
konfigurieren, Sie können Dateigrößen hier noch angeben, Sie können

28:21.840 --> 28:26.600
Zeitstempel von Dateien hier angeben, auch das wird manchmal gemacht,

28:26.720 --> 28:29.880
dass Sie zu einer Datei mitgleichen, wann sie das letzte Mal verändert

28:29.880 --> 28:31.100
wurde oder ähnliche Dinge.

28:31.880 --> 28:38.800
Sie können zum Beispiel den Inhalt irgendeiner Datei einfügen.

28:40.860 --> 28:45.800
Also wie gesagt, es gibt viele Möglichkeiten, wenn Sie das aber im

28:45.800 --> 28:48.680
Einzelnen sich anschauen müssen, also welche Attribute muss ich alle

28:48.680 --> 28:52.960
angeben, wenn ich einen INCLUDE mache oder ein gewisses FLASTMATCH,

28:53.100 --> 28:58.700
also LASTMODIFIED, wann ist die Dateisätze modifiziert worden, solche

28:58.700 --> 29:03.260
Informationen, also was man dann konkret als Attribute dort angeben

29:03.260 --> 29:07.620
muss, das schauen Sie nach in der SSI-Spezifikation und dann können

29:07.620 --> 29:08.320
Sie das einsetzen.

29:08.320 --> 29:11.380
Die einfachen Beispiele habe ich Ihnen ja genannt, aber ich glaube, es

29:11.380 --> 29:16.560
reicht in dieser Form, um zu verstehen, dass es eine interessante,

29:16.840 --> 29:19.760
einfache Möglichkeit ist, mit relativ wenig Zusatzkommunikation oder

29:19.760 --> 29:22.160
keiner Zusatzkommunikation zwischen Client und Server.

29:23.040 --> 29:27.360
Eine andere Möglichkeit, die Sie nutzen können, sind JAVA-Servernets.

29:28.060 --> 29:32.340
Auch hier habe ich Ihnen mehrere Links angegeben, auf denen Sie

29:32.340 --> 29:34.140
ausführliche Informationen abrufen können.

29:34.140 --> 29:39.740
Diese funktionierten gestern Abend alle, sollten also auch jetzt noch

29:39.740 --> 29:40.380
funktionieren.

29:41.020 --> 29:45.200
Das Problem ist ja, dass eben URLs etwas Dynamisches sind, sodass man

29:45.200 --> 29:49.000
nicht immer darauf vertrauen kann, dass so eine URL auch funktioniert,

29:49.240 --> 29:50.480
aber das hat mich überprüft.

29:51.040 --> 29:55.520
Das, was hier gemacht wird mit diesen JAVA-Servernets, ist, dass man

29:55.520 --> 30:01.480
im Prinzip eine JAVA-Version von CGI und SSI hat.

30:01.480 --> 30:08.300
Ich kann Skripte, CGI-Skript, kann ich also auch in JAVA schreiben,

30:08.400 --> 30:10.000
das sind dann bei den JAVA-Servernets.

30:10.740 --> 30:16.160
Und bei den JAVA-Serverpages, das sind ähnliche Dinge wie die SSIs.

30:16.760 --> 30:23.400
Da kann ich also über JAVA-Code in einer HTML-Seite, der auf dem

30:23.400 --> 30:27.100
Server ausgeführt wird, direkt Informationen einbauen.

30:28.580 --> 30:32.260
Der Vorteil ist, dass Sie hier eben in JAVA Dinge schreiben, deswegen

30:32.260 --> 30:36.640
haben Sie hier bessere Portierbarkeit des Codes und Sie haben

30:36.640 --> 30:41.020
objektorientiertes Design, das bei diesen anderen Techniken nicht

30:41.020 --> 30:43.740
notwendigerweise der Fall ist.

30:44.300 --> 30:49.980
Was Sie hier brauchen, ist natürlich ein Server, der in der Lage ist,

30:50.960 --> 30:55.740
diese Servernets auch geeignet auszuführen und JAVA-Serverpages

30:55.740 --> 30:56.860
richtig auszuführen.

30:57.440 --> 31:00.540
Das muss halt vom Web-Server unterstützt werden.

31:01.040 --> 31:04.360
Genauso muss natürlich SSI auch vom Web-Server unterstützt werden.

31:04.580 --> 31:09.580
Und dafür, Sie sehen jetzt hier eine kleine Änderung gegenüber der

31:09.580 --> 31:12.120
Folie, die Sie vielleicht vor sich ausgeliehen haben.

31:12.740 --> 31:15.620
Ich habe mir das auch gestern Abend nochmal angeguckt.

31:15.840 --> 31:18.440
Aktueller Stand JAVA-Serverlets ist 2.5.

31:18.440 --> 31:24.420
Wir sind jetzt noch nicht allzu alt und die Plattform dafür ist J2EE,

31:25.260 --> 31:30.340
Enterprise Java Enterprise Edition.

31:30.900 --> 31:35.020
Eine Plattform, die ich Ihnen etwas später vorstellen werde, also

31:35.020 --> 31:37.080
wesentlich mehr als ein Web-Server.

31:37.680 --> 31:44.180
Der Apache Tomcat ist also eine Komponente für den Apache Web-Server.

31:44.180 --> 31:50.000
Der Apache Web-Server unterstützt solche JAVA-Serverlets und damit

31:50.000 --> 31:53.400
kann man also, wenn man einen Apache Web-Server hat, als Web-Server

31:53.400 --> 31:57.840
kann man also solche JAVA-Serverlets und JAVA-Serverpages verwenden.

31:58.180 --> 32:01.860
Ansonsten muss man aufpassen, ob die ganzen Möglichkeiten auch

32:01.860 --> 32:02.560
unterstützt werden.

32:03.060 --> 32:05.660
Wenn Sie dazu mehr Informationen haben wollen, können Sie unter

32:05.660 --> 32:10.200
anderem auch auf diese Seite schauen, auf diese jakarta.apache.org.

32:10.200 --> 32:14.380
Da hat sich aber eben auch weiterentwickelt gegenüber dem, was da

32:14.380 --> 32:15.200
ursprünglich mal stand.

32:16.980 --> 32:23.420
Sie finden dort direkt im Augenblick keine explizit sofort sichtbaren

32:23.420 --> 32:25.500
Informationen zu JAVA-Serverlets.

32:25.920 --> 32:27.860
Aber indirekt hat das alles damit zu tun.

32:28.580 --> 32:31.080
Und ich würde sagen, wenn Sie sich speziell zu Serverlets und JAVA

32:31.080 --> 32:36.040
-Serverpages Informationen holen wollen, sind die Links dort oben

32:36.040 --> 32:38.120
sicherlich interessant.

32:38.500 --> 32:40.700
So, ich erzähle Ihnen mal noch ein bisschen mehr zu den Serverlets.

32:40.800 --> 32:42.340
Ich erzähle Ihnen noch ein paar Beispiele.

32:42.480 --> 32:44.220
Und jetzt stelle ich noch kleinere Beispiele vor.

32:44.820 --> 32:48.080
Wenn das mit JAVA läuft, ist es klar, schreibt man sich halt ein

32:48.080 --> 32:49.080
bisschen JAVA-Code hin.

32:49.780 --> 32:52.320
Und den habe ich Ihnen hier mal als Beispiel angegeben.

32:52.380 --> 32:53.320
Was steht denn da eigentlich?

32:53.820 --> 32:58.740
Zunächst mal wieder sehr viel Syntactic Sugar, also sehr viel Text,

32:58.860 --> 33:00.300
der außenrum geschrieben werden muss.

33:00.300 --> 33:04.900
Und das, was wir eigentlich hier haben wollen, ist...

33:04.900 --> 33:08.960
Aha, hier etwas, was sich Hello World nennt.

33:09.340 --> 33:10.400
Das typische Eingangsbeispiel.

33:11.540 --> 33:12.240
Hello World.

33:13.000 --> 33:18.100
Und dieses Hello World soll also ein HTTP-Serverlet sein.

33:18.200 --> 33:20.800
Das heißt, ich habe hier eine Basisklasse HTTP-Serverlet.

33:21.460 --> 33:27.560
Und dieses Hello World ist also eine spezielle Klasse, die jetzt

33:27.560 --> 33:28.580
später spezialisiert.

33:29.600 --> 33:34.040
Das Ganze ist eingebaut in eine Package, die jetzt aus irgendeinem

33:34.040 --> 33:36.660
Grund HAL heißt.

33:37.900 --> 33:41.720
Und das heißt, wenn ich das aufrufen möchte, dann muss ich also auf

33:41.720 --> 33:47.580
Package, HAL und dann Hello World zurückgreifen.

33:48.780 --> 33:51.790
So könnte also eine solche URL aussehen.

33:51.790 --> 33:57.150
Ich möchte jetzt auf welcher Domain auch immer bei Servlets gerade

33:57.150 --> 33:59.970
genau auf dieses Servlet Hello World zugreifen.

34:01.470 --> 34:08.250
Und jetzt sehen wir hier drin noch Dinge wie Variable Request.

34:08.370 --> 34:09.930
Wir tragen die Variable Request auf.

34:10.510 --> 34:11.790
Hier steht ein Request.

34:12.870 --> 34:15.990
Also ein HTTP-Serverlet-Request.

34:16.770 --> 34:19.910
Und ein HTTP-Serverlet-Response nennt sich Response.

34:19.910 --> 34:24.990
Ich habe also zwei Variablen, in denen diese beiden Dinge drinstehen.

34:25.070 --> 34:28.690
Der HTTP-Serverlet-Request kommt ja vom Client.

34:29.150 --> 34:30.690
Der Response muss erzeugt werden.

34:31.790 --> 34:36.350
Und das Ganze kann natürlich auch irgendwelche Ausnahmen erzeugen, die

34:36.350 --> 34:37.850
entsprechend behandelt werden müssen.

34:38.970 --> 34:42.950
Und jetzt steht hier das, was eigentlich gemacht werden soll.

34:42.950 --> 34:49.550
Hier habe ich also bei der Response, die erzeugt wird, die HTTP

34:49.550 --> 34:49.950
-Response.

34:50.750 --> 34:52.030
Wieso schreibt der jetzt nicht mehr?

34:52.850 --> 34:55.590
Aus irgendeinem Grund kann ich mir einen Stift im Auge mit nicht

34:55.590 --> 34:55.970
schreiben.

34:56.150 --> 34:57.090
Kommt vielleicht gleich wieder.

34:57.910 --> 34:58.530
Wollen wir sehen.

34:59.230 --> 35:05.970
Also bei Response, da soll jetzt der Content-Type auf Textplay

35:05.970 --> 35:06.930
hingesetzt werden.

35:10.590 --> 35:15.990
Mein Programm möchte im Augenblick nicht mehr mit mir kommunizieren.

35:18.290 --> 35:20.230
Das funktioniert noch, wie schön.

35:21.130 --> 35:22.150
Und jetzt funktioniert es auch wieder.

35:22.270 --> 35:23.650
Hat er sich kurzzeitig aufgehängt.

35:24.350 --> 35:27.890
Also, ich gehe also in die Response rein.

35:28.530 --> 35:33.290
Und setze dort den Wert Content-Type auf Textplay.

35:33.290 --> 35:37.690
Und schreibe hinterher dann dieses...

35:38.290 --> 35:40.430
Ich muss also irgendwo hinschreiben.

35:40.590 --> 35:41.790
Da habe ich also irgendeinen Writer.

35:42.630 --> 35:45.150
Und der soll jetzt schreiben, Hello World.

35:46.490 --> 35:51.210
Das ist wieder das typische, völlig triviale Basisbeispiel.

35:51.890 --> 35:56.930
Und außen rum steht halt nur, was für Variablen hier vorkommen.

35:57.670 --> 36:02.930
Ich kann halt aus der Variablen-Request alle Informationen rausziehen,

36:03.930 --> 36:07.930
die in diesem HTTP-Request, oder in dem Fall Server-Request, drin

36:07.930 --> 36:08.730
standen.

36:08.870 --> 36:14.710
Und kann die entsprechend dann verwenden, um meine Antwort zu

36:14.710 --> 36:15.330
formulieren.

36:16.010 --> 36:18.350
Ich habe also irgendwelche Formdaten da drin.

36:18.550 --> 36:20.450
Cookies, darauf gehen wir auch noch irgendwann ein.

36:20.890 --> 36:23.050
Wie man die eigentlich erzeugt, oder was das eigentlich sind.

36:23.050 --> 36:30.610
Und dann kann ich halt über diese Variablen-Response entsprechend die

36:30.610 --> 36:33.450
Antwort erzeugen, die zurückgeschickt wird.

36:34.410 --> 36:40.010
Also, ich kann halt jetzt hier ein beliebiges Java-Programm verwenden,

36:40.130 --> 36:41.630
um die Antwort zu erzeugen.

36:41.750 --> 36:46.450
Ich bin nicht so eingeschränkt wie bei den Server-Side-Includes.

36:49.130 --> 36:55.970
Dann haben wir hier ein weiteres Beispiel.

36:56.150 --> 37:00.330
Hier wird also eine Klasse Hallo genannt, als HTTP-Servlet.

37:01.670 --> 37:07.770
Und in diesem Fall auch wieder die Methode doGet.

37:08.710 --> 37:11.990
Da habe ich also Request-Response wieder als Variablen, die

37:11.990 --> 37:13.470
irgendwelche Ausnahmen erzeugen.

37:14.250 --> 37:20.890
Und in diesem Fall soll jetzt also Information rausgeholt werden aus

37:20.890 --> 37:22.590
dem Request.

37:22.970 --> 37:27.870
Wird also aus dem Request-Parameter der Wert dieses Namens rausgeholt.

37:28.010 --> 37:32.410
Sie erinnern sich an unser Beispiel, wo eine Antwort gegeben werden

37:32.410 --> 37:32.810
sollte.

37:33.270 --> 37:35.790
Hallo und dann irgendwie dieser Michael.

37:36.750 --> 37:40.150
Das ist jetzt hier halt auch eine andere Art und Weise formuliert, die

37:40.150 --> 37:42.370
halt in Java-Form abläuft.

37:42.370 --> 37:47.270
Und in dem Fall habe ich also dann, wenn hier mal bei einer Query im

37:47.270 --> 37:53.390
Query -String dieses Name gleich Michael drin stand, wird bei diesem

37:53.390 --> 37:55.830
Servlet entsprechend dieser Wert ausgegeben.

37:56.110 --> 37:58.750
Ich glaube, das ist auch relativ klar, wie das hier abläuft.

37:59.370 --> 38:02.090
Und Sie sehen einfach nur, von der Syntax her völlig anders.

38:02.790 --> 38:05.330
Und es ist halt einfach ein Java-Programm.

38:08.430 --> 38:10.370
Jetzt haben wir hier noch ein etwas komplizierteres.

38:10.370 --> 38:15.770
Ich habe also hier sogar etwas mehr angegeben.

38:15.910 --> 38:21.870
Jetzt habe ich hier in meinem Request, wie das aus dem Request soll,

38:23.150 --> 38:24.530
getParameterNames steht hier.

38:25.170 --> 38:31.290
Das heißt, da werden jetzt alle variablen Wertpaare hier genommen.

38:31.430 --> 38:36.290
Es könnte ja sein, dass man dort mehrere solche Paare hat, die

38:36.290 --> 38:37.390
nacheinander laufen.

38:37.390 --> 38:44.950
Also immer so irgendein Name und irgendein Value, noch ein Name,

38:45.150 --> 38:46.770
irgendein Value und so weiter.

38:47.390 --> 38:51.730
Da werden also alle Parameter-Namen aus dem Query-String ausgeholt.

38:52.190 --> 38:54.270
Deswegen steht hier AllNames.

38:55.230 --> 38:59.710
Und dann geht man in diese AllNames rein, das ist eine Aufzählung.

39:00.430 --> 39:05.250
Solange also ich noch nicht alle Werte in AllNames abgerufen habe,

39:06.710 --> 39:12.550
wird halt der aktuelle Name, der hier jetzt in der Liste dran steht,

39:12.650 --> 39:17.730
AllNames.nextElement, das ist also irgendeine String-Variable, wird

39:17.730 --> 39:23.210
thisName zugewiesen und dann wird einfach dieser Variablen-Name

39:23.210 --> 39:25.310
ausgegeben.

39:25.550 --> 39:26.870
Da steht dann noch ein Plus.

39:28.230 --> 39:30.830
Quatsch, thisName wird ausgegeben und dann eine neue Zeile.

39:30.830 --> 39:35.110
Das heißt, Sie bekommen dann als Ergebnis eine Auflistung der

39:35.110 --> 39:39.170
Variablen -Namen, die in dem Query-String drin standen, jeweils einen

39:39.170 --> 39:42.630
Variablen -Name pro Zeile, weil Sie ja anschließend hier jeweils eine

39:42.630 --> 39:43.490
neue Zeile machen.

39:45.070 --> 39:49.690
Und dann steht hier noch, dass Sie die ganzen Werte sich hier nehmen.

39:51.330 --> 39:52.530
Request, getParameterValues.

39:53.530 --> 39:58.870
Und da holen Sie sich jetzt den Wert von diesem Namen hier, oder

39:58.870 --> 40:07.590
thisName war ja der aktuelle Parameter-Wert.

40:08.010 --> 40:13.530
Wenn jetzt für diesen Namen, ja, genau ein...

40:14.830 --> 40:24.630
Also, if allValues.length allValues hat jetzt alle Werte, die für

40:24.630 --> 40:26.230
diesen Namen angegeben werden.

40:27.330 --> 40:29.650
Das könnte sein, dass das genau ein Name ist.

40:31.190 --> 40:33.310
Ja, genau ein Wert ist.

40:33.790 --> 40:39.790
Dann wird eine Variable thisValue auf den Wert gesetzt, der hier

40:39.790 --> 40:40.290
steht.

40:41.250 --> 40:44.550
Das ist also jetzt ein, dieser allValues von Null.

40:44.730 --> 40:48.570
Dann haben wir hier eine String, ein StringArray.

40:49.730 --> 40:54.750
allValues von Null ist dann genau dieser eine Wert, der dort stand.

40:56.030 --> 41:03.890
Wenn dieser Wert eine Länge von Null hat, und also leer ist, dann wird

41:03.890 --> 41:05.450
hier ausgegeben, leer.

41:06.870 --> 41:08.990
Ansonsten wird genau der Wert ausgegeben.

41:10.270 --> 41:14.210
Jetzt könnte es ja sein, hier steht ja if allValues.length gleich 1.

41:14.310 --> 41:17.530
Es könnte ja auch sein, dass dort überhaupt kein Wert angegeben ist.

41:17.670 --> 41:18.930
Dann brauche ich das hier nicht zu machen.

41:20.230 --> 41:21.990
Oder das wird hier gemacht als...

41:22.850 --> 41:27.170
Nein, hier wird der Wert, hier werden also mehrere Werte angegeben.

41:27.270 --> 41:31.590
Hier ist also die Annahme, dass ich für diesen Parameter-Namen mehrere

41:31.590 --> 41:32.610
Werte angeben kann.

41:32.710 --> 41:35.850
Das mag ja sein, dass das möglich ist in einem Query, dass ich hier

41:35.850 --> 41:38.130
mehrfache Werte angeben kann.

41:38.130 --> 41:43.270
Also wenn bei dieser Abfrage, an dieser Stelle, wo die Parameter-Werte

41:43.270 --> 41:54.170
für thisName aufgerufen werden, wenn dort mehrere Werte abgeliefert

41:54.170 --> 41:58.430
wurden, also hier, das wäre der Fall, dass wir mehrere solche Werte

41:58.430 --> 42:03.250
für den gleichen Parameter-Namen haben, dann müsste ich halt für jeden

42:03.250 --> 42:06.270
dieser Werte entsprechend etwas hinschreiben.

42:06.270 --> 42:10.510
Also steht dann hier eine Schleife.

42:10.990 --> 42:17.130
Solange ich noch nicht alle Werte abgearbeitet habe, schreibe ich hier

42:17.130 --> 42:22.950
also hin, den aktuellen Index, i, und anschließend den aktuellen Wert,

42:23.210 --> 42:25.710
der an der Stelle in diesem Array drin stand.

42:26.750 --> 42:31.450
Und anschließend, und zwar das Ganze jeweils in eine Zeile.

42:32.270 --> 42:34.630
Und dann mache ich anschließend noch eine Leerzeile.

42:34.630 --> 42:38.970
Das heißt, was wir dann bekommen, ist auf der Ausgabe irgendein, ich

42:38.970 --> 42:42.410
schreibe mal einfach hier jetzt irgendeinen Variablen-Namen, das wäre

42:42.410 --> 42:47.470
die Variable, und dahinter, wenn sie jetzt mehrere Werte hätten, würde

42:47.470 --> 42:53.750
dort jetzt stehen Null, und dann ein Null, kein Doppelpunkt, doch, es

42:53.750 --> 43:00.350
steht ein Punkt, Null, Punkt, und dann irgendein Value 1, Punkt, Value

43:00.350 --> 43:05.070
2 stehen, und so weiter, bis zu irgendeinem Wert, und danach hätten

43:05.070 --> 43:08.390
sie dann nochmal eine Leerzeile, und dann würde die nächste Variable

43:08.390 --> 43:08.810
da stehen.

43:09.550 --> 43:12.890
Das ist also das, was dieses etwas ausführlichere Servlet macht.

43:14.110 --> 43:20.350
Hier wird durch mehrere mögliche Parameter-Wertkombinationen

43:20.350 --> 43:23.930
durchgegangen, es werden die gleichen, also wenn man jetzt für einen

43:23.930 --> 43:26.990
Parameter mehrere Werte hat, werden die entsprechend hier alle

43:26.990 --> 43:35.810
aufgelistet, und damit sehen sie einfach, dass man hier einiges mehr

43:35.810 --> 43:39.330
machen kann, oder auch in einer einfachen Java-basierten Form machen

43:39.330 --> 43:42.530
kann, als das mit diesen anderen Methoden möglich war.

43:42.630 --> 43:46.330
Wobei, ich möchte eines, also es ist natürlich so, bei den anderen

43:46.330 --> 43:49.770
Methoden, ich rede jetzt hier von Java-Servlets, wenn Sie CGV-Skripte

43:49.770 --> 43:53.050
nehmen, können Sie natürlich in Perl auch ähnliche Programme

43:53.050 --> 43:54.990
schreiben, Sie können das, was ich Ihnen jetzt hier darstelle,

43:55.090 --> 43:56.730
natürlich auch in ein Perl-Skript schreiben.

43:57.590 --> 44:01.350
Aber das ist halt eine extra wieder neue Programmiersprache, die Sie

44:01.350 --> 44:02.510
sich erstmal aneignen müssen.

44:02.930 --> 44:07.350
Das hier ist halt im Prinzip genau in Java geschrieben, und insofern

44:07.350 --> 44:12.470
führt das zu einer doch deutlich einheitlicheren Art, wie man solche

44:12.470 --> 44:19.950
größere Programm-Umgebungen, kleinen Server-Umgebungen schreiben kann.

44:19.950 --> 44:23.970
Also es ist schon sehr sinnvoll, dass man im Prinzip einen

44:23.970 --> 44:26.470
Programmierstil hat in Java und nicht in vielen verschiedenen

44:26.470 --> 44:28.710
Programmiersprachen schreiben muss.

44:29.790 --> 44:36.530
Bei den SSIs hatten wir Umgebungsvariablen genutzt.

44:37.350 --> 44:42.430
Hier bei Servlets und Java Server Pages kann man auch

44:42.430 --> 44:44.330
Umgebungsvariablen einsetzen.

44:44.330 --> 44:53.190
Sie können also über Get-Befehle die Umgebungsinformationen abfragen.

44:54.010 --> 44:57.950
Und da können Sie also in dieser Java-Umgebung über Methoden

44:57.950 --> 45:03.690
getQueryString, getRemoteUser, getPathInfo zum Beispiel Werte dieser

45:03.690 --> 45:06.890
hier angedeuteten Umgebungsvariablen sich rausholen.

45:07.630 --> 45:10.910
Sie können im Servlet auch Cookies erzeugen.

45:10.910 --> 45:14.710
Sie können also sagen, Sie wollen ein User-Cookie erzeugen und Cookies

45:14.710 --> 45:16.610
sind immer etwas auf Benutzerseite.

45:17.550 --> 45:21.890
Und in diesem Fall wollen Sie also ein Cookie hier erzeugen, bei dem

45:21.890 --> 45:27.570
ein Benutzer steht, was immer Sie hier reinschreiben wollen und in dem

45:27.570 --> 45:28.450
Fall irgendein Wert.

45:28.590 --> 45:31.830
Also Sie können irgendwelche Werte, die in dem Cookie gespeichert

45:31.830 --> 45:38.090
werden sollen, erzeugen, die dann lokal auf dem Client in einer

45:38.090 --> 45:42.030
entsprechenden durch den Browser definierten Stelle als Cookie

45:42.030 --> 45:48.550
abgelegt werden, direkt verbunden mit der URL, die hier gerade

45:48.550 --> 45:49.630
aufgerufen worden war.

45:50.250 --> 45:56.730
Und bei dem Abschicken der Antwort kann dann halt dieser Cookie

45:56.730 --> 46:00.530
mitgeschickt werden, der hier vorher im Programm erzeugt wurde.

46:01.430 --> 46:07.350
Und ich kann natürlich auch beim Aufrufen einer URL die Cookies, die

46:07.350 --> 46:11.970
dazugehören, alle mitgeschickt werden, kann ich natürlich über so eine

46:11.970 --> 46:16.630
Methode getCookies auch die Informationen wieder abholen, die früher

46:16.630 --> 46:19.390
einmal beim früheren Aufruf dort abgelegt wurden.

46:20.070 --> 46:22.770
Ich gehe aber auf Cookies noch etwas später nochmal ein.

46:24.110 --> 46:34.070
Gut, das also zu den Java Servlets und Java Server Pages.

46:34.150 --> 46:36.490
Jetzt haben wir hier die Java Server Pages an der Bank.

46:36.710 --> 46:41.590
Die Servlets und die Java Server Pages, die erlauben, ähnlich wie bei

46:41.590 --> 46:48.210
den SSEs, irgendwelche Umgebungsbarrieren auf die direkt zuzugreifen.

46:48.450 --> 46:52.470
Also hier zum Beispiel auf den Remote Host direkt zuzugreifen.

46:52.590 --> 46:56.790
Das sind also solche, das ist ein dynamischer Code in einer HTML

46:56.790 --> 46:57.410
-Seite.

46:58.290 --> 47:04.050
Und das ist halt ein Tag aus einer HTML-Seite, bei der direkt auf

47:04.050 --> 47:10.190
jetzt ein Operation mit einer Methode zugegriffen wird, die in Java

47:10.190 --> 47:11.710
Server Pages definiert ist.

47:11.710 --> 47:15.790
Das sind halt keine SSEs, sondern diese Java-basierten Angaben.

47:16.890 --> 47:22.850
Und jetzt ein kleiner Unterschied zu den SSPs.

47:26.130 --> 47:32.550
Diese Java Server Pages, die werden vom Server beim Aufruf einer HTML

47:32.550 --> 47:36.890
-Seite direkt in Servlets umgeformt, die dann die gesamte Seite

47:36.890 --> 47:37.630
erzeugen.

47:37.630 --> 47:39.850
Also auch den ganzen statischen Teil.

47:40.630 --> 47:42.630
Bei den SSEs war das anders.

47:43.930 --> 47:49.830
Also hier hat man, also der Aufwand dafür ist insofern etwas größer.

47:51.550 --> 47:53.990
Ich wollte im Wesentlichen auf diesen Unterschied hier nur kurz

47:53.990 --> 47:54.410
hinweisen.

47:55.090 --> 48:00.290
Dann kann man bestimmte Umgebungsvariablen vordefiniert verwenden.

48:00.450 --> 48:03.150
Das ist klar, dass man die braucht, Request, Response, die HTTP

48:03.150 --> 48:05.850
-Session und die Möglichkeit, etwas zu schreiben.

48:05.850 --> 48:09.930
Es gibt andere Variablen, die man dort verwenden kann.

48:11.530 --> 48:13.510
Wenn wir uns das Beispiel hier nochmal angucken.

48:13.650 --> 48:16.550
Dieses Beispiel mit dem Request, Get Remote Host.

48:17.270 --> 48:24.010
Hier würde die Umformung beim Aufruf in ein Servlet so aussehen, dass

48:24.010 --> 48:29.670
man, also hier jetzt in dem Servlet eine Anweisung hat, Out.println,

48:29.670 --> 48:34.990
Client Host Name und dann würde dort stehen, dieser Request, Get

48:34.990 --> 48:36.130
Remote Host.

48:36.850 --> 48:39.910
Und es würde dann der entsprechende Wert dort reingeschrieben werden.

48:41.610 --> 48:46.750
Also wir haben hier jetzt so eine Java Server Page Ausdruck hier

48:46.750 --> 48:52.010
eingesetzt, der halt durch diesen Art Tag angegeben wird.

48:52.010 --> 48:59.050
Und jetzt kann man etwas unterschiedliche Arten von solchen Aufrufen

48:59.050 --> 48:59.570
verwenden.

48:59.670 --> 49:03.090
Man kann das entweder mit diesem Gleichheitszeichen machen oder mit

49:03.090 --> 49:04.330
einem Ausrufezeichen.

49:06.090 --> 49:08.130
Und es ist ein kleiner Unterschied.

49:10.010 --> 49:13.870
Wenn hier Gleichheitszeichen steht, dann wird dieser Ausdruck, der

49:13.870 --> 49:17.390
dahinter steht, hinter diesem Gleichheitszeichen, genau dort

49:17.390 --> 49:20.010
ausgewertet und in das spätere Dokument eingefügt.

49:20.010 --> 49:24.630
Wenn man das mit dem Ausrufezeichen macht, dann ist es eigentlich nur

49:24.630 --> 49:31.730
eine Deklaration, die erst später evaluiert wird, wenn sie in so einer

49:31.730 --> 49:32.290
Umgebung sind.

49:32.630 --> 49:34.010
Das können Sie so nicht verstehen.

49:34.110 --> 49:35.410
Ich gebe Ihnen ein Beispiel dafür.

49:36.270 --> 49:40.710
Sie haben hier ein Servlet bzw.

49:41.110 --> 49:48.150
Java Server Page, wo Sie eine Deklaration haben, eine Variablen, also

49:48.150 --> 49:49.990
Deklaration einer Variablen.

49:50.090 --> 49:55.130
Hier steht jetzt Integer-Variable accessCount gleich 0.

49:56.970 --> 50:04.410
Und jetzt wird dieser accessCount zu Anfang auf 0 gesetzt, aber an der

50:04.410 --> 50:06.230
Stelle soll eigentlich gar nichts stehen.

50:07.410 --> 50:09.250
Da soll kein Inhalt reingeschrieben werden.

50:09.250 --> 50:13.870
Ich möchte nur später an einer Stelle, die hier angegeben ist, möchte

50:13.870 --> 50:18.970
ich gerne einen Wert eintragen.

50:20.710 --> 50:28.630
Und bei jedem Zugriff an dieser Stelle soll also hier dieser Wert der

50:28.630 --> 50:31.730
Variablen accessCount um 1 erhöht werden.

50:31.950 --> 50:36.510
Das heißt, es soll jetzt an dieser Stelle das accessCount ausgewertet

50:36.510 --> 50:36.830
werden.

50:36.830 --> 50:39.830
Das, was hier oben stand, wird zu Anfang auf 0 gesetzt.

50:40.790 --> 50:44.430
Um 1 erhöht wird also zunächst mal eine 1 dann dort stehen.

50:46.390 --> 50:50.270
Und entsprechend kann man also Dinge praktisch deklarieren, Variablen

50:50.270 --> 50:55.010
deklarieren, Teile deklarieren, die dann an späterer Stelle erst

50:55.010 --> 51:00.870
eingesetzt werden, wenn dort also Variablen deklariert wurden, in so

51:00.870 --> 51:05.010
einer Java Server Page Expression vorkommen, wie das hier der Fall

51:05.010 --> 51:05.290
ist.

51:08.250 --> 51:11.310
So, jetzt gibt es noch andere Dinge.

51:11.510 --> 51:14.270
Ich kann also hier zum Beispiel, das ist auch noch eine Java Server

51:14.270 --> 51:18.730
Page Möglichkeit, ich möchte eine Zufallszahl erzeugen.

51:18.870 --> 51:20.890
Im Prinzip möchte ich eine Münze werfen.

51:21.650 --> 51:26.210
Und hier kann ich also zum Beispiel hinschreiben, ich habe hier eine

51:26.210 --> 51:37.870
bedingte Anweisung, kleiner 0,5, dann möchte ich etwas hinschreiben,

51:37.990 --> 51:38.610
nämlich Kopf.

51:39.690 --> 51:44.710
Und wenn es größer gleich 0,5 ist, dann soll Zahl geschrieben werden.

51:45.630 --> 51:47.590
Jetzt habe ich also, wenn ich so etwas in eine HTML Seite

51:47.590 --> 51:53.310
reinschreibe, habe ich also die Möglichkeit, im Server eine

51:53.310 --> 51:55.090
Zufallszahl ziehen zu lassen.

51:55.090 --> 51:58.710
Das passiert durch Aufruf dieser Funktion math.random.

51:59.690 --> 52:03.430
Der Zeuger zieht also eine Zufallszahl und kann dann, so wie es hier

52:03.430 --> 52:07.250
steht, je nachdem, ob die Zahl kleiner als 0,5 ist oder größer als 0

52:07.250 --> 52:10.370
,5, kann er den Wert Kopf oder Zahl reinschreiben.

52:10.450 --> 52:13.930
Das kriegen Sie mit normalem HTML-Code nicht hin.

52:15.130 --> 52:18.590
Da tragen Sie fest einen Wert hin, Sie können keine bedingten

52:18.590 --> 52:20.250
Anweisungen in HTML formulieren.

52:20.250 --> 52:23.310
Auf diese Art und Weise können Sie das formulieren.

52:24.250 --> 52:28.790
Und das hier ist also jetzt etwas, was man noch ganz speziell

52:28.790 --> 52:30.570
Scriptlet nennt.

52:31.690 --> 52:35.630
Und das kann man also auch wieder noch in eine spezielle Umgebung

52:35.630 --> 52:36.230
reinschreiben.

52:36.650 --> 52:38.010
Darauf will ich aber gar nicht weiter eingehen.

52:38.630 --> 52:42.950
Also das ist jetzt eine weitere Möglichkeit, wie man dynamisch Inhalte

52:42.950 --> 52:46.850
in einer Webseite modifizieren kann.

52:46.950 --> 52:49.850
Hier einfach nur auf der Basis eines Tests ausgeführt wird.

52:49.850 --> 52:52.950
Sie können natürlich dort das auch alles komplizierter machen, als ich

52:52.950 --> 52:54.850
das hier in den einfachen Beispielen mache.

52:56.850 --> 53:00.670
Und hier kommt jetzt noch ein etwas konstruiertes weiteres Beispiel.

53:01.010 --> 53:03.990
Das sieht etwas kompliziert aus.

53:05.070 --> 53:06.430
Schauen wir mal, was hier passiert.

53:07.530 --> 53:13.430
Hier haben wir jetzt sogenannte Beans, also Java Server Pages mit

53:13.430 --> 53:14.770
sogenannten Beans.

53:15.410 --> 53:18.630
Das sind also vorgefertigte Komponenten aus irgendeiner Bibliothek.

53:22.690 --> 53:27.810
Und jetzt habe ich hier also eine Variable und irgendeinen Wert.

53:28.510 --> 53:32.610
Bei der steht use Bean, also irgendeine Variable, das heißt die

53:32.610 --> 53:33.510
Identifikator.

53:34.750 --> 53:39.050
Kann so eine Variable sein, also ich kann hier hinschreiben, id gleich

53:39.050 --> 53:39.970
1, 2, 3.

53:40.230 --> 53:45.830
Oder ich kann hier hinschreiben, irgendeine Klasse, irgendein Server

53:45.830 --> 53:46.650
wird aufgerufen.

53:46.650 --> 53:49.510
Dann würde also hier so ein Test Bean aufgerufen werden.

53:50.230 --> 53:56.170
Und jetzt habe ich hier einfach eine Reihe von Anweisungen in so einer

53:56.170 --> 53:57.330
Java Server Page.

53:57.790 --> 54:02.370
Da steht ein use Bean, id gleich Quad.

54:02.370 --> 54:11.770
Und Quad wird also ein Wert sein, also ein Bean mit diesem Namen Quad.

54:12.410 --> 54:17.750
In einer Klasse, Halb.QuadratHal, sei wieder diese Package, die wir

54:17.750 --> 54:21.230
vor dem anderen Beispiel schon mal gesehen hatten.

54:22.450 --> 54:31.110
Und jetzt sehen Sie hier ein SetProperty, Name gleich Quad, Property

54:31.110 --> 54:35.010
gleich Zahl, Value gleich 16.

54:36.510 --> 54:46.210
Also SetProperty, Sie wollen in dem Quad eine bestimmte Set-Methode

54:46.210 --> 54:46.930
ausführen.

54:46.930 --> 54:54.090
Und dieses Set sind also Attributsätzen oder eine Eigenschaft.

54:54.530 --> 54:56.830
Und diese Eigenschaft soll Zahl sein.

54:56.890 --> 54:58.790
Wir kommen gleich drauf, wie das eingebaut wird.

54:59.710 --> 55:04.410
Und der Wert gleich 16.

55:04.610 --> 55:10.250
Also Set, im Prinzip soll hier in einer Anwendung SetZahl gleich 16

55:10.250 --> 55:11.370
geschrieben werden.

55:11.470 --> 55:14.230
Also eine Variable Zahl soll auf 16 gesetzt werden.

55:14.230 --> 55:18.490
Und dann haben wir hier noch einen Get-Operator, GetProperty.

55:19.290 --> 55:22.510
Und hier ist das Property QuadZahl angegeben.

55:22.630 --> 55:27.330
Das heißt, ich will hier eine Methode aufrufen, GetQuadZahl.

55:27.410 --> 55:29.950
Und das Ganze bezieht sich auf ein Java Bean.

55:30.390 --> 55:32.990
Hier ist nochmal das, was Sie gerade eben gesehen haben, angegeben.

55:34.870 --> 55:39.910
Und links sehen Sie jetzt das Java Bean, das hier angesprochen wird.

55:39.990 --> 55:42.150
Wir haben diese Package Hal wieder.

55:42.150 --> 55:48.290
Wir haben eine Klasse, Quadrat, das ist unser Bean.

55:49.850 --> 55:56.250
Und dort drin kommt eine Variable Zahl vor.

55:56.490 --> 55:58.530
Zunächst mal deklariert auf 0.

55:59.130 --> 56:04.150
Und zwei Methoden, eine Set-Methode, eine Get-Methode.

56:05.630 --> 56:09.610
Und in der Set-Methode, das ist eine SetZahl-Methode.

56:10.610 --> 56:23.210
Und diese Zahl-Methode soll also intern eine Variable Vis.Zahl auf den

56:23.210 --> 56:26.950
Wert des Parameters Zahl setzen, der hier angegeben ist.

56:26.950 --> 56:34.310
Und ich gebe also hier einen Wert mit, und der soll dann dieser

56:34.310 --> 56:41.470
internen Variablen, also diesem Objekt hier, Zahl, den Wert geben, der

56:41.470 --> 56:43.790
dort durch diese Set-Methode angegeben ist.

56:44.470 --> 56:49.050
Und ich möchte gerne den Wert heraus, also GetQuadZahl.

56:49.930 --> 56:54.390
Und dieses GetQuadZahl ist eine Methode, die liefert einen String in

56:54.390 --> 56:54.970
dem Fall.

56:55.620 --> 56:57.970
Und das String wird hier angegeben.

56:58.830 --> 57:06.410
Da wird jetzt eine Typ-Konversion, hier wird eine Zahl mit sich selbst

57:06.410 --> 57:09.610
modifiziert, also eine Quadratzahl angegeben.

57:10.690 --> 57:21.750
Und jetzt wird, also hier diese Quadratzahl wird als String ausgegeben

57:21.750 --> 57:23.510
mit dieser Methode GetQuadZahl.

57:23.510 --> 57:28.760
So, dieses Bean quadriert im Prinzip Zahlen.

57:29.650 --> 57:36.310
Und die Frage ist, wie setze ich also so ein Bean ein?

57:36.430 --> 57:38.650
Ich muss ja irgendwie dieses SetZahl aufrufen.

57:38.790 --> 57:45.770
Und hier sehen Sie eben, hier wird SetPropertyName gleich QuadProperty

57:45.770 --> 57:46.410
gleich Zahl.

57:46.410 --> 57:55.230
Durch dieses Statement hier wird also in dem Bean die SetZahl Methode

57:55.230 --> 57:57.810
ausgeführt mit dem Wert 16 da drin.

57:58.350 --> 58:05.550
Und wenn ich dann anschließend diese Java Server Page Anweisung

58:05.550 --> 58:11.830
angebe, dann wende ich hier an GetQuadZahl.

58:11.830 --> 58:16.170
Und GetQuadZahl ist Ausführung dieser Methode.

58:16.790 --> 58:18.830
Und dann wird also der Wert von Zahl quadriert.

58:19.570 --> 58:23.810
Dann würde also in dem Fall hier der Wert von 16 zum Quadrat erzeugt

58:23.810 --> 58:26.230
werden als Wert dieses Ausdrucks.

58:28.410 --> 58:34.710
Bisschen kompliziert, aber ich glaube es ist hoffentlich klar

58:34.710 --> 58:36.850
geworden, was hier gemeint ist.

58:36.950 --> 58:38.830
Ich kann also auf diese Art und Weise zugreifen.

58:38.830 --> 58:43.290
Auf einer HTML-Seite kann ich einen solchen Ausdruck reinschreiben,

58:43.850 --> 58:47.770
mit dem ich auf eine Methode zugreife.

58:48.030 --> 58:50.390
In diesem Fall also diese Halb.Quadrat.

58:51.910 --> 58:57.010
Und jetzt greife ich eben hier auf diesen Namen Quad wieder zu, den

58:57.010 --> 58:58.470
ich hier oben vorher gesetzt habe.

58:59.250 --> 59:04.470
Und setze also erst einen Wert und verwende dann diese Get-Methode, um

59:04.470 --> 59:06.210
einen Wert entsprechend auszugeben.

59:06.210 --> 59:12.710
Und auf diese Art und Weise können Sie eben solche Methoden einsetzen,

59:12.950 --> 59:17.810
auf einer HTML-Seite ansprechen, durch solche Java-Server-Pages

59:17.810 --> 59:18.610
ausdrücken.

59:19.330 --> 59:25.570
Okay, das zu diesen Java-Servernets und Java-Server-Pages.

59:26.210 --> 59:29.390
Alles das, was man mit Java-Servernets und Java-Server-Pages machen

59:29.390 --> 59:33.170
kann, kann man auch mit CGI-Skripten und mit SSI machen.

59:33.170 --> 59:38.090
Aber auf der Java-Seite ist es eben alles in einer einheitlichen

59:38.090 --> 59:39.030
Programmiersprache.

59:39.530 --> 59:44.310
Während das auf der anderen Seite einerseits mehr Freiheit erlaubt,

59:44.330 --> 59:46.470
weil ich da beliebige Programmiersprachen hinschreiben kann.

59:46.850 --> 59:49.410
Häufig verwendet man halt Perl-Skripte, aber man muss es nicht.

59:49.470 --> 59:53.730
Man kann auch andere nehmen, sofern man die CGI-Schnittstelle

59:53.730 --> 59:55.070
unterstützen kann.

59:55.070 --> 01:00:00.410
Und ich habe dann eben noch diese SSI-Möglichkeiten, die auf der Java

01:00:00.410 --> 01:00:04.270
-Seite durch diese Java-Server-Page-Ausdrücke ersetzt sind.

01:00:04.550 --> 01:00:07.350
Aber die bieten dann eben deutlich mehr Möglichkeiten.

01:00:08.170 --> 01:00:11.490
Und ich habe halt mit Java immer die Plattform-Unabhängigkeit.

01:00:13.010 --> 01:00:18.610
Das Ganze ist... also ein weiterer Vorteil ist, dass es

01:00:18.610 --> 01:00:19.790
ressourcenschonender ist.

01:00:19.790 --> 01:00:24.870
Wenn ich dasselbe Skript mehrfach aufrufe, dann wird eben jeweils

01:00:24.870 --> 01:00:27.870
nicht ein neuer Prozess, sondern nur ein neuer Thread erzeugt.

01:00:27.990 --> 01:00:28.970
Sie kennen die Unterschiede.

01:00:29.070 --> 01:00:30.650
Ein Prozess hat einen eigenen Adressraum.

01:00:31.290 --> 01:00:35.390
Ein Thread erzeugt keinen neuen Adressraum, ist also

01:00:35.390 --> 01:00:36.890
speicherplatzschonender.

01:00:38.090 --> 01:00:42.590
Und Sie haben halt bei der Java-Verbindung einfach die üblichen

01:00:42.590 --> 01:00:44.650
Vorteile der Objektorientierung.

01:00:45.650 --> 01:00:54.370
Gut, das sei genug zu diesen Java-Server-Pages und dem CI.

01:00:54.670 --> 01:00:58.050
Jetzt kommt hier noch etwas, die Microsoft-Variante, Active-Server

01:00:58.050 --> 01:00:58.630
-Pages.

01:01:00.650 --> 01:01:04.570
Das setzt halt speziell auf den Internet-Information-Server.

01:01:05.250 --> 01:01:09.210
Das heißt, Sie können also Active-Server-Pages halt auf dem Internet

01:01:09.210 --> 01:01:12.990
-Information -Server einsetzen, aber Sie können die halt nicht auf

01:01:12.990 --> 01:01:17.890
jedem Browser einsetzen, unterstützt werden.

01:01:18.450 --> 01:01:25.230
Hier eine ganze Reihe serverseitige Skripte.

01:01:25.330 --> 01:01:31.630
Sie haben also JavaScript oder verschiedene Microsoft-unterstützte

01:01:31.630 --> 01:01:35.850
Server oder Servlet-ähnliche Dinge.

01:01:39.830 --> 01:01:44.130
Ich will auf die Active-Server-Pages gar nicht groß eingehen.

01:01:44.450 --> 01:01:47.650
Im Prinzip setzt man eigentlich gar nicht mehr so viele Active-Server

01:01:47.650 --> 01:01:54.610
-Pages ein, sondern man geht auf die .net-Plattform, asp.net, wo man

01:01:54.610 --> 01:01:56.590
mehr Richtung Web-Services geht.

01:01:57.570 --> 01:02:03.710
Und deswegen möchte ich eigentlich hierzu Active-Server-Pages Ihnen

01:02:03.710 --> 01:02:04.790
gar nicht mehr so viel erzählen.

01:02:04.790 --> 01:02:08.570
Das Wesentliche waren jetzt diese Java-Servlets und das ist hier

01:02:08.570 --> 01:02:12.370
einfach nochmal nur eine kurze Angabe, welche Stichworte auf der

01:02:12.370 --> 01:02:15.630
Microsoft -Seite eine Rolle spielen.

01:02:17.050 --> 01:02:22.990
Hier ist doch noch ein Beispiel angegeben, bei dem man halt mit wieder

01:02:22.990 --> 01:02:29.670
einer etwas anderen Notation jetzt solche Active-Server-Page-Elemente

01:02:29.670 --> 01:02:30.710
mit eingebaut hat.

01:02:30.710 --> 01:02:34.510
Also hier wird angegeben, welche Sprache speziell verwendet wird, in

01:02:34.510 --> 01:02:35.880
dem Fall das Visual Basic-Skript.

01:02:36.990 --> 01:02:41.170
Und hier haben Sie also auch eine Code-Angabe.

01:02:41.310 --> 01:02:47.910
Hier wird also abgefragt, ob es nach 18 Uhr ist oder ob es vor 6 Uhr

01:02:47.910 --> 01:02:48.330
ist.

01:02:49.470 --> 01:02:53.530
Mit diesem Skript könnten Sie also fragen, ob es beim Server gerade

01:02:53.530 --> 01:02:55.510
Nacht ist oder ob es dort Tag ist.

01:02:56.170 --> 01:03:00.030
Weil hier die lokale Zeit beim Server abgefragt wird, nicht die Zeit

01:03:00.030 --> 01:03:00.690
beim Client.

01:03:02.410 --> 01:03:08.590
Und insofern hätten Sie hier eine Möglichkeit, wie Sie bei dem Abruf

01:03:08.590 --> 01:03:15.330
einer HTML-Seite vom Server bei dem entsprechenden Client-Rechner, wo

01:03:15.330 --> 01:03:18.550
diese Seite dargestellt wird, angeben können, ob ein Server gerade

01:03:18.550 --> 01:03:19.890
Nacht oder Tag gewesen ist.

01:03:19.890 --> 01:03:23.070
Ein kleines Beispiel, das nur zeigt, es sind die gleichen

01:03:23.070 --> 01:03:26.890
Möglichkeiten da, wie bei den anderen Beispielen, die ich Ihnen

01:03:26.890 --> 01:03:27.590
genannt habe.

01:03:28.090 --> 01:03:30.210
Die anderen Sprachen eigentlich auch.

01:03:32.390 --> 01:03:35.710
Ein Stichwort muss auf jeden Fall fallen, wenn man über dynamische

01:03:35.710 --> 01:03:36.610
Webseiten redet.

01:03:36.710 --> 01:03:39.030
Das ist PHP, Hypertext Preprocessor.

01:03:39.970 --> 01:03:44.090
PHP braucht man vor allen Dingen, wenn es um Datenbank-Abfragen geht.

01:03:45.010 --> 01:03:49.610
Ich hatte Ihnen diese Abkürzung genannt, LAMP und WAMP.

01:03:49.730 --> 01:03:54.150
Das wäre also Linux, Apache, MySQL und PHP.

01:03:55.530 --> 01:04:03.230
PHP ist eine Sprache, eine Script-Sprache, die speziell für Datenbank

01:04:03.230 --> 01:04:05.850
-Abfragen sehr gut geeignet ist.

01:04:06.770 --> 01:04:09.770
Hier ist ein kleines Beispiel für die Nutzung.

01:04:09.770 --> 01:04:10.890
Das ist natürlich viel zu einfach.

01:04:11.390 --> 01:04:13.610
Da haben Sie also PHP-Anweisungen.

01:04:13.770 --> 01:04:15.710
Wieder ein bisschen anderes Tag.

01:04:15.950 --> 01:04:17.390
Bisschen länger bis dahin.

01:04:17.590 --> 01:04:19.530
Da wird also wieder das Hello-World-Beispiel gemacht.

01:04:19.910 --> 01:04:22.830
Was aber natürlich gar nicht die Möglichkeiten von PHP richtig

01:04:22.830 --> 01:04:23.270
darstellt.

01:04:23.350 --> 01:04:26.770
Nur, dass Sie sehen, das ist in dem Fall Gesundheits- und PHP-Anteile

01:04:26.770 --> 01:04:27.770
darzustellen.

01:04:30.610 --> 01:04:34.270
Und hier steht es jetzt nochmal, die Unterstützung von Datenbanken ist

01:04:34.270 --> 01:04:35.010
halt sehr wichtig.

01:04:35.010 --> 01:04:39.690
Sie können insbesondere MySQL unterstützen, My Structured Query

01:04:39.690 --> 01:04:40.290
Language.

01:04:40.690 --> 01:04:48.110
Also irgendwelche Anfragen auf einfache Datenbanken hiermit

01:04:48.110 --> 01:04:49.730
formulieren.

01:04:50.650 --> 01:04:56.290
Und ich werde da ein ganz kurzes Beispiel dazu machen, bei dem ich von

01:04:56.290 --> 01:04:57.330
folgendem ausgehe.

01:04:57.430 --> 01:04:59.930
Ich habe eine kleine Datenbank D1.

01:05:00.730 --> 01:05:03.650
Und in dieser Datenbank sind irgendwelche Assistenten abgelegt.

01:05:03.650 --> 01:05:06.990
Also Assistenten mit fünf Attributen.

01:05:07.870 --> 01:05:09.650
Identifikator für den Assistenten.

01:05:10.550 --> 01:05:14.710
Dann ein Vorname, ein Nachname, eine Adresse und eine E-Mail-Angabe.

01:05:15.430 --> 01:05:19.410
Und es sind halt einige spezielle Einträge schon drin mit solchen

01:05:19.410 --> 01:05:19.750
Assistenten.

01:05:19.750 --> 01:05:27.030
Und jetzt wird in einem einfachen PHP-Skript der 0.

01:05:27.110 --> 01:05:31.470
Eintrag, also der erste, beziehungsweise im Sinne der Zählweise hier,

01:05:31.570 --> 01:05:31.890
der 0.

01:05:31.990 --> 01:05:35.170
Eintrag in dieser Datenbank abgefragt.

01:05:35.830 --> 01:05:43.050
Also dies ist jetzt eine solche PHP-Einbettung in eine HTML-Seite.

01:05:44.190 --> 01:05:47.610
Sie müssen sich zunächst einmal mit der Datenbank verbinden.

01:05:47.610 --> 01:05:52.970
Dann müssen Sie sagen, wo diese Datenbank eigentlich liegt und wie Sie

01:05:52.970 --> 01:05:54.290
da zugreifen.

01:05:54.890 --> 01:05:58.510
Dann müssen Sie mit dem Server verbinden.

01:05:58.670 --> 01:06:00.470
Sie müssen die Datenbank auswählen.

01:06:00.930 --> 01:06:03.750
Das ist also hier die Datenbank D1, die ausgewählt wird.

01:06:04.650 --> 01:06:10.790
Und jetzt müssen Sie sagen, was Sie in der Datenbank überhaupt machen

01:06:10.790 --> 01:06:11.230
wollen.

01:06:11.230 --> 01:06:16.050
Die Query in dem Fall sieht also so aus, dass Sie eine SELECT

01:06:16.050 --> 01:06:17.350
-Anweisung machen wollen.

01:06:18.150 --> 01:06:20.970
Und was soll ausgesucht werden?

01:06:21.590 --> 01:06:26.050
Es soll alles rausgeholt werden, also SELECT STAR FROM ASSIST.

01:06:26.670 --> 01:06:30.970
Das ist also unsere Tabelle, die ich dort ansprechen möchte, in der

01:06:30.970 --> 01:06:35.350
Datenbank, die vorher gerade ansprochen worden war.

01:06:35.350 --> 01:06:42.530
Und jetzt soll hier geschrieben werden, auf der HTML-Seite, die ich

01:06:42.530 --> 01:06:47.830
jetzt erzeugen möchte, als HTML-Text, Vorname.

01:06:49.210 --> 01:06:58.810
Dann steht hier, es geht gleich noch weiter.

01:06:58.810 --> 01:07:11.270
Also ich habe hier ein %s-n und jetzt steht hier das Ergebnis, also

01:07:11.270 --> 01:07:15.090
Abfrage dieser...

01:07:15.090 --> 01:07:20.470
Es soll also reingeschrieben werden, an dieses S, das Ergebnis der

01:07:20.470 --> 01:07:23.230
Abfrage auf dieses Assis.

01:07:23.230 --> 01:07:24.170
An die 0.

01:07:24.230 --> 01:07:29.190
Position meiner Assist-Tabelle und dort das Attribut Vorname.

01:07:30.630 --> 01:07:36.150
Und das ist halt das Ergebnis, das rausgekommen war aus meiner Query.

01:07:37.190 --> 01:07:38.850
Und da gehe ich halt an den 0.

01:07:38.930 --> 01:07:44.030
Eintrag ran und schreibe jetzt nacheinander Vorname sowieso, Nachname

01:07:44.030 --> 01:07:46.230
sowieso, neue Zeile, Adresse.

01:07:46.230 --> 01:07:53.390
Auch wieder ein Ergebnis dieser MySQL-Abfrage und eine neue Zeile und

01:07:53.390 --> 01:07:54.530
anschließend noch die E-Mail-Adresse.

01:07:55.150 --> 01:07:59.330
Also ich möchte eine Folge von Zeilen haben, in der jetzt der Vorname,

01:07:59.450 --> 01:08:06.270
Nachname, Adresse und E-Mail angegeben werden von der ersten Zeile in

01:08:06.270 --> 01:08:07.010
meiner Tabelle.

01:08:07.690 --> 01:08:11.810
Da stehen halt hier die ganzen Felder drin und die sollen halt der

01:08:11.810 --> 01:08:13.050
Reihe nach ausgegeben werden.

01:08:13.050 --> 01:08:17.710
Und das kann ich über diese PHP-Formulierung hier machen.

01:08:18.370 --> 01:08:23.130
Localhost ist also der Server und Anonymous, das ist ja klar, ist der

01:08:23.130 --> 01:08:26.610
Login, der hier natürlich auch irgendwie ermöglicht werden muss.

01:08:27.410 --> 01:08:30.650
Hier kann ich halt mit Anonymous zugreifen.

01:08:33.710 --> 01:08:37.290
Sie müssen sich halt entsprechend identifizieren mit der Art, wie das

01:08:37.290 --> 01:08:38.210
dort vorgesehen ist.

01:08:38.210 --> 01:08:43.410
Und wenn Sie nicht nur einen Eintrag ausgeben wollen, sondern alle

01:08:43.410 --> 01:08:48.070
Einträge, dann kann man das eben so machen, dass man jetzt

01:08:48.070 --> 01:08:50.850
entsprechend eine While-Anweisung macht.

01:08:50.850 --> 01:09:00.130
Das heißt, solange ich hier in dem Ergebnis aus meiner

01:09:00.130 --> 01:09:06.750
Datenbankabfrage noch Einträge habe, schreibe ich genau das gleiche

01:09:06.750 --> 01:09:07.190
hier hin.

01:09:07.330 --> 01:09:09.470
Vorname, Nachname, Adresse, E-Mail.

01:09:09.470 --> 01:09:16.790
Und für diese Platzhalter, die hier vorne stehen, dieses %s, soll der

01:09:16.790 --> 01:09:22.590
Reihe nach eingesetzt werden, das Ergebnis, das Attributs Vorname,

01:09:22.730 --> 01:09:28.130
Ergebnis Attribut Nachname, Ergebnis Attribut Adresse und E-Mail.

01:09:31.350 --> 01:09:38.730
Also, auf die Art und Weise habe ich dann eine Liste aller Einträge in

01:09:38.730 --> 01:09:39.630
der Tabelle gemacht.

01:09:40.650 --> 01:09:43.370
Und das ist halt die Möglichkeit, das mit PHP zu formulieren.

01:09:44.390 --> 01:09:48.230
Und es ist klar, dass man auf diese Art und Weise sehr einfach Inhalte

01:09:48.230 --> 01:09:54.110
von Datenbanken auf die zugreifen und auch hier visualisieren kann.

01:09:55.330 --> 01:09:59.690
Also, solange noch neue Zeilen kommen, ist dieses MyRoll ungleich

01:09:59.690 --> 01:10:00.070
Null.

01:10:00.990 --> 01:10:02.730
Und die Schleife wird dann erneut ausgeführt.

01:10:02.950 --> 01:10:10.330
Ansonsten ist die Schleife beendet und ich kann was anderes machen.

01:10:10.810 --> 01:10:12.890
So, auch nur ein kurzer Einstieg in PHP.

01:10:16.450 --> 01:10:20.050
Und wie gesagt, nur einige Informationen.

01:10:20.870 --> 01:10:27.310
Wenn Sie so eine PHP Datei mit einem Query String aufrufen, dann

01:10:27.310 --> 01:10:32.350
werden durch PHP entsprechend die Variablen wertbarer erzeugt.

01:10:32.410 --> 01:10:36.830
Naja, das ist klar, dass PHP das sinnvoll auswerten muss.

01:10:37.510 --> 01:10:41.230
Und wenn ich jetzt einen neuen Assi einfügen will in die Datenbank,

01:10:41.510 --> 01:10:45.290
dann muss ich entsprechend halt dafür sorgen, dass dort ich an die

01:10:45.290 --> 01:10:47.230
richtige Stelle zugreifen kann.

01:10:47.230 --> 01:10:52.790
Dann muss ich die Werte eingeben können in eine HTML-Seite.

01:10:52.930 --> 01:10:54.030
Ich brauche also ein Formular.

01:10:54.470 --> 01:10:56.950
Bei dem Formular muss ich der Reihe nach die Werte für diesen

01:10:56.950 --> 01:10:57.910
Assistenten eingeben.

01:10:58.030 --> 01:11:00.990
Vorname, Nachname, Adresse und E-Mail-Adresse.

01:11:01.970 --> 01:11:05.810
Und dann muss ich mit irgendeinem Submit-Button die Daten übergeben.

01:11:06.610 --> 01:11:11.250
Und dann hier ist es angegeben, hier wird es also mit Post gemacht.

01:11:11.850 --> 01:11:18.090
Wird zugegriffen, also die Aktion ist eine Datenbank, ein PHP-Skript,

01:11:18.390 --> 01:11:21.010
hier Daba PHP 3.

01:11:21.370 --> 01:11:24.870
Also wird aus dieser Variante von PHP zugegriffen.

01:11:24.870 --> 01:11:32.150
Und jetzt habe ich hier meine Formangaben.

01:11:32.330 --> 01:11:35.570
Also auf der HTML-Seite stehen jetzt Vorname, Nachname, Adresse, E

01:11:35.570 --> 01:11:37.050
-Mail der Reihe nach.

01:11:37.530 --> 01:11:40.170
Also hier, das sind die ganzen Dinger, die da stehen, die eingegeben

01:11:40.170 --> 01:11:40.690
werden sollen.

01:11:40.810 --> 01:11:44.070
Daneben jeweils ein Fenster, um Werte einzugeben.

01:11:44.070 --> 01:11:47.550
Und da können Sie jetzt entsprechend Texte eingeben.

01:11:48.550 --> 01:11:54.830
Und die werden jetzt intern Variablen vor, nach, Adresse und Mail

01:11:54.830 --> 01:11:55.550
zugewiesen.

01:11:56.030 --> 01:11:59.730
Sie haben in ein Submit, also das waren hier fünf solche

01:11:59.730 --> 01:12:00.670
Eingabefelder.

01:12:01.070 --> 01:12:05.690
Sie haben irgendein Submit-Button und dann können Sie die Werte

01:12:05.690 --> 01:12:06.810
entsprechend abliefern.

01:12:06.810 --> 01:12:16.830
Und das PHP-Skript wird dann diesen Namen vor, nach und so weiter die

01:12:16.830 --> 01:12:19.570
Werte zuordnen, die eingegeben worden sind.

01:12:19.970 --> 01:12:24.850
Und kann die dann entsprechend der Formulierung in den PHP-Skript in

01:12:24.850 --> 01:12:26.790
die Datenbank reinschreiben.

01:12:27.030 --> 01:12:28.990
Also es wird dieser Aufruf gemacht.

01:12:30.170 --> 01:12:32.410
Es wird Daba.php erzeugt.

01:12:32.630 --> 01:12:35.010
Und die Operation ist einfügen.

01:12:35.010 --> 01:12:43.230
Und es soll dann entsprechend die Werte von vor, nach, Adresse und

01:12:43.230 --> 01:12:46.310
Mail hier eingegeben werden.

01:12:47.190 --> 01:12:53.870
Und Sie erinnern sich, dass dort manchmal solche Prozentzeichen drin

01:12:53.870 --> 01:12:54.670
stehen können.

01:12:54.670 --> 01:13:01.370
Und dieses %40 ist gerade der Klammeraffe.

01:13:01.930 --> 01:13:04.410
Das ist das Hexadezimalzeichen.

01:13:05.090 --> 01:13:07.530
Und Hexadezimal 40 ist halt gerade das 64.

01:13:08.830 --> 01:13:09.470
Zeichen.

01:13:09.710 --> 01:13:11.990
ASCII-Zeichen, das ist gerade dieser Klammeraffe.

01:13:12.550 --> 01:13:15.990
Also bla.et.phasen.de, die Mail-Adresse in dem Fall.

01:13:15.990 --> 01:13:22.970
Und das Einfügen direkt wird jetzt also so gemacht, dass Sie, wenn die

01:13:22.970 --> 01:13:26.250
Operation einfügen ist, dann entsprechend sich wieder verbinden mit

01:13:26.250 --> 01:13:29.110
der Datenbank auf dem Server anonym eingeloggt.

01:13:29.690 --> 01:13:32.070
Wird die Datenbank D1 ausgewählt.

01:13:32.950 --> 01:13:40.190
Und dann soll an dieser Stelle etwas eingefügt werden in die Tabelle

01:13:40.190 --> 01:13:41.470
ASCIIs.

01:13:41.470 --> 01:13:45.810
Und zwar für die Attribute Vorname, Nachname, Adresse, E-Mail.

01:13:45.890 --> 01:13:49.010
Das waren die Attribute, die dort in der ASCII-Datenbank stehen.

01:13:49.330 --> 01:13:53.950
Sollen die Werte eingegeben werden, die durch die Variablen, die im

01:13:53.950 --> 01:13:58.850
Queue -String drin standen, Vor, Nach, Adre und Mail halt gerade drin

01:13:58.850 --> 01:13:59.890
standen.

01:13:59.890 --> 01:14:07.350
Und dann haben Sie nochmal das Ergebnis sich rausgeholt.

01:14:08.110 --> 01:14:12.430
Das ist normal eine Ergebnis-Variable für das Eintragen dann in diese

01:14:12.430 --> 01:14:12.970
Datenbank.

01:14:13.610 --> 01:14:18.050
Also das ist einfaches PSP-Script, um etwas in eine Datenbank

01:14:18.050 --> 01:14:18.890
reinzuschreiben.

01:14:19.410 --> 01:14:20.970
Das andere war, etwas rauszuholen.

01:14:21.770 --> 01:14:24.650
Ich würde nicht behaupten, dass Sie jetzt in der Lage sind, konkret

01:14:24.650 --> 01:14:26.630
bei der Datenbank schon etwas zu schreiben.

01:14:26.630 --> 01:14:30.330
Aber Sie sehen, welche Möglichkeiten dort bestehen, wofür man PHP

01:14:30.330 --> 01:14:31.530
nutzen könnte.

01:14:33.730 --> 01:14:37.310
Jetzt habe ich Ihnen eine ganze Reihe solcher einfachen Techniken

01:14:37.310 --> 01:14:39.010
dargestellt.

01:14:39.310 --> 01:14:42.870
Jetzt kann ich mich entscheiden, ob es 13 Uhr oder 12.50 Uhr ist.

01:14:43.090 --> 01:14:45.490
Aber nach meiner Uhr ist es 12.50 Uhr.

01:14:45.690 --> 01:14:46.870
Entscheide ich mich dafür.

01:14:47.050 --> 01:14:49.370
Diese beiden Uhren hier sind wirklich interessant.

01:14:50.290 --> 01:14:53.590
Sie haben jedes Mal wieder eine andere... oder die linke Uhr hat immer

01:14:53.590 --> 01:14:54.390
eine andere Funktion.

01:14:54.490 --> 01:14:55.470
Mal rennt sie ganz schnell.

01:14:55.470 --> 01:14:58.370
Jetzt geht sie 10 Minuten vor.

01:15:00.170 --> 01:15:03.510
Das, worüber ich Ihnen eigentlich die ganze Zeit erzählt habe, sind

01:15:03.510 --> 01:15:06.810
Möglichkeiten, wie ich dynamische Webseiten erstellen kann.

01:15:07.570 --> 01:15:11.450
Und dafür gibt es eine ganze Reihe verschiedener Möglichkeiten.

01:15:13.370 --> 01:15:18.310
Ich möchte gerne den Inhalt von Webseiten an die aktuellen

01:15:18.310 --> 01:15:20.410
Rahmenbedingungen des Aufrufs anpassen.

01:15:21.290 --> 01:15:24.170
Und zu diesen aktuellen Rahmenbedingungen zählen verschiedene Dinge.

01:15:24.170 --> 01:15:27.930
Was ich Ihnen bei den Beispielen genannt hatte, war Zugriff auf

01:15:27.930 --> 01:15:29.170
Umgebungsvariablen.

01:15:29.870 --> 01:15:34.730
Uhrzeit oder aktueller Browser beim Client oder irgend solche Dinge.

01:15:35.050 --> 01:15:36.650
Also Browsertyp, Betriebssystem.

01:15:37.690 --> 01:15:39.550
Benutzerprofil könnte interessant sein.

01:15:39.670 --> 01:15:40.550
Datum, Ort.

01:15:40.690 --> 01:15:43.410
Bei Benutzerprofilen zucken einige immer zusammen, weil das

01:15:43.410 --> 01:15:48.310
persönliche, individuelle Information ist, die man vielleicht gar

01:15:48.310 --> 01:15:49.630
nicht weitergeben möchte.

01:15:50.490 --> 01:15:52.710
Was könnte beim Server interessant sein?

01:15:52.930 --> 01:15:54.490
Wie ausgelastet ist der gerade?

01:15:55.330 --> 01:15:57.090
Was steht dort in Datenbanken drin?

01:15:58.050 --> 01:16:02.390
Dann könnte es alle möglichen Dinge geben, die beim Server eine Rolle

01:16:02.390 --> 01:16:07.830
spielen, die sich ausdrücken in der Art, wie eine HTML-Seite gestaltet

01:16:07.830 --> 01:16:08.190
wird.

01:16:09.230 --> 01:16:12.510
Dafür kann ich die Techniken einsetzen, die ich hier jetzt gelernt

01:16:12.510 --> 01:16:12.950
habe.

01:16:13.830 --> 01:16:16.850
Man kann auch etwas weitergehende Techniken einsetzen.

01:16:16.850 --> 01:16:21.290
Man wird heute immer stärker Web-Services einsetzen und Service

01:16:21.290 --> 01:16:22.430
-orientierte Architekturen.

01:16:23.850 --> 01:16:29.630
Aber das hier sind eigentlich alles die Basistechniken, die man nutzen

01:16:29.630 --> 01:16:33.550
kann, wenn man Webseiten dynamisch bauen will.

01:16:35.170 --> 01:16:39.990
Das Wesentliche ist halt, dass der Inhalt, Layout, Präsentation der

01:16:39.990 --> 01:16:44.270
Webseiten erst aufgrund des HTTP-Aufrufs festgelegt werden.

01:16:44.270 --> 01:16:47.650
Das heißt, Sie könnten auch so Dinge machen, dass Sie zum Beispiel

01:16:47.650 --> 01:16:51.530
eine Webseite unterschiedlich sich darstellen lassen, je nachdem, ob

01:16:51.530 --> 01:16:52.670
es Tag oder Nacht ist.

01:16:53.290 --> 01:16:54.010
Überhaupt kein Problem.

01:16:54.170 --> 01:17:02.470
Sie müssen entsprechend die Style-Files, also CSS, müssen Sie

01:17:02.470 --> 01:17:07.450
entsprechend davon abhängig machen, was Ihre Umgebungsvariable Ihnen

01:17:07.450 --> 01:17:09.850
sagt, was gerade für die Tageszeit ist.

01:17:09.850 --> 01:17:12.490
Da könnten Sie also unterschiedliche Gestaltungen machen für die

01:17:12.490 --> 01:17:13.170
Präsentation.

01:17:13.750 --> 01:17:16.450
Inhalt, Layout habe ich Ihnen schon gesagt, dass man das natürlich

01:17:16.450 --> 01:17:17.250
auch dann machen kann.

01:17:17.350 --> 01:17:20.670
Sie können je nachdem, wer einen Aufruf macht, den Inhalt

01:17:20.670 --> 01:17:21.550
unterschiedlich machen.

01:17:22.070 --> 01:17:25.230
Auf jeden Fall, das ist Standard, machen Sie je nachdem, welcher

01:17:25.230 --> 01:17:29.830
Browser ein Request schickt, die Inhalte unterschiedlich.

01:17:29.830 --> 01:17:39.130
Also ja, der Internet Explorer stellt HTTP-Code anders dar als der

01:17:39.130 --> 01:17:40.490
nationale Firefox.

01:17:41.510 --> 01:17:46.070
Und entsprechend müssen Sie, wenn Sie auf jedem Browser eine sinnvolle

01:17:46.070 --> 01:17:50.470
Darstellung haben wollen, müssen Sie abfragen, was ist eigentlich der

01:17:50.470 --> 01:17:54.410
vom Benutzer verwendete Browser, damit man eine vernünftige

01:17:54.410 --> 01:17:58.770
Darstellung hat, die auf jedem Browser im Prinzip identisch oder

01:17:58.770 --> 01:18:04.750
zumindest angepasst an das gewünschte Erscheinungsbild ist.

01:18:05.850 --> 01:18:08.970
Gut, das waren also Inhalt, Layout, Präsentation.

01:18:10.030 --> 01:18:12.470
Und dann möchte ich natürlich auch persönliche Informationen

01:18:12.470 --> 01:18:16.910
desjenigen benutzen können, der dort lokal davor sitzt.

01:18:17.990 --> 01:18:21.350
Und dafür benutzt man Dinge wie Personalisierung.

01:18:22.310 --> 01:18:25.850
Also ein Student sollte vielleicht andere Inhalte dargestellt bekommen

01:18:25.850 --> 01:18:29.430
als jemand anders oder nicht vielleicht etwas in einer anderen Form

01:18:29.430 --> 01:18:29.950
als Sie.

01:18:31.450 --> 01:18:33.990
Und dann muss man natürlich in der Lage sein, Benutzer- und

01:18:33.990 --> 01:18:35.350
Serviceprofile zu erheben.

01:18:36.290 --> 01:18:38.110
Und die Frage ist, wie macht man das eigentlich?

01:18:38.610 --> 01:18:45.310
Wie kann der Server mitbekommen, wer eigentlich vor diesem Rechner

01:18:45.310 --> 01:18:45.850
sitzt?

01:18:45.850 --> 01:18:48.510
Dazu müsste man eine Webcam haben, um das mitzubekommen.

01:18:49.250 --> 01:18:50.550
Es gibt vielleicht weitere Informationen.

01:18:51.210 --> 01:18:54.550
Und Versuche, sowas hinzukriegen, ist halt über Cookies das zu machen

01:18:54.550 --> 01:18:55.470
und über Profile.

01:18:56.670 --> 01:19:00.210
Genau darauf muss ich also als nächstes eingehen, auf die Techniken,

01:19:00.290 --> 01:19:02.070
wie man Cookies und Profile macht.

01:19:02.650 --> 01:19:04.250
Ich hatte Cookies schon kurz erwähnt.

01:19:05.490 --> 01:19:10.650
Cookies sind also eine Möglichkeit, wie man Informationen über einen

01:19:10.650 --> 01:19:14.910
Zugriff auf Webserver-Seiten, also auf HTML-Seiten, wie man diese

01:19:14.910 --> 01:19:21.030
Informationen für einen späteren Zugriff wieder zur Verfügung stellt.

01:19:22.170 --> 01:19:25.670
Und das Problem ist, dass das HTTP-Protokoll normalerweise davon gar

01:19:25.670 --> 01:19:30.570
nichts weiß, ob vorher schon einmal die gleiche URL aufgerufen worden

01:19:30.570 --> 01:19:30.970
ist.

01:19:31.490 --> 01:19:33.650
Das HTTP-Protokoll ist zustandslos.

01:19:33.910 --> 01:19:37.370
Eigentlich ist es so, dass Sie, wann immer Sie eine URL aufrufen,

01:19:37.450 --> 01:19:40.830
bekommen Sie genau die Seite, genau das, was im Query-String oder in

01:19:40.830 --> 01:19:43.850
dem URL-String drin steht, genau das wird geliefert.

01:19:45.130 --> 01:19:49.970
Und das Protokoll weiß nicht, ob Sie vorher schon einmal die gleiche

01:19:49.970 --> 01:19:51.090
Seite aufgerufen haben.

01:19:51.750 --> 01:19:55.210
Und dafür hat man dann aber trotzdem eben sich Möglichkeiten überlegt,

01:19:55.270 --> 01:19:56.530
wie man das hinbekommen kann.

01:19:57.650 --> 01:20:03.050
Und zwar so, dass die Speicherung der Informationen darüber, ob man

01:20:03.050 --> 01:20:06.610
vorher schon einmal die Seite aufgerufen hat, auf Client-Seite

01:20:06.610 --> 01:20:07.410
erfolgt.

01:20:08.290 --> 01:20:12.930
Das heißt, der Client selber speichert die Informationen ab, dass er

01:20:12.930 --> 01:20:15.350
schon einmal auf eine Seite zugegriffen hat.

01:20:16.170 --> 01:20:19.510
Und beim nächsten Zugriff wird genau diese Information wieder

01:20:19.510 --> 01:20:20.190
mitgeliefert.

01:20:21.210 --> 01:20:32.170
Also, die Information über einen HTTP-Zugriff wird erzeugt auf Server

01:20:32.170 --> 01:20:32.650
-Seite.

01:20:32.650 --> 01:20:35.610
Da werden Informationen, die der Server gerne haben möchte, werden

01:20:35.610 --> 01:20:36.310
dort reingeschrieben.

01:20:36.450 --> 01:20:39.710
Vielleicht wird es auch direkt auf der HTTP-Seite schon formuliert,

01:20:39.730 --> 01:20:40.950
was dort alles drinstehen soll.

01:20:41.410 --> 01:20:45.750
Man kann also in der HTML-Seite Anweisungen einbetten, die ein Cookie

01:20:45.750 --> 01:20:46.450
erzeugen.

01:20:47.250 --> 01:20:53.930
Und dann wird beim Liefern der HTML-Seite, wird diese Cookie

01:20:53.930 --> 01:20:58.410
-Information mitgeliefert und lokal vom Browser abgespeichert in einem

01:20:58.410 --> 01:20:59.970
dafür vorgesehenen Verzeichnis.

01:20:59.970 --> 01:21:07.730
Also, bei jedem Aufruf werden die zu der entsprechenden URI, die dort

01:21:07.730 --> 01:21:09.850
drinsteht im Aufruf, gehörigen Cookies mitgeschickt.

01:21:09.990 --> 01:21:12.730
Dann weiß der Server, was dort an früheren Informationen schon mal

01:21:12.730 --> 01:21:13.850
abgelegt wurde.

01:21:14.890 --> 01:21:20.910
Und bei der Antwort auf einen HTTP-Zugriff wird der aktuelle Cookie

01:21:20.910 --> 01:21:27.890
dann als erstes übertragen und dann kommen die entsprechenden weiteren

01:21:27.890 --> 01:21:29.030
HTML -Informationen.

01:21:29.030 --> 01:21:33.050
Und auf diese Art und Weise habe ich die Möglichkeit, Daten auf dem

01:21:33.050 --> 01:21:36.630
Rechner des Anwenders zu speichern, darüber, was er schon mal gemacht

01:21:36.630 --> 01:21:39.850
hat, auf dieser gleichen Seite, auf die er jetzt nochmal zugreift.

01:21:40.330 --> 01:21:44.730
Und dann kann der Server, da er diese Information bekommt, auf diese

01:21:44.730 --> 01:21:47.230
Information entsprechend reagieren.

01:21:47.330 --> 01:21:52.250
Das heißt, wenn Sie sich melden bei irgendeinem Laden oder irgendeinem

01:21:52.250 --> 01:21:57.090
Webstore, dann kann der Sie sofort begrüßen mit Ihrem Namen, weil er

01:21:57.090 --> 01:22:01.270
das beim vorigen Mal vielleicht abgerufen hat oder sich gemerkt hat,

01:22:01.350 --> 01:22:02.510
im Cookie gespeichert hat.

01:22:02.910 --> 01:22:06.130
Sie haben dem die Information über das Cookie wieder mitgeteilt und

01:22:06.130 --> 01:22:10.190
dadurch kann der Sie direkt begrüßen, obwohl Sie explizit beim zweiten

01:22:10.190 --> 01:22:12.290
Aufruf Ihren Namen gar nicht mitgeteilt haben.

01:22:13.990 --> 01:22:18.690
Wenn Sie sich das anschauen im Netscape oder in Firefox oder Internet

01:22:18.690 --> 01:22:21.130
Explorer, da werden die Cookies ein bisschen unterschiedlich

01:22:21.130 --> 01:22:21.750
verwaltet.

01:22:22.710 --> 01:22:29.210
Bei Netscape in einer Datei namens Cookies.txt, dann haben Sie beim

01:22:29.210 --> 01:22:32.450
Internet Explorer, da werden die gewissen Verzeichnissen des Windows

01:22:32.450 --> 01:22:37.070
-Verzeichnisses abgelegt und entsprechend in Firefox macht das wieder

01:22:37.070 --> 01:22:37.290
anders.

01:22:37.510 --> 01:22:40.990
Sie können bei Firefox über ein Menü direkt auf die Cookies zugreifen

01:22:40.990 --> 01:22:47.450
und ich werde Ihnen nächstes Mal dieses Beispiel hier vorführen.

01:22:47.450 --> 01:22:48.850
Das macht heute keinen Sinn mehr.

01:22:49.210 --> 01:22:57.150
Vielleicht nur ganz kurz, wenn wir uns das jetzt anschauen.

01:22:57.370 --> 01:23:00.870
Wir haben hier irgendeinen Browser.

01:23:01.450 --> 01:23:05.910
Gehen wir hier auf Extras und in dem Fall auf Einstellungen.

01:23:06.070 --> 01:23:11.290
Dann müsste man eigentlich hier drin sehr schnell irgendwo die...

01:23:11.290 --> 01:23:12.350
Wo haben wir das denn?

01:23:13.890 --> 01:23:14.590
Inhalt.

01:23:14.970 --> 01:23:15.270
Danke.

01:23:16.770 --> 01:23:19.190
Da sollte jetzt irgendwo... ich glaube ich lasse es jetzt.

01:23:19.570 --> 01:23:21.950
Ich muss hier doch mal wieder gucken, weil ich mich ständig auf meine

01:23:21.950 --> 01:23:22.930
Cookies rausschaue.

01:23:24.430 --> 01:23:29.790
Es ist nicht unter... in dem Fall unter Inhalt.

01:23:30.430 --> 01:23:32.530
Wie ist denn das bei Sicherheit?

01:23:33.010 --> 01:23:34.110
Da ist es auch nicht drauf.

01:23:34.190 --> 01:23:37.470
Ich kann an irgendeiner Stelle bei Allgemein...

01:23:37.470 --> 01:23:38.690
Auch da finde ich es jetzt nicht.

01:23:38.970 --> 01:23:41.430
Aber an irgendeiner Stelle, nächstes Mal kann ich es Ihnen genau

01:23:41.430 --> 01:23:42.070
vorstellen.

01:23:42.650 --> 01:23:47.250
Da kann ich Ihnen sagen, an welcher Stelle tatsächlich die Cookies...

01:23:47.250 --> 01:23:48.550
Da steht etwas über Cookies.

01:23:48.990 --> 01:23:50.270
Hier möchte ich Cookies anzeigen.

01:23:50.750 --> 01:23:52.150
Hat was mit Sicherheit zu tun.

01:23:52.710 --> 01:23:56.350
Und hier können Sie also jetzt sehen, wo ich überall mal zugegriffen

01:23:56.350 --> 01:23:58.970
habe, das sind die ganzen Cookies, die hier noch nicht gespeichert

01:23:58.970 --> 01:23:59.210
sind.

01:23:59.370 --> 01:24:01.730
Ich mach es mal wieder zu, damit Sie nicht zu viel sehen, wo ich

01:24:01.730 --> 01:24:02.630
überall drauf zugreife.

01:24:04.650 --> 01:24:05.990
Aber das ist ja...

01:24:05.990 --> 01:24:09.070
Also es kann halt auf jedem Browser, können Sie halt auf die Art und

01:24:09.070 --> 01:24:13.530
Weise selbst kontrollieren, was ist über Ihre Aufrufe im Netz

01:24:13.530 --> 01:24:14.730
eigentlich gespeichert worden.

01:24:15.370 --> 01:24:21.010
Und wie gesagt, der Server, der einmal so etwas bei Ihnen abgelegt

01:24:21.010 --> 01:24:23.650
hat, bekommt diese Information wieder zurückgeliefert, wenn Sie das

01:24:23.650 --> 01:24:26.190
nächste Mal diese URL aufrufen.

01:24:26.910 --> 01:24:28.350
Ich denke, das reicht für heute.

01:24:28.870 --> 01:24:30.610
Wir sehen uns also erst am 28.

01:24:31.110 --> 01:24:32.250
wieder, in zwei Wochen.

01:24:32.770 --> 01:24:34.130
Und dann geht es mit Cookies weiter.

01:24:35.830 --> 01:24:38.490
Bis dahin, vielen Dank für die Aufmerksamkeit.

