suchen

Heim >Web-Frontend >js-Tutorial >So funktioniert die Node.js-Middleware

So funktioniert die Node.js-Middleware

青灯夜游
青灯夜游nach vorne
2020-09-30 18:01:562885Durchsuche

So funktioniert die Node.js-Middleware

Video-Tutorial-Empfehlung: Node-JS-Tutorial

Was ist Express-Middleware?

  • Middleware bedeutet wörtlich alles, was Sie zwischen einer Softwareschicht und einer anderen platzieren.
  • Express-Middleware ist eine Funktion, die während des Lebenszyklus einer Anfrage an den Express-Server ausgeführt wird.
  • Jede Middleware hat Zugriff auf HTTP-Anfragen und -Antworten für alle Routen, an die sie angeschlossen ist.
  • Darüber hinaus kann die Middleware die HTTP-Anfrage beenden oder sie mit next an eine andere Middleware-Funktion übergeben. Diese „Kette“ von Middleware ermöglicht es Ihnen, Ihren Code zu partitionieren und wiederverwendbare Middleware zu erstellen.

Anforderungen 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 && node -v

Sie sollten die installierten Node- und NPM-Versionen sehen. Wenn Sie eine Fehlermeldung erhalten, müssen Sie Node installieren. Alle Beispiele sollten unter Node Version 8+ und NPM Version 5+ verwendet werden.

Dieser Artikel verwendet Express-Version 4.x. Dies ist wichtig, da es erhebliche Änderungen von Version 3.x zu Version 4.x gab.

Express-Middleware: 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

Create server.js and paste the following code:

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

app.get('/', (req, res, next) => {
  res.send('Welcome Home');
});

app.listen(3000);

Welches Problem 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 für einige Seiten anmelden.

Wenn der Webserver eine Datenanfrage empfängt, stellt Ihnen Express ein Anfrageobjekt zur Verfügung, das Informationen über den Benutzer und die von ihm angeforderten Daten enthält. Express bietet Ihnen außerdem Zugriff auf Antwortobjekte, die geändert werden können, bevor der Webserver dem Benutzer antwortet. Diese Objekte werden oft zu req, res abgekürzt.

Middleware-Funktionen sind ein idealer Ort, um req- und res-Objekte mit relevanten Informationen zu ändern. Nachdem sich beispielsweise ein Benutzer angemeldet hat, können Sie seine Benutzerdetails aus der Datenbank abrufen und diese Details dann in res.user speichern. res.user 中。

中间件函数是什么样的？

async function userMiddleware (req, res, next) {
    try {
        const userData = await getUserData(req.params.id);  //see app.get below

        if(userData) {
                req.user = userData;
                next();
        }
    } catch(error)  {
        res.status(500).send(error.message); //replace with proper error handling
    }
}

如果出现错误，并且你不想执行其他代码，则不要调用该函数。请记住在这种情况下要发送响应，否则客户端将会等待响应直到超时。

var app = express();

//your normal route Handlers
app.get('/user/:id', userMiddleware, userController);

中间件链

你可以在中间件数组中或着通过使用多个 app.use 调用来链接中间件：

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

Express 收到请求后，与请求相匹配的每个中间件都将会按照初始化的顺序运行，直到有终止操作为止。

So funktioniert die Node.js-Middleware

因此，如果发生错误，则将按顺序调用所有用于处理错误的中间件，直到其中一个不再调用 next() 函数调用为止。

Express中间件的类型

  • 路由器级中间件，例如：router.use
  • 内置中间件，例如：express.static，express.json，express.urlencoded
  • 错误处理中间件，例如：app.use（err，req，res，next）
  • 第三方中间件，例如：bodyparser、cookieparser
  • 路由器级中间件

  • express.Router 使用 express.Router 类创建模块化的、可安装的路由处理。路由实例是一个完整的中间件和路由系统。

    • 你可以用中间件进行日志记录、身份验证等操作。如下所示，以记录用户的最新活动并解析身份验证标头，用它确定当前登录的用户并将其添加到 Request 对象。
    • 该函数在程序每次收到请求时执行。如果有错误，它会仅结束响应，而不会调用后续的中间件或路由处理。
var router = express.Router()
//Load router-level middleware by using the router.use() and router.METHOD() functions.
//The following example creates a router as a module, loads a middleware function in it,
//   defines some routes, and mounts the router module on a path in the main app.
var express = require(‘express’);
var router = express.Router();

