Detaillierte Erklärung der Funktionsweise der Node.js-Middleware

Was ist Express-Middleware?

• Unter Middleware versteht man buchstäblich alles, was Sie zwischen einer Softwareschicht und einer anderen platzieren.
• Express-Middleware sind Funktionen, die während des Lebenszyklus einer Anfrage an einen Express-Server ausgeführt werden.
• Jede Middleware hat Zugriff auf die HTTP-Anfragen und -Antworten aller Routen, an die sie angeschlossen ist.
• Darüber hinaus kann die Middleware die HTTP-Anforderung beenden oder sie mit „next“ an eine andere Middleware-Funktion weiterleiten. Durch diese „Verkettung“ der Middleware können Sie Ihren Code unterteilen und wiederverwendbare Middleware erstellen.

Voraussetzungen zum Schreiben von Express-Middleware

Sie müssen einige Dinge installieren, um Express-Middleware zu erstellen, zu verwenden und zu testen. Zuerst benötigen Sie Node und npm. Um sicherzustellen, dass es installiert ist, führen Sie Folgendes aus:

npm -v und Knoten -v

Sie sollten die installierten Versionen von Node und NPM sehen. Wenn eine Fehlermeldung angezeigt wird, müssen Sie Node installieren. Alle Beispiele sollten mit Node Version 8+ und NPM Version 5+ verwendet werden.

Dieser Artikel verwendet Express Version 4.x. Dies ist wichtig, da es von Version 3.x zu Version 4.x zu wesentlichen Änderungen kommt.

Express-Middleware: Die Grundlagen

Zuerst verwenden wir die grundlegendste integrierte Middleware von Express. Erstellen Sie ein neues Projekt und initialisieren Sie es mit npm ...

npm init
npm install express --save

Erstellen Sie server.js und fügen Sie den folgenden Code ein:

const express = erfordern('express');
const app = express();

app.get('/', (req, res, next) => {
  res.send('Willkommen zu Hause');
});

app.listen(3000);

Welche Probleme löst Middleware? Warum es verwenden?

Angenommen, Sie führen eine Webanwendung mit Node.js und Express auf einem Webserver aus. In dieser App müssen Sie sich auf einigen Seiten anmelden.

Wenn ein Webserver eine Datenanforderung empfängt, stellt Express Ihnen ein Anforderungsobjekt bereit, das Informationen über den Benutzer und die von ihm angeforderten Daten enthält. Express gibt Ihnen auch Zugriff auf das Antwortobjekt, das Sie ändern können, bevor der Webserver dem Benutzer antwortet. Diese Objekte werden oft zu „req, res“ abgekürzt.

Middleware-Funktionen sind der ideale Ort, um die Req- und Res-Objekte mit relevanten Informationen zu ändern. Wenn sich ein Benutzer beispielsweise anmeldet, können Sie seine Benutzerdetails aus der Datenbank abrufen und diese Details dann in res.user speichern.

Wie sehen Middleware-Funktionen aus?

asynchrone Funktion userMiddleware (req, res, next) {
    versuchen {
        const userData = await getUserData(req.params.id); //siehe app.get unten

        if(Benutzerdaten) {
                req.user = Benutzerdaten;
                nächste();
        }
    } fange(Fehler) {
        res.status(500).send(error.message); //durch entsprechende Fehlerbehandlung ersetzen
    }
}

Wenn ein Fehler auftritt und Sie nicht möchten, dass anderer Code ausgeführt wird, rufen Sie die Funktion nicht auf. Denken Sie in diesem Fall daran, eine Antwort zu senden, da der Client sonst bis zur Zeitüberschreitung auf die Antwort wartet.

var app = express();

//Ihre normalen Routenhandler
app.get('/user/:id', Benutzer-Middleware, Benutzer-Controller);

Middleware-Kette

Sie können Middleware in Ihrem Middleware-Array verketten oder mehrere app.use-Aufrufe verwenden:

app.use(middlewareA);
app.use(middlewareB);
app.get('/', [middlewareC, middlewareD], handler);

Wenn Express eine Anforderung empfängt, wird jede Middleware, die der Anforderung entspricht, in der Reihenfolge ausgeführt, in der sie initialisiert wurde, bis eine Beendigungsaktion erfolgt.

