Implémentation du middleware nodejs

Node.js est un environnement d'exploitation côté serveur très puissant et un framework de développement back-end populaire. Node.js possède de nombreuses fonctionnalités puissantes, dont le middleware. Le middleware est un concept important dans Node.js, qui fournit aux applications Node.js un moyen plus flexible et personnalisable de gérer les demandes. Dans l'article suivant, nous verrons comment utiliser le middleware dans Node.js.

Qu’est-ce qu’un middleware ?

Dans Node.js, le middleware est une fonction qui peut accéder à l'objet de requête d'application (req), à l'objet de réponse (res) et passer le contrôle directement à la fonction middleware suivante. Les fonctions middleware sont généralement conçues pour effectuer certaines opérations, telles que la journalisation des demandes, l'authentification, la vérification des données, etc.

Le Middleware est l'une des fonctionnalités très puissantes de Node.js. Il peut fournir les fonctions suivantes :

1. Aide à gérer les requêtes et réponses HTTP
2. Modifier les objets de requête ou de réponse
3. Effectuer certaines opérations dans l'application
4. Jump Install d'autres middleware tiers via la pile middleware

Comment fonctionne le middleware

Le middleware est une fonctionnalité importante de Node.js, et son mode de fonctionnement et son cycle de vie sont très faciles à comprendre. En termes simples, lorsqu'une requête HTTP entre dans le serveur, toutes les fonctions middleware de l'application seront exécutées dans l'ordre. Chaque fonction middleware peut gérer les objets de requête et de réponse et peut éventuellement transmettre la requête au middleware suivant.

Jetons un coup d'œil au format d'utilisation de base du middleware :

app.use(function (req, res, next) {
    console.log('This is a middleware function');
    next();
});

Dans l'exemple ci-dessus, nous avons défini une fonction middleware. Lorsque cette fonction est appelée par l'application, elle imprime un message de journal puis appelle la méthode next(). La méthode next() transfère le contrôle à la fonction middleware suivante (s'il y en a une).

Si la méthode next() n'est pas appelée, la requête sera suspendue et ne continuera pas. Dans ce cas, l'application n'envoie aucune réponse. Il s'agit généralement d'une condition d'erreur, donc lors de l'écriture de fonctions middleware, assurez-vous d'appeler la méthode next().

Classification du middleware Node.js

Dans Node.js, le middleware peut être divisé en deux types suivants :

1. Middleware au niveau de l'application
2. Middleware au niveau de la route

Middleware au niveau de l'application

Le middleware au niveau de l'application fait référence au middleware qui peut gérer toutes les requêtes de l’application actuelle. Ce middleware est ajouté via la méthode app.use(). Par exemple, enregistrez toutes les demandes, implémentez l'authentification, etc.

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

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

Middleware au niveau de la route

Le middleware au niveau de la route, comme son nom l'indique, est un middleware qui ne peut traiter que les demandes de routage en cours. Ce middleware est ajouté via la méthode use() de l'objet Router. Par exemple : implémenter la vérification des demandes, implémenter la mise en cache, etc.

let express = require('express');
let router = express.Router();

router.use(function (req, res, next) {
   console.log('Request URL:', req.originalUrl);
   next();
});

Utilisation d'un middleware tiers

Dans Node.js, l'utilisation d'un middleware tiers est généralement une pratique très courante. Cette approche nous permet d'ajouter des fonctionnalités existantes à notre application sans avoir à consacrer du temps et des efforts à écrire notre propre code. Voici comment utiliser un middleware tiers très célèbre, le middleware body-parser.

let express = require('express');
let bodyParser = require('body-parser');

let app = express();

// 处理 application/x-www-form-urlencoded 类型的请求体
app.use(bodyParser.urlencoded({ extended: false }));

// 处理 application/json 类型的请求体
app.use(bodyParser.json());

Résumé

Dans cet article, nous avons appris la définition, les fonctions et la classification du middleware Node.js. Le middleware est un concept très important dans Node.js. Grâce au middleware, nous pouvons ajouter plus de fonctions et de flexibilité à l'application. Qu'il s'agisse d'un middleware au niveau de l'application ou d'un middleware au niveau de la route, en utilisant correctement les fonctions du middleware, vous pouvez implémenter votre logique d'application de manière plus efficace.

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!