// a middleware function with no mount path. This code is executed for
//   every request to the router
// logging
async function logMiddleware (req, res, next) {
    try {
         console.log(req.user.id, new Date());
     next();
    } catch() {
        res.status(500).send(error.message);
    }
}
// authentication
    async function checkAuthentication(req, res, next) => {
// check header or url parameters or post parameters for token
const token = req.body.token || req.query.token || req.headers['x-access-token']
 || req.headers['authorization'];
      if (token) {
        try {
            // verifies secret
            req.decoded = await jwt.verify(token, config.secret)

            let checkUser = await authenticateTokenHelper.getUserDetail(req);

            // if everything is good, save to request for use in other routes
                if (checkUser) {
                        req.user = req.decoded
                        next()
                } else {
                    return res.status(403).json({ 
                    message: responseMessage.noAuthorized 
                    })
                }
        } catch (err) {
            return res.status(401).json({ message: responseMessage.invalidToken })
        }
  } else {
    // if there is no token
    return res.status(400).json({ message: responseMessage.invalidRequest })
  }
}
router.use(logMiddleware);
    router.get('/user, checkAuthentication, handler);

内置中间件

Express 有以下内置的中间件功能：

  • express.static 提供静态资源，例如 HTML 文件，图像等。
  • express.json 负载解析用 JSON 传入的请求。
  • express.urlencoded

    Wie sieht die Middleware-Funktion aus? 

    • app.use(function (err, req, res, next) {
  console.error(err.stack)
  res.status(500).send('Something broke!')
})
Wenn ein Fehler auftritt und Sie keinen anderen Code ausführen möchten, rufen Sie diese Funktion nicht auf. Denken Sie in diesem Fall daran, eine Antwort zu senden, da der Client sonst auf eine Antwort wartet, bis das Zeitlimit überschritten wird. 

app.get('/users', (req, res, next) => {
  next(new Error('I am passing you an error!'));
});
app.use((err, req, res, next) => {
  console.log(err);    
  if(!res.headersSent){
    res.status(500).send(err.message);
  }
});

Middleware-Kette

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

app.get('/users, (req, res, next) => {
  let err = new Error('I couldn\'t find it.');
  err.httpStatusCode = 404;
  next(err);
});

app.get('/user, (req, res, next) => {
  let err = new Error('I\'m sorry, you can\'t do that, Dave.');
  err.httpStatusCode = 304;
  next(err);
});

app.use((err, req, res, next) => {
   // handles not found errors
  if (err.httpStatusCode === 404) {
    res.status(400).render('NotFound');
  }
   // handles unauthorized errors 
  else if(err.httpStatusCode === 304){
    res.status(304).render('Unauthorized');
  }
    // catch all
   else if (!res.headersSent) {
     res.status(err.httpStatusCode || 500).render('UnknownError');
  }
  next(err);
});
Nachdem Express die Anfrage erhalten hat , jede Middleware, die der Anforderung entspricht, wird in der Reihenfolge der Initialisierung ausgeführt, bis ein Beendigungsvorgang erfolgt.

So funktioniert die Node.js-MiddlewareDaher , wenn ein Fehler auftritt, werden alle Middleware zur Fehlerbehandlung nacheinander aufgerufen, bis eine davon den Funktionsaufruf

next()🎜 nicht mehr aufruft. 🎜

