Middleware verwenden

Express ist ein Weiterleitungs- und Middleware-Web-Framework, das selbst nur minimale Funktionalität aufweist: Eine Express-Anwendung besteht im Wesentlichen aus einer Reihe von Middlewarefunktionsaufrufen.

Middlewarefunktionen sind Funktionen, die Zugriff auf das Anforderungsobjekt (req), das Antwortobjekt (res) und die nächste Middlewarefunktion im Anforderung/Antwort-Zyklus der Anwendung haben. Die nächste Middlewarefunktion wird im Allgemeinen durch die Variable next bezeichnet.

Über Middlewarefunktionen lassen sich die folgenden Tasks ausführen:

• Ausführen von Code
• Vornehmen von Änderungen an der Anforderung und an Antwortobjekten
• Beenden des Anforderung/Antwort-Zyklus
• Aufrufen der nächsten Middlewarefunktion im Stack

Wenn über die aktuelle Middlewarefunktion der Anforderung/Antwort-Zyklus nicht beendet werden kann, muss next() aufgerufen werden, um die Steuerung an die nächste Middlewarefunktion zu übergeben. Andernfalls geht die Anforderung in den Status “Blockiert” über.

Eine Express-Anwendung kann die folgenden Middlewaretypen verwenden:

• Middleware auf Anwendungsebene
• Middleware auf Routerebene
• Middleware für die Fehlerbehandlung
• Integrierte Middleware
• Middleware anderer Anbieter

Sie können Middleware auf Anwendungsebene und Routerebene mit einem optionalen Mountpfad laden. Sie können auch eine Reihe von Middlewarefunktionen zusammen laden. Dadurch wird ein Sub-Stack des Middlewaresystems am Mountpunkt erstellt.

Middleware auf Anwendungsebene

Binden Sie Middleware auf Anwendungsebene zu einer Instanz des Anwendungsobjekts, indem Sie die Funktionen app.use() und app.METHOD() verwenden. METHOD ist dabei die HTTP-Methode der Anforderung, die die Middlewarefunktion in Kleinschreibung verarbeitet (wie GET, PUT oder POST).

Dieses Beispiel zeigt eine Middlewarefunktion ohne Mountpfad. Die Funktion wird immer dann ausgeführt, wenn die Anwendung eine Anforderung erhält.

var app = express();

app.use(function (req, res, next) {
  console.log('Time:', Date.now());
  next();
});

Dieses Beispiel zeigt eine Middlewarefunktion mit dem Mountpfad /user/:id. Die Funktion wird für jede Art von HTTP-Anforderung auf dem Pfad /user/:id ausgeführt.

app.use('/user/:id', function (req, res, next) {
  console.log('Request Type:', req.method);
  next();
});

Dieses Beispiel zeigt eine Weiterleitung und deren Handlerfunktion (Middlewaresystem). Die Funktion verarbeitet GET-Anforderungen zum Pfad /user/:id.

app.get('/user/:id', function (req, res, next) {
  res.send('USER');
});

Dies ist ein Beispiel zum Laden einer Reihe von Middlewarefunktionen an einem Mountpunkt mit einem Mountpfad. Das Beispiel veranschaulicht einen Middleware-Stack, über den Anforderungsinformationen zu einer HTTP-Anforderung zum Pfad /user/:id ausgegeben werden.

app.use('/user/:id', function(req, res, next) {
  console.log('Request URL:', req.originalUrl);
  next();
}, function (req, res, next) {
  console.log('Request Type:', req.method);
  next();
});

Mit einem Routenhandler können Sie mehrere Weiterleitungen für einen Pfad definieren. Im folgenden Beispiel werden zwei Weiterleitungen für GET-Anforderungen zum Pfad /user/:id definiert. Die zweite Weiterleitung verursacht zwar keine Probleme, wird jedoch nie aufgerufen, da durch die erste Weiterleitung der Anforderung/Antwort-Zyklus beendet wird.

Dieses Beispiel zeigt einen Middleware-Sub-Stack, über den GET-Anforderungen zum Pfad /user/:id verarbeitet werden.

app.get('/user/:id', function (req, res, next) {
  console.log('ID:', req.params.id);
  next();
}, function (req, res, next) {
  res.send('User Info');
});

// handler for the /user/:id path, which prints the user ID
app.get('/user/:id', function (req, res, next) {
  res.end(req.params.id);
});

Wenn Sie den Rest der Middlewarefunktionen eines Weiterleitungs-Middleware-Stack überspringen wollen, rufen Sie next('route') auf, um die Steuerung an die nächste Weiterleitung zu übergeben. HINWEIS: next('route') funktioniert nur in Middlewarefunktionen, die über die Funktionen app.METHOD() oder router.METHOD() geladen wurden.

