Node.js

Middleware in Express verstehen

Middleware ist das Herz von Express. Hier lernst du, wie Middleware-Funktionen Anfragen verarbeiten, wie next funktioniert und wie du Fehler zentral behandelst.

Anton

— 2 Min. Lesezeit
Teilen
Middleware in Express verstehen

Wenn du schon ein paar Express-Apps gebaut hast, ist dir bestimmt das Wort Middleware begegnet. Middleware ist das eigentliche Herzstück von Express – und sobald du sie verstehst, schreibst du sauberere und mächtigere Server. In diesem Beitrag erkläre ich dir, was Middleware ist, wie sie funktioniert und wie du eigene schreibst.

Was ist Middleware?

Eine Middleware ist eine Funktion, die zwischen der eingehenden Anfrage und der endgültigen Antwort sitzt. Sie bekommt drei Argumente: req (die Anfrage), res (die Antwort) und next (eine Funktion, die zum nächsten Schritt weiterleitet). Stell dir Middleware wie eine Kette von Stationen vor, die jede Anfrage durchläuft.

function meineMiddleware(req, res, next) {
  console.log("Eine Anfrage ist angekommen");
  next();
}

Die Rolle von next

Der Aufruf von next() ist entscheidend. Er sagt Express: "Ich bin fertig, gib die Anfrage an die nächste Middleware oder Route weiter." Vergisst du next(), bleibt die Anfrage hängen und der Client bekommt nie eine Antwort:

app.use((req, res, next) => {
  console.log(`${req.method} ${req.url}`);
  next(); // ohne dies würde alles steckenbleiben
});

Mit app.use registrierst du eine Middleware, die für alle Anfragen gilt.

Eingebaute Middleware

Express bringt nützliche Middleware mit. Die bekannteste hast du vielleicht schon genutzt: express.json() liest den JSON-Body einer Anfrage. Auch das Ausliefern statischer Dateien ist Middleware:

app.use(express.json());
app.use(express.static("public"));

Die zweite Zeile sorgt dafür, dass Dateien aus dem Ordner public automatisch ausgeliefert werden – etwa Bilder oder HTML-Seiten.

Eigene Middleware schreiben

Du kannst Middleware für ganz eigene Zwecke bauen. Ein typisches Beispiel ist ein Logger, der jede Anfrage mit Zeitstempel protokolliert:

function logger(req, res, next) {
  const zeit = new Date().toISOString();
  console.log(`[${zeit}] ${req.method} ${req.url}`);
  next();
}

app.use(logger);

Ein weiteres Beispiel ist eine einfache Prüfung, ob ein bestimmter Header gesetzt ist – etwa für eine simple Authentifizierung:

function pruefeToken(req, res, next) {
  if (req.headers["x-api-key"] !== "geheim") {
    return res.status(401).json({ fehler: "Nicht erlaubt" });
  }
  next();
}

Hier bricht die Middleware die Kette ab, falls der Schlüssel fehlt, und sendet einen 401-Fehler. Nur mit gültigem Schlüssel geht es über next() weiter.

Middleware gezielt einsetzen

Du musst Middleware nicht immer global einsetzen. Du kannst sie auch einzelnen Routen voranstellen. So gilt die Prüfung nur für geschützte Bereiche:

app.get("/admin", pruefeToken, (req, res) => {
  res.send("Willkommen im Admin-Bereich");
});

Die Route führt pruefeToken zuerst aus. Nur wenn die Middleware next() aufruft, wird der eigentliche Handler erreicht.

Fehler-Middleware

Eine Sonderform ist die Fehler-Middleware. Sie erkennst du an vier Argumenten, beginnend mit err. Express ruft sie auf, wenn irgendwo ein Fehler auftritt:

app.use((err, req, res, next) => {
  console.error(err.message);
  res.status(500).json({ fehler: "Interner Serverfehler" });
});

Diese Middleware registrierst du als letzte. So fängst du Fehler zentral ab, statt sie in jeder Route einzeln zu behandeln.

Fazit

Middleware ist das Prinzip, das Express so flexibel macht. Jede Funktion bekommt req, res und next und entscheidet, ob sie weitergibt oder die Kette abbricht. Du nutzt eingebaute Middleware wie express.json(), schreibst eigene Logger oder Prüfungen und fängst Fehler mit einer speziellen Fehler-Middleware ab. Mit diesem Wissen baust du strukturierte, wartbare Backends. Damit hast du die wichtigsten Grundlagen der Server-Entwicklung mit Node und Express in der Hand – ein super Ausgangspunkt für deine nächsten Projekte.

Weiterlesen