Typen von Express-Middleware🎜🎜🎜Middleware auf Router-Ebene, wie zum Beispiel: router.use🎜🎜Eingebaute Middleware, wie zum Beispiel: express.static, express.json, express .urlencoded 🎜🎜Middleware zur Fehlerbehandlung, zum Beispiel: app.use(err, req, res, next) 🎜🎜Middleware von Drittanbietern, zum Beispiel: bodyparser, cookieparser 🎜🎜Middleware auf Router-Ebene 🎜🎜🎜express.Router verwendet Express. Router-Klasse Erstellen Sie eine modulare, installierbare Routenverarbeitung. Eine Routing-Instanz ist ein vollständiges Middleware- und Routing-System. 🎜🎜🎜Sie können Middleware für Protokollierung, Authentifizierung und andere Vorgänge verwenden. Protokollieren Sie wie unten gezeigt die letzte Aktivität des Benutzers und analysieren Sie den Authentifizierungsheader. Verwenden Sie ihn, um den aktuell angemeldeten Benutzer zu ermitteln, und fügen Sie ihn dem Request-Objekt hinzu. 🎜🎜Diese Funktion wird jedes Mal ausgeführt, wenn das Programm eine Anfrage erhält. Wenn ein Fehler auftritt, wird die Antwort einfach beendet, ohne die nachfolgende Middleware oder Routenverarbeitung aufzurufen. 🎜🎜🎜🎜
const express = require('express');
const bodyParser = require('body-parser');
const app = express();
app.use(bodyParser.urlencoded({extended:false}))
app.use(bodyParser.json())
app.post('/save',(req,res)=>{
    res.json({
        "status":true,
         "payload":req.body
    })
}
app.listen(3000,(req,res)=>{
    console.log('server running on port')
})
🎜Eingebaute Middleware🎜🎜Express verfügt über die folgenden integrierten Middleware-Funktionen: 🎜🎜🎜express.static stellt statische Ressourcen wie HTML-Dateien, Bilder usw. bereit. 🎜🎜express.json Payload analysiert eingehende Anfragen in JSON. 🎜🎜express.urlencoded Analysiert eingehende URL-codierte Nutzlastanfragen. 🎜🎜🎜Middleware zur Fehlerbehandlung 🎜🎜Middleware zur Fehlerbehandlung benötigt immer vier Parameter 🎜 (err, req, res, next) 🎜. Sie müssen es als Middleware-Funktion zur Fehlerbehandlung identifizieren, indem Sie vier Parameter angeben. Auch wenn Sie das nächste Objekt nicht verwenden müssen, müssen Sie es angeben. Andernfalls wird das nächste Objekt als reguläre Middleware interpretiert und Fehler werden nicht behandelt. Die Grundsignatur sieht so aus: 🎜rrreee🎜🎜Beispiel 1:🎜🎜
app.get('/users', (req, res, next) => {
  next(new Error('I am passing you an error!'));
});
app.use((err, req, res, next) => {
  console.log(err);    
  if(!res.headersSent){
    res.status(500).send(err.message);
  }
});

在这种情况下，管道末端的错误处理中间件将会处理该错误。你可能还会注意到，我检查了 res.headersSent 属性。这只是检查响应是否已经将标头发送到客户端。如果还没有，它将向客户端发送 HTTP 500  状态和错误消息。

例2：

你还可以链接错误处理中间件。通常以不同的方式处理不同类型的错误：

app.get('/users, (req, res, next) => {
  let err = new Error('I couldn\'t find it.');
  err.httpStatusCode = 404;
  next(err);
});

app.get('/user, (req, res, next) => {
  let err = new Error('I\'m sorry, you can\'t do that, Dave.');
  err.httpStatusCode = 304;
  next(err);
});

app.use((err, req, res, next) => {
   // handles not found errors
  if (err.httpStatusCode === 404) {
    res.status(400).render('NotFound');
  }
   // handles unauthorized errors 
  else if(err.httpStatusCode === 304){
    res.status(304).render('Unauthorized');
  }
    // catch all
   else if (!res.headersSent) {
     res.status(err.httpStatusCode || 500).render('UnknownError');
  }
  next(err);
});
  • 在这种情况下，中间件检查是否抛出了 404（not found）错误。如果是，它将渲染 “NotFound” 模板页面，然后将错误传递到中间件中的下一项。
  • 下一个中间件检查是否抛出了 304（unauthorized）错误。如果是，它将渲染“Unauthorized”页面，并将错误传递到管道中的下一个中间件。
  • 最后，“catch all” 错误处理仅记录错误，如果未发送响应，它将发送错误的 httpStatusCode（如果未提供则发送 HTTP 500 状态）并渲染 “UnknownError” 模板。

第三方级别的中间件

在某些情况下，我们将向后端添加一些额外的功能。先安装 Node.js 模块获取所需的功能，然后在应用级别或路由器级别将其加载到你的应用中。

示例：当 body-parser 处理 Content-Type 请求标头时，所有中间件都将使用解析的正文填充 req.body 属性。

const express = require('express');
const bodyParser = require('body-parser');
const app = express();
app.use(bodyParser.urlencoded({extended:false}))
app.use(bodyParser.json())
app.post('/save',(req,res)=>{
    res.json({
        "status":true,
         "payload":req.body
    })
}
app.listen(3000,(req,res)=>{
    console.log('server running on port')
})

总结

中间件功能是一种非常好的方式，可以对每个请求或针对特定路由的每个请求运行代码，并对请求或响应数据采取措施。中间件是现代 Web 服务器的重要组成部分，并且非常有用。

更多编程相关知识，请访问：编程入门！！

Das obige ist der detaillierte Inhalt vonSo funktioniert die Node.js-Middleware. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!

Stellungnahme：
Dieser Artikel ist reproduziert unter:thirdrocktechkno. Bei Verstößen wenden Sie sich bitte an admin@php.cn löschen
Vorheriger Artikel：Ein genauerer Blick auf Multithreading und Multi-Processing in Node.jsNächster Artikel：Ein genauerer Blick auf Multithreading und Multi-Processing in Node.js

In Verbindung stehende Artikel

Mehr sehen