Um unterschiedliche Feedback zu verschiedenen Anfragen zu geben, stellen wir ein Event -Prozessor -Modul vor.
Das Modul heißt RequestHandlers. Wir fügen zunächst zwei Platzhalterfunktionen hinzu, start () und upload ().
Der Code für RequestHandlers.js lautet wie folgt:
Die Codekopie lautet wie folgt:
Funktion start () {
console.log ("Rufen Sie dies beim Zugriff /Stern an.");
}
Funktion upload () {
console.log ("Rufen Sie dies beim Zugriff auf/hochladen.");
}
exports.Start = start;
exports.Upload = Upload;
In realen Anwendungen erhöht sich die Anzahl der Anforderungshandler weiter. Natürlich möchten wir die Anfrage in der Route nicht jedes Mal abschließen, wenn eine neue URL oder eine neue Anfragehandler vorhanden ist.
Nachzuordnung wiederholt zum Handler.
Außerdem möchten wir nicht viel haben, wenn Request == x dann Handler Y in der Route rufen, wodurch der Code chaotisch und unprofessionell aussieht.
Hier werde ich das Konzept von assoziativen Arrays verwenden, um diese Anforderung zu erfüllen. Wir übergeben eine Reihe von Anforderungshandlern über ein Objekt und müssen dieses Objekt in locker gekoppelter Weise in die Route () -Funktion injizieren.
Lassen Sie uns dieses Objekt zunächst in den Hauptdatei index.js einführen:
Die Codekopie lautet wie folgt:
var Server = Request ("./ Server");
var router = required ("./router");
var RequestHandlers = Request ("./ RequestHandlers");
var Handle = {};
Handle ["/"] = RequestHandlers.Start;
Handle ["/start"] = RequestHandlers.Start;
Handle ["/Upload"] = RequestHandlers.Upload;
server.start (Router.Route, Handle);
Wenn ich beispielsweise A /Show -Karte hinzufügen möchte, fügen Sie einfach einen Handle [" /show"] RequestHandlers.show hinzu;
Haha, ist der Code viel prägnanter und geordneter? !
Als nächstes übergeben wir das Handlungsobjekt an den Server, und der Server.js wird wie folgt geändert:
Die Codekopie lautet wie folgt:
var http = required ("http");
var url = erfordern ("url");
Funktionsstart (Route, Handle) {
Funktion OnRequest (Anfrage, Antwort) {
var pathname = url.parse (request.url) .PathName;
console.log ("Anfrage für" + pathname + "empfangen.");
Route (Handle, Pfadname);
response.writeHead (200, {"Content-Type": "Text/Plain"});
Antwort.Write ("Hallo Welt");
Antwort.end ();
}
http.createServer (OnRequest) .Listen (8888);
console.log ("Server hat begonnen.");
}
exports.Start = start;
Ändern Sie die Funktion Route () in der Datei Route.js entsprechend:
Die Codekopie lautet wie folgt:
Funktionsstrecke (Handle, Pathname) {
console.log ("kurz davor, eine Anfrage nach" + pathname) zu leiten);
if (typeof handle [pathName] === 'Funktion') {
Handle [Pathname] ();
} anders {
console.log ("Kein Anfrage -Handler für" + pathname);
}
}
Exports.Route = Route;
Wir übergeben das Handle -Objekt als Parameter an den Server und empfangen es dann an der Route, und schließlich bestimmt die Route, ob der Anforderungshandler, der dem aktuellen Pfad entspricht, vorhanden ist oder nicht. Wenn es vorhanden ist, rufen Sie die entsprechende Funktion auf.
Wir können die Anforderungshandhabungsfunktion aus dem übergebenen Objekt genauso wie Elemente aus dem assoziativen Array abrufen. Daher haben wir einen einfachen und reibungslosen Ausdruck wie Handle [Pathname] ();, was sich wie die zuvor erwähnte anfühlt: "Hallo, bitte helfen Sie mir, mit diesem Pfad umzugehen."
Auf diese Weise können wir je nach Anfragen unterschiedliche Verarbeitung durchführen.
Im nächsten Abschnitt werden wir den Code weiter überarbeiten, damit der Server einige tatsächliche Rückmeldungsvorgänge durchführen kann.