Dieses Beispiel zeigt einen Middleware-Sub-Stack, über den GET-Anforderungen zum Pfad /user/:id verarbeitet werden.

app.get('/user/:id', function (req, res, next) {
  // if the user ID is 0, skip to the next route
  if (req.params.id == 0) next('route');
  // otherwise pass the control to the next middleware function in this stack
  else next(); //
}, function (req, res, next) {
  // render a regular page
  res.render('regular');
});

// handler for the /user/:id path, which renders a special page
app.get('/user/:id', function (req, res, next) {
  res.render('special');
});

Middleware auf Routerebene

Middleware auf Routerebene funktioniert in der gleichen Weise wie Middleware auf Anwendungsebene, mit dem einzigen Unterschied, dass sie an eine Instanz von express.Router() gebunden ist.

var router = express.Router();

Laden Sie Middleware auf Routerebene über die Funktionen router.use() und router.METHOD(). Der folgende Beispielcode repliziert das Middlewaresystem, das oben für die Middleware auf Anwendungsebene gezeigt wird, durch Verwendung von Middleware auf Routerebene.

var app = express();
var router = express.Router();

// a middleware function with no mount path. This code is executed for every request to the router
router.use(function (req, res, next) {
  console.log('Time:', Date.now());
  next();
});

// a middleware sub-stack shows request info for any type of HTTP request to the /user/:id path
router.use('/user/:id', function(req, res, next) {
  console.log('Request URL:', req.originalUrl);
  next();
}, function (req, res, next) {
  console.log('Request Type:', req.method);
  next();
});

// a middleware sub-stack that handles GET requests to the /user/:id path
router.get('/user/:id', function (req, res, next) {
  // if the user ID is 0, skip to the next router
  if (req.params.id == 0) next('route');
  // otherwise pass control to the next middleware function in this stack
  else next(); //
}, function (req, res, next) {
  // render a regular page
  res.render('regular');
});

// handler for the /user/:id path, which renders a special page
router.get('/user/:id', function (req, res, next) {
  console.log(req.params.id);
  res.render('special');
});

// mount the router on the app
app.use('/', router);

Middleware für die Fehlerbehandlung

Middlewarefunktionen für die Fehlerbehandlung werden in derselben Weise definiert wie andere Middlewarefunktionen, außer dass Fehlerbehandlungsfunktionen speziell bei Signaturen vier anstatt drei Argumente aufweisen (err, req, res, next):

app.use(function(err, req, res, next) {
  console.error(err.stack);
  res.status(500).send('Something broke!');
});

Details zu Middleware für die Fehlerbehandlung siehe Fehlerbehandlung.

Integrierte Middleware

Seit Version 4.x bestehen bei Express keine Abhängigkeiten zu Connect mehr. Mit Ausnahme von express.static befinden sich nun alle Middlewarefunktionen, die bisher in Express enthalten waren, in separaten Modulen. Sehen Sie sich hierzu auch die Liste der Middlewarefunktionen an.

express.static(root, [options])

Die einzige integrierte Middlewarefunktion in Express ist express.static. Diese Funktion basiert auf serve-static und ist zuständig für die statischen Assets einer Express-Anwendung.

Das Argument root gibt das Stammverzeichnis an, von dem aus statische Assets bedient werden.

Das optionale Objekt options kann folgende Eigenschaften aufweisen:

Dies ist ein Beispiel zur Verwendung der Middlewarefunktion express.static mit einem ausführlich dargestellten Optionsobjekt:

var options = {
  dotfiles: 'ignore',
  etag: false,
  extensions: ['htm', 'html'],
  index: false,
  maxAge: '1d',
  redirect: false,
  setHeaders: function (res, path, stat) {
    res.set('x-timestamp', Date.now());
  }
}

app.use(express.static('public', options));

Es sind mehrere statische Verzeichnisse pro Anwendung möglich:

app.use(express.static('public'));
app.use(express.static('uploads'));
app.use(express.static('files'));

Details zur Funktion serve-static und deren Optionen finden Sie in der Dokumentation zu serve-static.

Middleware anderer Anbieter

Mit Middleware anderer Anbieter können Sie Express-Anwendungen um neue Funktionalität erweitern.

Installieren Sie das Modul Node.js für die erforderliche Funktionalität. Laden Sie das Modul dann in Ihre Anwendung auf Anwendungsebene oder auf Routerebene.

Das folgende Beispiel veranschaulicht das Installieren und Laden der Middlewarefunktion cookie-parser für das Cookie-Parsing.

$ npm install cookie-parser

var express = require('express');
var app = express();
var cookieParser = require('cookie-parser');

// load the cookie-parsing middleware
app.use(cookieParser());

Eine nicht vollständige Liste zu den Middlewarefunktionen anderer Anbieter, die im Allgemeinen mit Express verwendet werden, finden Sie unter Middleware anderer Anbieter.