[MUSIC]
In dieser Übung werden wir einige der Code-Knoten-Module untersuchen.
Insbesondere werden wir uns das HTTP-Modul ansehen, das in Node integriert ist und
das HTTP-Modul verwenden, um einen einfachen Webserver zu konfigurieren und zu starten.
Wir werden auch untersuchen, wie wir statische Dateien von unserem Knoten HTTP-Server bereitstellen können.
Wir werden auch dieses Dateisystemmodul und das Pfadmodul betrachten und
wie sie uns helfen können, statische Dateien in unserem node-basierten HTTP-Server bereitzustellen.
Lassen Sie uns also einige der Code-Knoten-Module in dieser Übung untersuchen.
Um mit dieser Übung zu beginnen, wechseln Sie zu einem geeigneten Speicherort auf Ihrem Computer.
Also werden wir zu dem NodeJS-Ordner gehen, den wir bereits in einer
der vorherigen Übungen erstellt haben.
Und im NodeJS-Ordner werde ich einen neuen Ordner namens node-http erstellen.
Und dann werden wir dies als Knotenanwendung einrichten.
Auch in den Node-http-Ordner zu bewegen,
lassen Sie uns einen Unterordner dort mit dem Namen public erstellen,
der einige der HTML-Dateien fortsetzen wird, die wir von unserer Node HTTP-Anwendung Server werden.
Wechseln Sie nun zu einem Terminal, navigieren Sie zum Knoten,
-http Ordner.
Und lassen Sie uns diesen Ordner initialisieren, um in unserer Anwendung zu sein.
Also beginnen wir mit npm init und
initialisieren dieses Paket in unsere JSON-Datei hier.
Und dann geben wir den Paketnamen als node-http und
akzeptieren Sie die Standardversion, und
die Beschreibung ist Knoten HTTP-Modul Beispiel.
Und der Ausgangspunkt ist index.js, kein Testbefehl,
kein Git-Repository für den Moment, und Autor,
geben Sie Ihren Namen ein und akzeptieren Sie den Rest wie es ist.
Und das sollte das Paket für eine JSON-Manifestdatei erstellen.
Nun lassen Sie uns dieses Projekt in unserem Lieblings-Editor öffnen.
Lassen Sie mich also meinen Visual Studio-Code in diesem Ordner starten.
Und im Visual Studio-Code gehen wir zum Paket in unsere JSON-Datei.
Und dann werden wir in einem anderen Skript zum Paket hinzufügen,
zu unserer JSON-Datei namens start und
die Knoten Index ausführen würde.
Und denken Sie daran, nach dem Test ein Komma zu setzen.
Und speichern Sie die Änderungen in der Datei package.json.
Erstellen Sie nun in Project eine neue Datei namens index.js.
Wir werden diese index.js konfigurieren, um den Knoten HTTP-Modul zu verwenden.
Also geben wir in dieser Datei const
http = require („http“) ein.
So können Sie sehen, dass wir das HTTP-Code-Modul verwenden, und
wir benötigen es, indem Sie einfach den Namen des HTTP-Codemoduls dort angeben.
Darüber hinaus, Lassen Sie uns erklären,
Ein paar Konstanten hier und dann,
Wir rufen Hostname und
die Portnummer als 3000 standardmäßig.
Nun lassen Sie uns den Server einrichten.
Um den Server einzurichten, sagen wir const server = http.
Das HTTP-Modul unterstützt eine Methode namens CreateServer,
so dass sie die CreateServer-Methode verwenden.
Diese CreateServer-Methode wird eine Funktion als Parameter nehmen und
diese Funktion nimmt zwei
Werte als Parameter, Anfrage und Antwort.
Und wie Sie sehen können, schreibe ich hier eine Pfeilfunktion.
Die Anfrage und Antwort sind also die beiden Parameter für die Funktion, die wir
hier als Parameter für die CreateServer-Methode liefern.
Und darin werden wir
console.log (req.headers) sagen.
Hier sind die req und res die eingehende HTTP-Anforderung an den Server.
Und sie spawning Response-Objekt, das
von diesem Server konstruiert und an den Client zurückgegeben wird
, der mit diesem HTTP-Server verbindet, den wir hier erstellen.
Die Anfrage ist also die eingehende Anfrage von jedem Browser oder
von überall, der versucht, auf diesen Server zuzugreifen, den wir
mit dieser HTTP-Knoten-Anwendung starten, die wir hier entwickeln.
Aus der Anfrage
gibt uns das Anforderungsobjekt Zugriff auf die Header in der eingehenden HTTP-Anfrage.
Also werde ich die eingehenden
Header der HTTP-Anfrage protokollieren, die mit dieser console.log eingeht.
Nur zu meiner Information, nur um zu wissen, woher diese Anfrage kommt.
Danach können wir die Antwort konstruieren, indem wir die res verwenden und
dies wird uns eine Methode namens StatusCode zur Verfügung stellen.
Der StatusCode ermöglicht es uns, den StatusCode für die Antwortnachricht einzurichten.
In diesem Fall werde ich den StatusCode als 200 einrichten.
Wenn Sie sich aus der früheren Diskussion über Netzwerk-Essentials erinnern,
werden Sie wissen, dass StatusCode von 200 bedeutet, dass alles in Ordnung ist.
Und so richten wir hier den Statuscode für die Antwortnachricht ein und
dann werden wir auch den Header für die Antwortnachricht einrichten.
Und eine der Kopfbefürchtungen, die wir
einrichten werden, heißt Content-Type.
Und der Content-Type,
wir werden dies angeben, um 'text/html' zu sein.
Der Antwortkörper enthält also hier die Daten in Form von HTML.
Der Header ist also eingerichtet, um den Client zu informieren, dass Sie
die Antwort senden und der Text im HTML-Format formatiert ist.
Und dann schließlich sagen wir res.end ('').
Dies beendet also die Antwort hier, und wenn dies geschehen ist,
werden diese Informationen an den Client zurückgesendet.
Also hier, lassen Sie mich einfach eine Inline-HTML-Seite hier erstellen,
also werde ich sagen <Hallo,
Welt! .
Und schließen Sie das h1-Tag, das body-Tag
und das html-Tag, genau dort.
Und das ist eine gültige HTML-Antwort, die
von unserem Server hier zurückgeschickt werden kann.
Also dieser Server, wie Sie erwarten, einfach gehen eine Hallo Welt an den Client senden.
Nun, da wir den Server eingerichtet haben, müssen wir diesen Server starten.
Um diesen Server in Notiz zu starten,
müssen wir sagen server.listen.
Und dies startet den Listening-Port, auf dem der Server auf
eingehende Anfragen wartet.
Und das würde an der Portnummer gestartet werden,
die meinen Port gegeben hat, den wir bereits hier im const Port eingerichtet haben.
Und der zweite Parameter ist der Hostname, den wir bereits früher eingerichtet haben.
Und der dritte Parameter ist eine Funktion, die
ausgeführt wird, wenn der Server startet.
In dieser Funktion drucken wir nur die Informationen über den Server aus.
Also hier drin werde ich nur console.log sagen.
Und in der console.log
werde ich die Informationen ausdrucken, damit ich ein Back-Zitat verwenden werde.
Beachten Sie also die Verwendung von Back-Zitat nicht das normale Zitat.
Der Grund, warum wir das verwenden, ist, weil wir
einige Variablen innerhalb der Zeichenfolge verwenden werden, die wir hier konstruieren werden.
Also sagen wir Server läuft unter http://.
Und dann werden wir $ und
dann Hostname sagen.
Daran erinnern, dass dieser Hostname, Sie bereits zuvor deklariert haben.
Und dann der zweite Teil,
werden wir sagen: $ und Port.
Diese beiden Werte werden also durch die entsprechenden Werte ersetzt.
Und da wir dies in hinteren Anführungszeichen einschließen.
Und wenn Sie etwas in Dollar-Erhöhungen einschließen,
wird das hier durch seinen Wert in dieser Zeichenfolge ersetzt.
Das war's.
Wir haben einen einfachen HTTP-Server und läuft.
Also lassen Sie uns die Änderungen daran speichern.
Und wir gehen und starten unsere Anwendung und sehen, was sie dient.
Gehen wir zum Terminal, geben wir npm start ein, und
dies sollte unsere Anwendung starten.
Und wir bemerken, dass es unser Sprichwort ausdruckt, dass Server läuft
auf http://localhost:3000.
Jetzt können Sie auf diese URL zugreifen, indem Sie sie in die Adressleiste eines beliebigen Browsers eingeben.
Lassen Sie mich also ein Chrome-Browserfenster starten und geben Sie dies ein und
sehen Sie, was der Server zurückgeben wird.
Starten eines neuen Fensters.
Lassen Sie mich einfach http://
localhost: 3000 eingeben.
Und das sollte eine Hello World zurückgeben, wie wir es erwarten.
Wenn wir nun zur Konsole gehen, sehen Sie, dass auf der Konsole
Details der eingehenden Anfragen Header hier ausgedruckt werden.
Einige Dinge sind hier sehr einfach zu finden.
Das ist also host, localhost: 3000, und Sie sehen auch, dass der „user-Agent“
hier auf „Chrome“ gesetzt ist, die Chrome-Version, die ich hier verwende.
Das ist also eine interessante Illustration der HTTP-Anforderungsnachricht.
Und was in der Kopfzeile der Anforderungsnachricht enthalten ist, die hier hereinkam.
So interessant zu beobachten, was Ihr Server
hier auf den Bildschirm ausdruckt.
Damit schließen wir die erste Hälfte dieser Übung ab.
Jetzt können wir diese Anwendung in ein Git-Repository initialisieren
und dann die Änderungen im Git-Repository speichern.
Also gehen wir weiter und machen das als nächstes.
Geben Sie an der Eingabeaufforderung init ab, und das hat das Repository initialisiert.
Und dann sagen wir git status und Sie sehen, dass diese beiden Dateien neu sind.
Also sagen wir git add.
Und git commit
-m „Knoten HTTP Example 1".
Und dann überprüfe das in unser Git-Repository.
Jetzt noch ein weiteres Tool, das sehr nützlich ist
, wenn wir auf serverseitige Anwendungen suchen, heißt Postman.
Jetzt Postman kommt in Form von entweder einer Chrome-Browsererweiterung oder
einem eigenständigen Tool, das Sie herunterladen und auf Ihrem Computer installieren können.
Also, um das zu tun, lassen Sie uns in unserem Browser http eingeben.
getpostman.com.
Und dann können Sie hier das
Postman-Tool für Ihr spezifisches Betriebssystem erhalten und es installieren. Mit
dem Postman-Tool können Sie HTTP-Anfragen erstellen und dann senden.
Und es gibt Ihnen auch die Flexibilität, die Header für
Ihre HTTP-Anfrage einzurichten, bevor Sie sie einsenden.
Und wenn die Antwort zurückkommt, können Sie die Antwort
einschließlich der Header der Antwort untersuchen, die von der Serverseite zurückkommt.
Also finde ich Postman sehr nützlich.
Es gibt ein paar andere Werkzeuge wie diese,
aber Postman scheint derzeit der beste auf dem Markt zu sein.
Also werde ich Postman durch den Rest dieses Kurses nutzen.
Wenn Sie es nicht installieren möchten,
können Sie auch die Chrome-Browser-Erweiterung von Postman installieren und dann verwenden.
Ich werde die macOS-Version von Postman herunterladen und
sie dann auf meinem Computer installieren und dann nutzen.
Sobald Sie den Postman, entweder die Standalone-Version oder
die Chrome-Browser-Erweiterung installiert haben, können Sie es starten.
Und Sie werden sehen, dass die Benutzeroberfläche
sowohl für die Standardversion als auch für die Chrome-Browsererweiterung mehr oder weniger gleich ist.
Und sobald Sie den Postboten ausgeführt haben,
geben Sie in das Feld Request URL
localhost: 3000 ein.
Und senden Sie die Anfrage an sich.
Stellen Sie sicher, dass Ihr Knoten HTTP-Server betriebsbereit ist.
Wenn Sie also die Anfrage senden,
würden Sie sofort eine Antwort vom Server mit dem HTML-Code hier erhalten.
Nun ist der Vorteil, wie Sie sehen,
bei der Verwendung von Postman, dass Sie den eigentlichen Text der Nachricht sehen können.
Sie können sich auch die Header ansehen, um zu sehen, was vom Server zurückgesendet wurde.
Sie können auch viele Details in Postman einrichten, wenn Sie senden.
Anfrage vom Server.
Jetzt sind viele von ihnen möglicherweise nicht sehr einfach mit einem Standard-Browserfenster zu tun.
Das ist der Grund, warum ich es vorziehe, [INAUDIBLE] zu verwenden, um
die HTTP-Anfragen an meinen Server zu generieren.
Und dann beobachten Sie die Antwort, die von der Serverseite zurückkommt.
Beachten Sie auch, dass hier der Statuscode und einige andere Informationen über
die Anfrage und die Antwortzeit von der Serverseite angezeigt werden.
Nun, da wir seinen einfachen Knoten basierten HTTP-Server erstellt haben,
lassen Sie uns es weiter erweitern, lassen Sie uns ein paar HTML-Dateien im Öffentlichen Ordner erstellen.
Wir werden es als index.html nennen.
Und dann auch aboutus.html,
und dann fügen Sie einfach einige nackte Knochen Informationen in hier.
Also sagen wir html, und
Titel wie Dies ist index.html.
Und dann geben wir den Text der HTML-Seite ein.
Sagen Sie h1 Index.html
und den Körper und dann ist dies
der Inhalt dieser Datei.
Einige grundlegende HTML-Code hier, lassen Sie mich dies kopieren und
dann auch in die aboutus.html Seite einfügen.
Und der Inhalt der Datei aboutus.html, das war's.
Wir haben gerade zwei HTML-Seiten erstellt, und
dies sind statische HTML-Seiten, die wir im Öffentlichen Ordner erstellt haben.
Können wir nun unseren Knoten HTTP-Server einrichten, um statische Seiten bereitstellen zu können?
Das ist also, was wir im zweiten Teil dieser Übung konfigurieren werden.
Also gehe ich zurück zur Datei index.js,
zusätzlich zum HTTP-Code-Modul,
werde ich auch das Dateisystem-Code-Modul importieren.
Und das Pfadcode-Modul. Mit
dem Pfad können Sie den Teil einer Datei in Ihrem lokalen Dateisystem angeben. Mit
dem Dateisystemmodul können Sie
Dateien aus Ihrem lokalen Dateisystem lesen und schreiben.
Damit werden sie also konstanter Server, http.CreateServer sagen.
Für das Konsolenprotokoll, anstatt ganze Anforderungsheader
einzugeben, werde ich einfach nur ausreichende Informationen eingeben, also
werde ich sagen, Anfrage für,
Nur die URL dieser Anfrage.
Nach Methode.
Die Methode wäre also entweder Port-Post oder Delete-Methoden.
Dies wird also diese Informationen protokollieren.
Nun, was wir tun werden, ist, anstatt
diese Antwort zu senden, die Standard-Hallo Welt-Antwort.
Hier werden wir die Methode untersuchen und
dann werden wir sagen, ob req.method gleich GET ist.
So werden wir nur GET-Anfragen in diesem Beispiel bedienen.
Andernfalls werden wir sagen, dass es ein Wenn gibt.
Also, wenn es eine GET-Anfrage gibt, die in kommt
, dann werden wir untersuchen,
die URL, die in kommt,
also sagen wir, wenn req.url/ist,
sagen wir FileURL gleich html.
Wenn Sie also keinen bestimmten Dateinamen erhalten, aber
Sie senden nur eine Anfrage an den lokalen Hostcode 3000.
Es wird standardmäßig auf die index.html gesetzt,
sonst wird FileURL gleich req.url.
Auf diese Weise haben Sie konstruiert, welche Datei Server ist.
Jetzt werden wir sagen, Wir werden den Pfad der Datei finden,
wir sagen Pfad, Resolve,
also unterstützt das Pfadmodul diese Auflösungsmethode, also wird
dies in die vollwertige Pfadordnerdatei übersetzen,
die Datei, die wir gerade erstellt haben,
die FileURL, die wir gerade erstellt haben.
Dies wird uns also den vollständigen Pfad für die Datei geben, und
dann sagen wir konstante FileExtension.
Also, wenn Sie sicherstellen möchten, dass
die Dateinamenerweiterung HTML ist.
Aus dem FilePath
werden wir die Dateinamenerweiterung untersuchen und
dann sagen wir, ob FileExt ==.
Wenn es sich also um eine HTML-Datei handelt, dann wissen wir, wie man es aus dieser speziellen
Beziehung des Knotens HTTP-Server bedient.
Also werden wir sagen, wenn die Dateierweiterung HTML ist, dann wissen wir, dass
die Datei eine HTML-Datei ist und wir haben die beiden Dateien, Index und aboutus.html.
Also werden wir überprüfen, ob diese Datei existiert, also
sagen wir, ob Datei existiert, FilePath.
Die Methode existiert also, um zu sehen, ob die Datei existiert,
also sagen wir fs.exists (FilePath),
und dieser wird
als zweiter Parameter eine Rückruffunktion nehmen.
Beachten Sie also die Verwendung der ersten Rückruffunktion in unserem Beispiel.
So wird diese Callback-Funktion aufgerufen, wobei dieser Parameter dort vorhanden ist.
In diesem Callback-Parameter wird dies entweder wahr oder falsch sein.
Dies ist also der Rückgabeparameter für diese Callback-Funktion.
Also hier, Wir werden überprüfen, und
wir werden sagen, ob (! existiert),
was bedeutet, dass die Datei nicht existiert,
dann sagen wir res.StatusCode = 404. Denken Sie
daran, dass, wenn die Datei nicht existiert, Sie einen Statuscode von 404 senden, der besagt, dass
Sie die Datei nicht finden können.
Und dann sagen wir res.setHeader,
und wir setzen den Header auf 'Content-Type',
'text/html'.
Und dann müssen wir die HTML-Datei hier oder den HTML-Code senden.
Also werde ich den grundlegenden HTML-Code, html body h1 tun.
Fehler 404,
wir sagen, + FileURL +
'nicht gefunden'.
Und schließen Sie, Die HTML-Seite.
Hier, wie Sie bemerken, verwenden Sie die Funktion existiert
des Dateisystemmoduls, um zu überprüfen, ob die Datei existiert.
Sie geben also den Dateipfad als ersten Parameter an, und
der zweite ist die Callback-Funktion.
Wenn in dieser Callback-Funktion angegeben wird, dass das existiert falsch ist,
senden Sie die Standardfehlermeldung 404 zurück, die besagt, dass Sie die Datei nicht finden können.
Und nachdem wir dies tun, werden wir einfach,
zurückkehren, sonst,
Wir sagen res.StatusCode
= 200, res.setHeader,
('Content-Type', 'text/html').
Jetzt müssen wir die Datei einlesen und dann die Datei aussenden.
Hier
werden wir also aus dem Dateisystemmodul den CreateReadStream verwenden
, der den FilePath als Parameter verwendet.
Diese CreateReadStream-Methode wird also die Datei aus diesem FilePath einlesen.
Und dann konvertieren Sie das in Byte-Stream,
und dann werden sie dies an die Antwort übergeben.
Das wird also in die Antwort aufgenommen, im Körper der Antwort.
Auf diese Weise haben wir gerade die Datei genommen und
sie dann in die Antwort hier aufgebaut.
Und das war's, die Akte ist bereit, verschickt zu werden, okay?
Wenn also die Dateierweiterung html ist,
überprüfen wir, um sicherzustellen, dass Sie dies richtig behandeln.
Hier werden Sie die Datei einlesen und sie dann versenden.
Wenn die Dateierweiterung nicht html ist, müssen wir natürlich eine Fehlermeldung senden.
Also genau dort werden wir sehen, wir werden diesen
speziellen Code von hier kopieren.
Und dann kleben Sie es dort hinein.
Wir sagen, sonst StatusCode = 404, Context text/html,
und die Fehlermeldung sagt, Fehler 404, FileURL.
Es wurde nicht gefunden, aber
es ist keine HTML-Datei.
Das ist also der Fehler, den wir in diesem Fall zurücksenden werden.
Und schließlich, für den letzten anderen Fall,
also hier sagen wir die Methode.
Das entspricht also der Anforderungsmethode.
Also, wenn die Anforderungsmethode nicht GET ist, sondern eine andere Anforderungsmethode,
dann werden wir das in dieser Version unserer Node-Anwendung nicht behandeln.
Also senden wir zurück StatusCode 404,
Inhalt html, und wir sagen Fehler 404.
Und wir werden sagen,, req Methode,
Nicht, Unterstützt,
nicht von diesem Knoten HTML-Server hier unterstützt, das ist es.
Mit diesen Änderungen sind wir nun bereit, unseren Browser neu zu starten.
Und dann lassen Sie es die HTML-Dateien hier servieren.
Also lassen Sie uns die Änderungen speichern, und dann gehen und starten Sie unseren Server neu, und
dann untersuchen, was er sendet, wenn wir verschiedene Anfragen an den Server senden.
Gehen Sie zum Terminal, wenn Ihr Server läuft,
stoppen Sie ihn, indem Sie Strg+C eingeben, und starten Sie den Server neu.
Und wenn der Server betriebsbereit ist, senden wir einige Anfragen an ihn.
Zuerst von einem Browser und danach von Postman.
Gehen Sie in Ihr Browserfenster, geben Sie localhost:3000 ein und
sehen Sie, dass dies die Datei index.html zurückgibt, wie wir erwarten.
Und dann sagen wir localhost: 3000/index.html,
und dies wird auch die Datei index.html zurückgeben.
Nun, wenn wir aboutus.html senden, heißt es Aboutus.html, und es gibt es richtig zurück.
Lassen Sie uns jetzt eine Anfrage für aboutus.txt senden und sehen, was es tut.
Also sagt es /aboutus.txt ist keine HTML-Datei.
Dann lassen Sie uns eine Anfrage an test.html senden.
Und wir wissen, dass test.html nicht existiert, also heißt es /test.html nicht gefunden.
Wir sehen also, dass wir durch die Verwendung des Browsers
die vorhandenen Dateien abrufen können und der Server die Dateien an den Browser senden kann.
Lassen Sie uns nun zu Postman gehen und versuchen, die gleichen Anfragen zu generieren,
und sehen Sie die Antwort vom Server.
Als nächstes gehen wir zu Postman, lassen Sie uns eine GET-Anfrage an localhost senden: 3000/.
Und Sie sehen, dass dies die Datei index.html zurückgibt.
Lassen Sie uns eine Anfrage an aboutus.html senden.
Und dann sehen Sie, dass es die Datei aboutus.html zurückgibt.
Und dann senden wir eine Anfrage an die Textdatei,
und dann steht Fehler 404, keine HTML-Datei.
Und Sie werden sehen, dass der Status hier sagt, 404 nicht gefunden.
Und dann werden wir, anstatt eine GET-Anfrage zu senden,
sehen, dass dies der Vorteil der Verwendung von Postman ist, ich werde eine PUT-Anfrage senden.
Und Sie werden feststellen, dass dies sagt, Fehler: PUT nicht unterstützt, und
so mit dem Status 404 hier, und so weiter.
So können Sie einen Knoten HTTP-Server konfigurieren,
um Dateien, HTTP-Dateien in diesem speziellen Fall bereitstellen zu können.
Jetzt können Sie sich leicht vorstellen,
diesen HTTP-Server auf viele verschiedene Arten von Dateien zu erweitern und so weiter.
Aber natürlich
wird der Code entsprechend auch komplizierter als das, was wir in diesem Moment haben.
Damit schließen wir diese Übung ab.
In dieser Übung haben wir gesehen, wie wir einen einfachen
knotenbasierten HTTP-Server einrichten können, der Dateien von unserer Server-Site bereitstellt.
( MUSIK)