Une brève discussion sur le fonctionnement du middleware Node.js

Qu'est-ce que le middleware Express ?

• Le middleware désigne littéralement tout ce que vous mettez entre une couche de logiciel et une autre.
• Le middleware Express est une fonction exécutée pendant le cycle de vie d'une requête au serveur Express.
• Chaque middleware a accès aux requêtes et réponses HTTP pour toutes les routes auxquelles il est attaché.
• De plus, le middleware peut mettre fin à la requête HTTP ou la transmettre à une autre fonction middleware en utilisant next. Cette « chaîne » de middleware vous permet de partitionner votre code et de créer un middleware réutilisable.

Conditions requises pour l'écriture du middleware Express

Vous devez installer quelques éléments pour créer, utiliser et tester le middleware Express. Vous avez d’abord besoin de Node et de NPM. Pour vous assurer qu'il est installé, exécutez :

npm -v && node -v

Vous devriez voir les versions installées de Node et NPM. Si vous obtenez une erreur, vous devez installer Node. Tous les exemples doivent être utilisés sous Node ver 8+ et NPM ver 5+.

Cet article utilise la version Express 4.x. Ceci est important car des changements importants ont été apportés entre la version 3.x et la version 4.x.

Middleware Express : bases

Nous utilisons d’abord le middleware intégré le plus basique d’Express. Créez un nouveau projet et npm initialisez-le…

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);

Quel problème le middleware résout-il ? Pourquoi l'utiliser ?

Supposons que vous exécutez une application Web utilisant Node.js et Express sur un serveur Web. Dans cette application, vous devez vous connecter à certaines pages.

Lorsqu'un serveur Web reçoit une demande de données, Express vous fournira un objet de demande contenant des informations sur l'utilisateur et les données demandées. Express vous donne également accès aux objets de réponse, qui peuvent être modifiés avant que le serveur Web ne réponde à l'utilisateur. Ces objets sont généralement raccourcis en req, res. La fonction middleware

est un endroit idéal pour modifier les objets req et res avec des informations pertinentes. Par exemple, une fois qu'un utilisateur est connecté, vous pouvez obtenir ses détails d'utilisateur à partir de la base de données, puis stocker ces détails dans res.user.

À quoi ressemble la fonction middleware ?

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
    }
}

N'appelez pas cette fonction si une erreur se produit et que vous ne souhaitez pas exécuter d'autre code. N'oubliez pas d'envoyer une réponse dans ce cas, sinon le client attendra une réponse jusqu'à expiration du délai.

var app = express();

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

Chaînage de middleware

Vous pouvez chaîner des middlewares dans un tableau de middlewares ou en utilisant plusieurs app.use appels :

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

Express après réception de la requête, chaque middleware qui correspond au La requête sera exécutée dans l'ordre d'initialisation jusqu'à ce qu'il y ait une opération de terminaison.

Ainsi si une erreur survient, tous les middlewares de gestion des erreurs seront appelés en séquence jusqu'à ce que l'un d'entre eux n'appelle plus next() jusqu'à ce que la fonction est appelé.

Types de middleware express

• Middleware au niveau du routeur, par exemple : router.use
• Middleware intégré, par exemple : express.static, express. json, express.urlencoded
• Middleware de gestion des erreurs, par exemple : app.use(err, req, res, next)
• Middleware tiers, par exemple : bodyparser, cookieparser
• Middleware au niveau du routeur

• express.Router Utilisez la classe express.Router pour créer un traitement de routage modulaire et installable. Une instance de routage est un middleware et un système de routage complet.

  • Vous pouvez utiliser un middleware pour la journalisation, l'authentification et d'autres opérations. Comme indiqué ci-dessous, pour enregistrer la dernière activité de l'utilisateur et analyser l'en-tête d'authentification, utilisez-le pour déterminer l'utilisateur actuellement connecté et ajoutez-le à l'objet Request.
  • Cette fonction est exécutée à chaque fois que le programme reçoit une requête. S'il y a une erreur, il met simplement fin à la réponse sans appeler de middleware ou de traitement de route ultérieur.

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);

Middleware intégré

Express possède les fonctions middleware intégrées suivantes :

• express.static Fournit des fonctions statiques ressources, par exemple des fichiers HTML, des images, etc.
• express.json Payload analyse les requêtes entrantes en JSON.
• express.urlencoded Analyse une demande de charge utile entrante codée en URL.

Middleware de gestion des erreurs

Le middleware de gestion des erreurs prend toujours quatre paramètres (err, req, res, next) . Vous devez l'identifier comme une fonction middleware de gestion des erreurs en fournissant quatre paramètres. Même si vous n'avez pas besoin d'utiliser l'objet suivant, vous devez le spécifier. Sinon, l'objet suivant sera interprété comme un middleware standard et les erreurs ne seront pas traitées. La signature de base ressemble à ceci :

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

Exemple 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 服务器的重要组成部分，并且非常有用。

英文原文地址：https://www.thirdrocktechkno.com/blog/how-Node-JS-middleware-works/

为了保证的可读性，本文采用意译而非直译。

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

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!