Wenn also ein Fehler auftritt, werden der Reihe nach alle Middlewares zur Fehlerbehandlung aufgerufen, bis eine davon den Funktionsaufruf next() nicht mehr ausführt.

Arten von Express-Middleware

• Middleware auf Router-Ebene, wie etwa router.use
• Integrierte Middleware, wie zum Beispiel: express.static, express.json, express.urlencoded
• Middleware zur Fehlerbehandlung, zum Beispiel: app.use(err, req, res, next)
• Middleware von Drittanbietern, z. B. Bodyparser, Cookieparser
• Middleware auf Routerebene
• express.Router Verwenden Sie die Klasse express.Router, um modulare, installierbare Routing-Handler zu erstellen. Eine Routerinstanz ist ein vollständiges Middleware- und Routingsystem. Sie können Middleware für Protokollierung, Authentifizierung usw. verwenden. Um die letzte Aktivität des Benutzers aufzuzeichnen und den Authentifizierungsheader zu analysieren, verwenden Sie ihn, um wie unten gezeigt den aktuell angemeldeten Benutzer zu ermitteln und ihn dem Anforderungsobjekt hinzuzufügen. Diese Funktion wird jedes Mal ausgeführt, wenn das Programm eine Anfrage empfängt. Wenn ein Fehler auftritt, wird die Antwort einfach beendet, ohne die nachfolgende Middleware oder Routenverarbeitung aufzurufen.

var router = express.Router()
Laden Sie Middleware auf Routerebene mithilfe der Funktionen router.use() und router.METHOD().
Das folgende Beispiel erstellt einen Router als Modul, lädt eine Middleware-Funktion darin, definiert einige Routen und mountet das Router-Modul auf einem Pfad in der Haupt-App.
var express = erforderlich('express');
var router = express.Router();

// eine Middleware-Funktion ohne Mount-Pfad. Dieser Code wird bei jeder Anfrage an den Router ausgeführt
// Protokollierung
asynchrone Funktion logMiddleware (req, res, next) {
    versuchen {
         console.log(req.user.id, neues Datum());
     nächste();
    } fangen() {
        res.status(500).senden(Fehlernachricht);
    }
}
// Authentifizierung
    asynchrone Funktion checkAuthentication(req, res, next) => {
// Header- oder URL-Parameter oder Post-Parameter auf Token prüfen
const token = req.body.token || req.query.token || req.headers['x-access-token'] || req.headers['authorization'];
      wenn (Token) {
        versuchen {
            // überprüft das Geheimnis
            req.decoded = warte auf jwt.verify(Token, config.secret)

            let checkUser = warte auf authenticateTokenHelper.getUserDetail(req);

            // wenn alles in Ordnung ist, in der Anfrage speichern, um sie in anderen Routen zu verwenden
                if (prüfeBenutzer) {
                        req.user = req.dekodiert
                        nächste()
                } anders {
                    return res.status(403).json({ 
                    Nachricht: responseMessage.noAuthorized 
                    })
                }
        } fangen (Fehler) {
            return res.status(401).json({ Nachricht: responseMessage.invalidToken })
        }
  } anders {
    // wenn kein Token vorhanden ist
    return res.status(400).json({ Nachricht: Antwortnachricht.ungültigeAnforderung })
  }
}
router.use(logMiddleware);
    router.get('/Benutzer, checkAuthentication, Handler);

Integrierte Middleware

Express verfügt über die folgenden integrierten Middleware-Funktionen:

• express.static stellt statische Ressourcen wie HTML-Dateien, Bilder usw. bereit.
• Die express.json-Nutzlast analysiert die eingehende Anforderung mit JSON.
• express.urlencoded analysiert eingehende Anfragen mit URL-codierten Nutzdaten.

Fehlerbehandlungs-Middleware

Die Middleware zur Fehlerbehandlung benötigt immer vier Argumente (err, req, res, next). Sie müssen es durch die Angabe von vier Argumenten als Middleware-Funktion zur Fehlerbehandlung identifizieren. Auch wenn Sie das nächste Objekt nicht benötigen, müssen Sie es angeben. Andernfalls wird das nächste Objekt als normale Middleware interpretiert und kann keine Fehler verarbeiten. Die grundlegende Signatur lautet wie folgt:

app.use(Funktion (err, req, res, next) {
  Konsole.Fehler(Fehler.Stapel)
  res.status(500).send('Etwas ist kaputt!')
})

Beispiel 1:

app.get('/Benutzer', (req, res, next) => {
  next(new Error('Ich übergebe Ihnen einen Fehler!'));
});
app.use((err, req, res, next) => {
  console.log(fehler);    
  wenn(!res.headersSent){
    res.status(500).senden(Fehlernachricht);
  }
});

In diesem Fall behandelt die Fehlerbehandlungs-Middleware am Ende der Pipeline den Fehler. Möglicherweise bemerken Sie auch, dass ich die Eigenschaft res.headersSent überprüft habe. Dadurch wird lediglich überprüft, ob die Header der Antwort bereits an den Client gesendet wurden. Wenn nicht, sendet es einen HTTP 500-Status und eine Fehlermeldung an den Client.

Beispiel 2:

Sie können auch Middleware zur Fehlerbehandlung verketten. Verschiedene Fehlertypen werden normalerweise unterschiedlich behandelt:

app.get('/Benutzer, (req, res, next) => {
  let err = new Error('Ich konnte es nicht finden.');
  Fehler.httpStatusCode = 404;
  nächster(Fehler);
});

