Ich hoffe, jeder kann weiterhin meine Artikelreihe lesen. Dies ist auch die größte Ermutigung und Unterstützung für mich. Lassen Sie uns gemeinsam Fortschritte machen, durch Literatur Freunde finden und sich gegenseitig helfen. OK, gehen wir direkt zum heutigen Thema.
Was ist "Connect" und wie kann man Middleware verstehen? Schauen wir uns den heutigen Artikel mit Fragen an.
Wie verstehe man "Middleware"?
Mein Verständnis ist, dass Middleware einem Filter etwas ähnelt, eine Möglichkeit, Anforderungen und Antworten zwischen dem Client und der Anwendung zu bearbeiten.
Wenn ein HTTP -Verarbeitungsprozess mit der Abwasserbehandlung verglichen wird, ist die Middleware wie Filterschichten. Jede Middleware schreibt die Anforderung oder (und) Antwortdaten während der HTTP -Verarbeitung um.
Zustand, implementiert spezifische Funktionen.
Was ist "Connect"?
Wir können uns als Sammlung einer Häufigkeit von Middleware vorstellen. Für jede Anforderung verwendet Connect die Middleware -Ebene, um die Anforderung zu filtern, von denen jedes die HTTP -Anforderung abrufen kann.
TJ Holowaychuk sagte über Connect, dass es zwei Arten von Middleware gibt. Einer von ihnen ist ein Filter:
Filter behandeln Anfragen, reagieren jedoch nicht auf Anfragen (denken Sie an Serverprotokolle).
Der zweite Typ ist ein Anbieter, der auf die Anfrage reagiert. Sie können mehrere Middleware entsprechend Ihren Anforderungen verwenden. Die HTTP -Anfrage beantwortet die Anfrage über jede Middleware bis zu einer der Middleware.
2. Einführung in die integrierte Middleware von Connect
Im Folgenden finden Sie mehrere Hauptmitte und Beispiele: Beispiele werden beschrieben:
.
Die Codekopie lautet wie folgt:
var Connect = Request ('./ lib/connect');
var app = connect ()
.use (connect.cookieParser ('Secret String'))
.use (Funktion (req, res, next) {
req.cookies.website = "Hallo, ich bin Bigbear!" ;
res.end (json.stringify (req.cookies));
}). Hören (8888);
(2), Sitzung
Beschreibung: Sitzungsverwaltung Middleware
Abhängigkeit: Cookieper
Parameter: Optionen
Optionen:
Schlüssel: Cookies Name, Standardwert ist Connect.sid
Speicher: Sitzungspeicherinstanz
Geheimnis: Session Cookie -Verschlüsselung
Cookie: Session Cookie -Konfiguration, Standardwert ist {Pfad: '/', httponly: true, maxage: null}
Proxy: Ein Reverse-Proxy für sichere Cookies, der über X-Forwarded-Proto implementiert wird
Cookie -Option:
cookie.maxage: Der Standardwert ist null, was darauf hinweist, dass das Cookie beim Schließen des Browsers gelöscht wird.
Die Codekopie lautet wie folgt:
var Connect = Request ('./ lib/connect');
var app = connect ()
.use (connect.logger ('dev'))
.use (connect.cookieParser ())
.Use (Connect.Session ({Secret: '123', Cookie: {Maxage: 60000}}))
.use (Funktion (req, res, next) {
if (req.session.pv) {
res.setheader ('Inhaltstyp', 'text/html');
Res.Write ('Ansichten:' + req.session.pv);
res.end ();
req.Session.pv ++;
}anders{
req.Session.pv = 1;
res.end ('aktualisieren');
}
})
.Listen (8888);
Wenn der Client die Seite "PV" kontinuierlich aktualisiert und die Anzahl der Wartung auf der Serverseite "Sitzung" weiter zunimmt.
(3), Bodyparser ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Die Codekopie lautet wie folgt:
var connect = require ('connect');
var app = connect ()
.use (connect.bodyparser ())
.use (Funktion (req, res) {
res.end ('req.body =>' + json.stringify (req.body));
})
.Listen (8888);
Drittens nehmen wir ein Vergleichsbeispiel und sehen Sie die Vorteile der Verwendung von Middleware an.
Die Codekopie lautet wie folgt:
/*
* Statische Dateiverarbeitung mithilfe von Connect implementiert
*/
var connect = require ('connect');
Connect (Connect.static (__ DirName + '/Public')).listen(//Listen
8888,
function () {
console.log ('Connect in Port 8888');
}
);
/*
* Implementierung mit nativem Knoten -API
*/
var http = required ('http');
http.createserver (
Funktion (req, res) {
var url = erfordern ('url');
var fs = fordert ('fs');
var pathname = __dirname + '/public' + url.parse (req.url) .PathName;
// Lokale Dateien lesen
fs.readfile (
Pfadname,
Funktion (err, data) {
// Ausnahmebehandlung
if (err) {
Res.WriteHead (500);
res.end ('500');
}
anders {
res.end (Daten);
}
}
);
}
) .Listen (// Hören
8888,
function () {
console.log ('HTTP -Server mit Port 8888');
}
);
Obwohl die native API von Knoten bereits so viele Codezeilen ausgegeben hat, hinterlässt sie immer noch viele Aspekte eines einfachen statischen Dateiservers, der nicht verarbeitet wurde.
Zum Beispiel: 404 und andere Ausnahmen werden nicht verarbeitet. Es gibt keine grundlegende Überprüfung der Sicherheitsverifizierung von Dateien (tatsächlich können wir auf das gesamte OS -Dateisystem zugreifen), globaler Ausnahmebehandlung usw.
Gleichzeitig hat Connect bereits all diese Probleme behandelt.
Vier, lasst uns zusammenfassen
(1) Verarbeitung von Middleware Streaming.
Die Codekopie lautet wie folgt:
var app = connect ();
app.use (connect.staticcache ());
app.use (Connect.static (__ DirName + '/public'));
app.use (connect.cookieParser ());
app.use (Connect.Session ());
app.use (Connect.Query ());
app.use (connect.bodyparser ());
app.use (connect.csrf ());
app.use (function (req, res, next) {
// Middleware
});
App.Listen (8888);
(2) Differenzierung zwischen nativen Implementierungsmethoden und Middleware -Implementierungen.
(3) In den oben genannten Beispielen für Middleware können wir die Verwendungs- und Nutzungsszenarien verstehen und auf relevante Dokumente verweisen, um die grundlegende Verwendung anderer Middleware zu beherrschen.