Abschnitt 10 · Lektion 2
Eigene Middleware
Eine Middleware gibt der Anfrage etwas mit, eine Nummer oder eine Anfragekennung. Das nützt aber nur, wenn die Route danach diesen Wert auch findet. Middleware und Route sind zwei verschiedene Funktionen. Der erste Gedanke ist eine gemeinsame Variable daneben, und ausgerechnet die ist die falsche Ablage.
Prüfen oder ergänzen, dann weitergeben
import express from "express";
const app = express();
let zaehler = 0;
// Das Protokoll liegt in einer Liste statt in der Ausgabe des Servers,
// damit du es unter /protokoll nachlesen kannst.
const protokoll = [];
// Der Pfad steht beim Anmelden, nicht in der Funktion: diese Middleware gilt
// nur fuer Anfragen, die mit /api beginnen.
app.use("/api", (req, res, next) => {
zaehler += 1;
req.nummer = zaehler;
res.setHeader("X-Nummer", req.nummer);
protokoll.push(
`Nr. ${req.nummer} kommt an: req.url=${req.url} req.originalUrl=${req.originalUrl}`
);
res.on("finish", () => {
const groesse = res.getHeader("Content-Length");
protokoll.push(`Nr. ${req.nummer} ist fertig: ${res.statusCode}, ${groesse} Bytes`);
});
next();
});
app.get("/api/wetter", (req, res) => res.json({ nummer: req.nummer, wetter: "sonnig" }));
app.get("/hallo", (req, res) => res.json({ nummer: req.nummer ?? "ohne Nummer" }));
app.get("/protokoll", (req, res) => res.json(protokoll));
app.listen(3000); req.nummer = ... hängt einen Wert an die Anfrage. Ab dieser Zeile können ihn jede Middleware und
jede Route darunter lesen. Eine Nummer bekommt nur /api/wetter, denn die Middleware ist unter
/api angemeldet. /hallo läuft ohne. Deshalb steht dort req.nummer ?? "ohne Nummer", und
deshalb fehlt bei /hallo die Kopfzeile. Im Reiter Browser siehst du keine Kopfzeilen, im Terminal
mit den ersten beiden Befehlen der Befehlsleiste schon.
res.setHeader funktioniert hier, obwohl die Antwort noch gar nicht geschrieben ist. res sammelt
die Kopfzeilen und schickt sie erst mit, wenn die Antwort rausgeht. Solange noch nichts gesendet
wurde, darf man also welche setzen.
res.on("finish", ...) läuft, wenn die Antwort draußen ist. Dorthin gehört alles, was das Ergebnis
kennen muss, also Statuscode, Dauer und Größe. Für eine Kopfzeile ist es dann zu spät, die sind
längst unterwegs. Was in die Antwort soll, steht vor next(). Was über die Antwort geschrieben
wird, steht im finish.
Im Beispiel steht dort neben dem Statuscode die Größe des Rumpfs, gelesen mit
res.getHeader("Content-Length"). Vor next() gibt es diese Kopfzeile noch gar nicht. Sie entsteht
erst, wenn die Route mit res.json antwortet.
Warum der Pfad beim Anmelden abgeschnitten wird
Unter /protokoll steht in der ersten Zeile für req.url nur /wetter, für req.originalUrl
dagegen /api/wetter.
Das ist Absicht. Eine Middleware, die unter /api angemeldet ist, hat /api schon hinter sich. Für
ein Protokoll nehme ich deshalb req.originalUrl. Sonst stehen dort irgendwann Zeilen, in denen der
halbe Pfad fehlt.
Eine Variable daneben reicht nicht
Eine Variable außerhalb sieht einfacher aus, und sie funktioniert auch. Beim Ausprobieren.
import express from "express";
const app = express();
// Falsch: eine Variable ausserhalb, fuer alle Anfragen dieselbe.
let aktuellerName = "";
app.use("/aussen", (req, res, next) => {
aktuellerName = req.query.name;
next();
});
app.get("/aussen", async (req, res) => {
await new Promise((r) => setTimeout(r, Number(req.query.warten)));
res.json({ gruss: `Hallo ${aktuellerName}` });
});
// Richtig: an die Anfrage gehaengt, also fuer jede Anfrage ein eigener Wert.
app.use("/innen", (req, res, next) => {
req.name = req.query.name;
next();
});
app.get("/innen", async (req, res) => {
await new Promise((r) => setTimeout(r, Number(req.query.warten)));
res.json({ gruss: `Hallo ${req.name}` });
});
app.listen(3000); Im Reiter Browser steht der harmlose Fall. Eine Anfrage allein, und die Antwort stimmt. Zwei
gleichzeitig bekommst du in einem Browser-Tab nicht hin, im Terminal schon. Dort schickt das & den
ersten Aufruf in den Hintergrund, und sleep lässt ihn kurz anlaufen. Dann kommt der zweite
dazwischen.
Ada fragt zuerst, und ihre Antwort dauert länger. Grace kommt hundert Millisekunden später
dazwischen. Die Middleware überschreibt in der Zwischenzeit die Variable mit dem neuen Namen, und
als Adas Route nach ihrer langen Pause endlich antwortet, steht dort Graces Name. In beiden
Antworten steht Hallo Grace, direkt hintereinander in einer Zeile, weil keine von beiden mit einem
Zeilenumbruch endet. Mit /innen statt /aussen bekommt jede ihren eigenen Namen.
Ada bekommt eine Antwort, die für jemand anderen gedacht war. Bei einem Namen ist das peinlich. Bei einer Nutzerkennung oder einem Warenkorb ist es ein Sicherheitsvorfall.
Beim Entwickeln fällt davon nichts auf. Wenn du dich allein durch die Anwendung klickst, hast du immer nur eine Anfrage unterwegs, und alles stimmt. Der Fehler kommt erst, wenn mehrere Leute gleichzeitig da sind. Also dann, wenn man am wenigsten Lust darauf hat.
Alles, was zu einer einzelnen Anfrage gehört, kommt an req. Eine Variable außerhalb ist für Dinge
da, die alle bewusst teilen, etwa den Zähler im ersten Beispiel.
Middleware mit einer Einstellung
In Abschnitt 9 stand express.static mit Klammern da, der Standardfall dagegen als Funktion direkt.
Der Unterschied ist einfacher, als er aussieht.
import express from "express";
// Eine Funktion, die eine Middleware zurueckgibt. So sieht fast jedes
// Express-Paket aus, das man beim Anmelden mit Klammern aufruft.
function nurMitSchluessel(erwartet) {
return (req, res, next) => {
if (req.headers["x-schluessel"] !== erwartet) {
return res.status(401).json({ fehler: "Schlüssel fehlt oder stimmt nicht" });
}
next();
};
}
const app = express();
app.use("/intern", nurMitSchluessel("geheim"));
app.get("/", (req, res) => res.send("offen für alle"));
app.get("/intern/zahlen", (req, res) => res.json({ buecher: 10, ausgeliehen: 2 }));
app.listen(3000); nurMitSchluessel selbst ist eine Funktion, die eine Middleware zurückgibt. Beim Anmelden wird
sie aufgerufen. Sie merkt sich den erwarteten Schlüssel und liefert die eigentliche Funktion mit
drei Argumenten. So lässt sich dieselbe Middleware mehrfach mit verschiedenen Einstellungen
anmelden, und praktisch jedes Express-Paket ist so gebaut, auch express.static.
Die offene Seite unter / antwortet jedem. Tippst du /intern/zahlen in die Adresszeile, kommt ein
401, denn der Browser kennt den Schlüssel nicht. Mit dem Schlüssel in der Kopfzeile kommen die
Zahlen.
In der Zeile mit return res.status(401)... antwortet die Middleware und ruft next() nicht auf.
Das ist in Ordnung. Eine Middleware darf die Kette abbrechen, sie muss nur eines von beiden tun.
Beides geht nicht, und keines auch nicht.
Was in eine Middleware gehört und was nicht
Hinein gehört, was für viele Routen gleich ist. Das sind Protokoll, Zeitmessung, Anmeldung, Berechtigungen und das Lesen des Rumpfs.
Nicht hinein gehört die eigentliche Arbeit einer Route. Fängt eine Middleware an, Bücher zu suchen oder Preise zu rechnen, ist sie eine Route an der falschen Stelle. Eine Middleware lohnt sich erst, wenn dieselbe Arbeit bei jeder zweiten Route wieder anfiele.
In der Aufgabe schreibst du beides selbst, ein Protokoll für jede Anfrage und eine Kennung nur unter
/api.
Zum Mitnehmen
Eine eigene Middleware prüft oder ergänzt etwas und ruft dann next() auf. Was sie ergänzt, hängt sie an req. Eine Variable daneben teilen sich alle gleichzeitigen Anfragen, und das fällt erst auf, wenn mehrere da sind.
Jetzt du
Basis Konto, kostenlosZu dieser Lektion gehört eine Aufgabe. Du schreibst den Code selbst, und nach jedem Lauf sagt dir eine Prüfliste, was schon stimmt.
Dafür brauchst du das Basis Konto. Es kostet nichts, und ein Passwort gibt es auch nicht.
In diesem Kurs läuft dein Code auf einem Server. Dafür hat das Basis Konto 1 Stunde im Monat, mehr Zeit gibt es mit dem Premium Konto.
Was in dieser Lektion steckt
-
Artikel mit 3 Beispielen zum Ausprobieren
Steht hier, ohne Konto lesbar.
-
Aufgabe, dein Code läuft auf einem Server
Öffnet sich mit dem Basis Konto.