app.get('/Benutzer, (req, res, next) => {
  let err = new Error('Es tut mir leid, das kannst du nicht machen, Dave.');
  Fehler.httpStatusCode = 304;
  nächster(Fehler);
});

app.use((err, req, res, next) => {
   // behandelt „Nicht gefunden“-Fehler
  wenn (err.httpStatusCode === 404) {
    res.status(400).render('Nicht gefunden');
  }
   // behandelt nicht autorisierte Fehler 
  sonst wenn(err.httpStatusCode === 304){
    res.status(304).render('Nicht autorisiert');
  }
    // alles abfangen
   sonst wenn (!res.headersSent) {
     res.status(err.httpStatusCode || 500).render('UnbekannterFehler');
  }
  nächster(Fehler);
});

• In diesem Fall prüft die Middleware, ob ein 404-Fehler (nicht gefunden) ausgegeben wurde. Wenn dies der Fall ist, wird die Vorlagenseite „NotFound“ gerendert und der Fehler wird dann an das nächste Element in der Middleware weitergegeben.
• Die nächste Middleware prüft, ob ein 304-Fehler (nicht autorisiert) aufgetreten ist. Wenn dies der Fall ist, wird die Seite „Nicht autorisiert“ gerendert und der Fehler an die nächste Middleware in der Pipeline weitergegeben.
• Schließlich protokolliert die „Catch-All“-Fehlerbehandlung einfach den Fehler, und wenn keine Antwort gesendet wird, sendet sie den falschen httpStatusCode (oder den HTTP 500-Status, wenn keiner angegeben ist) und rendert die Vorlage „UnknownError“.

Middleware von Drittanbietern

In einigen Fällen fügen wir dem Backend einige zusätzliche Funktionen hinzu. Installieren Sie das Node.js-Modul, um die erforderliche Funktionalität zu erhalten, und laden Sie es dann auf Anwendungsebene oder Routerebene in Ihre Anwendung.

Beispiel: Wenn der Body-Parser den Content-Type-Anforderungsheader verarbeitet, füllen alle Middlewares die Eigenschaft „req.body“ mit dem analysierten Body.

const express = erfordern('express');
const bodyParser = erfordern('body-parser');
const app = express();
app.use(bodyParser.urlencoded({extended:false}))
app.verwenden(bodyParser.json())
app.post('/speichern',(req,res)=>{
    res.json({
        "Status":wahr,
         "Nutzlast":anf.body
    })
}
app.listen(3000,(erf.,res)=>{
    console.log('Server läuft auf Port')
})

Zusammenfassen

Middleware-Funktionen bieten eine hervorragende Möglichkeit, bei jeder Anfrage oder bei jeder Anfrage für eine bestimmte Route Code auszuführen und auf Grundlage der Anfrage- oder Antwortdaten Maßnahmen zu ergreifen. Middleware ist ein wichtiger Bestandteil moderner Webserver und sehr nützlich.

Oben finden Sie eine ausführliche Erklärung zur Funktionsweise der Node.js-Middleware. Weitere Informationen zur Node.js-Middleware finden Sie in den anderen verwandten Artikeln auf 123WORDPRESS.COM!