Bisher hat der von uns erstellte Server keine praktische Verwendung, sodass wir einige praktische und nützliche Funktionen implementieren.
Was wir tun müssen, ist: Der Benutzer wählt eine Datei aus, lädt die Datei hoch und sieht dann die hochgeladene Datei im Browser.
Zuerst benötigen wir einen Textbereich, damit der Benutzer den Inhalt eingeben und ihn dann über eine Postanforderung an den Server senden kann.
Wir fügen dem Start -Event -Handler Code hinzu und ändern wie folgt RequestHandlers.js:
Die Codekopie lautet wie folgt:
Funktion start (Antwort) {
console.log ("Anfragenhandler" Start "wurde genannt.");
var body = '<html>'+ '<kopf>'+
'<meta http-äquiv = "content-type" content = "text/html;'+
'charSet = utf-8 " />'+
'</head>'+
'<body>'+
'<form action = "/Upload" method = "post">'+
'<textArea name = "text" rows = "20" cols = "60"> </textArea>'+
'<input type = "value =" text " />'+ reichen
'</form>'+
'</body>'+
'</html>';
Antwort.WriteHead (200, {"Content-Type": "text/html"});
Antwort.Write (Körper);
Antwort.end ();
}
Funktion hochladen (Antwort) {
console.log ("Anfrage -Handler" Upload "wurde genannt.");
response.writeHead (200, {"Content-Type": "Text/Plain"});
Antwort.Write ("Hallo Upload");
Antwort.end ();
}
exports.Start = start;
exports.Upload = Upload;
Sie können den Effekt sehen, indem Sie http: // localhost: 8888/starten in Ihrem Browser.
Als nächstes möchten wir die Auslösen des /Upload -Anforderungshandlers implementieren, um die Postanforderung zu verarbeiten, wenn der Benutzer das Formular einreicht.
Um den gesamten Prozess nicht blockieren zu lassen, teilen Node.js die Postdaten in viele kleine Datenblöcke auf und übergeben diese kleinen Datenblöcke dann an die Rückruffunktion, indem Sie bestimmte Ereignisse auslösen. Die spezifischen Ereignisse hier enthalten ein Datenereignis (was darauf hinweist, dass ein neuer kleiner Datenblock eingetroffen ist) und ein Endereignis (was darauf hinweist, dass alle Daten empfangen wurden).
Wir tun dies, indem wir einen Hörer im Anforderungsobjekt registrieren. Das Anforderungsobjekt hier wird jedes Mal, wenn eine HTTP -Anforderung empfangen wird, an die Funktion "OnRequest" übergeben.
Wir setzen den Code auf den Server und ändern server.js wie folgt:
Die Codekopie lautet wie folgt:
var http = required ("http");
var url = erfordern ("url");
Funktionsstart (Route, Handle) {
Funktion OnRequest (Anfrage, Antwort) {
var postdata = "";
var pathname = url.parse (request.url) .PathName;
console.log ("Anfrage für" + pathname + "empfangen.");
request.seteCoding ("utf8");
request.addListener ("data", function (postdatachunk) {
Postdata += Postdatachunk;
console.log ("empfangene Postdaten -Chunk" + Postdatachunk + "'.");
});
Request.AddListener ("End", function () {
Route (Handle, Pfadname, Antwort, Postdata);
});
}
http.createServer (OnRequest) .Listen (8888);
console.log ("Server hat begonnen.");
}
exports.Start = start;
Der obige Code erledigt drei Dinge: Zuerst setzen wir das Codierungsformat der empfangenen Daten auf UTF-8 und registrieren dann den Listener für das "Daten" -Ereignis, um jedes Mal neue Datenblöcke zu sammeln und der Postdata-Variablen zuzuweisen. Schließlich verschieben wir den Anruf, der die Route zum End -Event -Handler anfordert, um sicherzustellen, dass er nur dann abfeuert, wenn alle Daten empfangen werden und nur einmal abfeuern. Wir übergeben auch Postdaten, um Routen anzufordern, da diese Daten vom Anforderungshandler verwendet werden.
Anschließend Zeigen Sie auf der Seite /Upload die Benutzereingabe an
Wechseln wir Router.js:
Die Codekopie lautet wie folgt:
Funktionsstrecke (Handle, Pfadname, Antwort, Postdata) {
console.log ("kurz davor, eine Anfrage nach" + pathname) zu leiten);
if (typeof handle [pathName] === 'Funktion') {
Handle [Pathname] (Antwort, Postdata);
} anders {
console.log ("Kein Anfrage -Handler für" + pathname);
Antwort.WriteHead (404, {"Inhaltstyp": "text/plain"});
Antwort.Write ("404 nicht gefunden");
Antwort.end ();
}
}
Exports.Route = Route;
In RequestHandlers.js geben wir dann die Daten in die Antwort auf die Upload -Anfrage ein:
Die Codekopie lautet wie folgt:
Funktionsstart (Antwort, Postdata) {
console.log ("Anfragenhandler" Start "wurde genannt.");
var body = '<html>'+
'<kopf>'+
'<meta http-äquiv = "content-type" content = "text/html;'+
'charSet = utf-8 " />'+
'</head>'+
'<body>'+
'<form action = "/Upload" method = "post">'+
'<textArea name = "text" rows = "20" cols = "60"> </textArea>'+
'<input type = "value =" text " />'+ reichen
'</form>'+
'</body>'+
'</html>';
Antwort.WriteHead (200, {"Content-Type": "text/html"});
Antwort.Write (Körper);
Antwort.end ();
}
Funktion hochladen (Antwort, Postdata) {
console.log ("Anfrage -Handler" Upload "wurde genannt.");
response.writeHead (200, {"Content-Type": "Text/Plain"});
Antwort.Write ("Sie haben gesendet:" + Postdata);
Antwort.end ();
}
exports.Start = start;
exports.Upload = Upload;
Das Letzte, was wir tun müssen, ist: Derzeit übergeben wir den gesamten Meldungsgremium der Anfrage an das Anforderungsrouting und den Anforderungshandler. Wir sollten nur die Postdaten, den Teil, an dem wir interessiert sind, an das Anforderungsrouting und die Anforderungshandler übergeben. In unserem Beispiel ist das Textfeld.
Wir können das zuvor eingeführte QueryString -Modul verwenden, um es zu implementieren:
Die Codekopie lautet wie folgt:
var queryString = required ("queryString");
Funktionsstart (Antwort, Postdata) {
console.log ("Anfragenhandler" Start "wurde genannt.");
var body = '<html>'+
'<kopf>'+
'<meta http-äquiv = "content-type" content = "text/html;'+
'charSet = utf-8 " />'+
'</head>'+
'<body>'+
'<form action = "/Upload" method = "post">'+
'<textArea name = "text" rows = "20" cols = "60"> </textArea>'+
'<input type = "value =" text " />'+ reichen
'</form>'+
'</body>'+
'</html>';
Antwort.WriteHead (200, {"Content-Type": "text/html"});
Antwort.Write (Körper);
Antwort.end ();
}
Funktion hochladen (Antwort, Postdata) {
console.log ("Anfrage -Handler" Upload "wurde genannt.");
response.writeHead (200, {"Content-Type": "Text/Plain"});
Antwort.Write ("Sie haben den Text gesendet:"+ queryString.parse (Postdata) .Text);
Antwort.end ();
}
exports.Start = start;
exports.Upload = Upload;
OK, es geht in der oben genannten Verarbeitung von Postdaten.
Im nächsten Abschnitt werden wir die Funktion des Hochladens von Bildern implementieren.