Comprendre les middlewares dans Express.js et leur fonctionnement interne

Dans Express.js, les middlewares sont des fonctions spéciales qui ont accès à la requête (req), à la réponse (res) et à un troisième paramètre appelé next. Contrairement aux gestionnaires de routes classiques, les middlewares jouent un rôle essentiel dans le contrôle du flux de l'application en exécutant une logique externe avant la logique métier principale.

Comment fonctionnent les middlewares ?

Lorsqu'une requête HTTP atteint un serveur Express.js, elle passe par une série de fonctions middleware. Chaque middleware peut :

• Modifiez l'objet de la requête (par exemple, joignez des données, validez les jetons).
• Modifiez l'objet de réponse (par exemple, envoyez une réponse plus tôt).
• Passez le contrôle au middleware suivant dans la pile à l'aide de la fonction next().

Si un middleware n'appelle pas next(), le cycle requête-réponse se termine là et aucune autre logique (y compris les gestionnaires de route) ne s'exécutera.

Pourquoi utilisons-nous des middlewares ?

Les middlewares sont parfaits pour les scénarios où nous devons ajouter une logique réutilisable avant de traiter une requête. Par exemple :

• Authentification : Vérifier si l'utilisateur est connecté (par exemple, valider - les jetons JWT).
• Autorisation : S'assurer que les utilisateurs disposent des autorisations nécessaires pour effectuer certaines actions (par exemple, les administrateurs peuvent supprimer du contenu).
• Validation de la demande : Vérifier si toutes les entrées requises sont fournies.
• Journalisation et surveillance : Enregistrement des détails des demandes entrantes d'analyse ou de débogage.
• Gestion des erreurs : Détecter les erreurs à l'échelle mondiale pour envoyer des réponses significatives.

Définir et utiliser des middlewares

Une fonction middleware ressemble à ceci :

app.use((req, res, next) => {
    // Logic here
    next(); // Pass control to the next middleware or route handler
});

• req (Request) : Contient des informations sur la requête HTTP entrante (par exemple, en-têtes, corps, paramètres).
• res (Réponse) : Utilisé pour renvoyer des données au client. next() : une fonction qui passe le contrôle au prochain middleware en ligne.

Flux middleware : ordre d'exécution

L’ordre des middlewares est important ! Express exécute les middlewares séquentiellement dans l'ordre dans lequel ils sont définis.

Si un middleware est défini après une route, cela n'affectera pas cette route. C'est pourquoi les middlewares doivent être déclarés avant les routes dans votre app.js.

Exemple :

// Middleware to check if the user has admin privileges
app.use((req, res, next) => {
    console.log("Checking for admin role...");

    // Simulating a user object attached earlier in the pipeline
    if (req.user && req.user.role === "admin") {
        console.log("Access granted");
        next(); // Move to the next middleware or route handler
    } else {
        console.log("Access denied");
        res.status(403).send("You do not have access to this resource.");
    }
});

// Routes
app.get("/admin/dashboard", (req, res) => {
    res.send("Welcome to the admin dashboard!");
});

app.get("/public", (req, res) => {
    res.send("This is a public page.");
});

Flux d'exécution interne

Voici ce qui se passe étape par étape :

• Demande entrante : Une requête arrive au serveur.
• Exécution du middleware :
  • Le middleware vérifie le req.user.role.
  • Si le rôle est "admin", il appelle next() pour passer le contrôle au prochain middleware ou route.
  • Sinon, le middleware met fin à la requête en envoyant une réponse 403 Forbidden.
• Gestionnaire de route : Si next() est appelé, le gestionnaire de route concerné (par exemple, /admin/dashboard) s'exécute.

Exemple de flux :

• Un utilisateur avec le rôle : "admin" demande /admin/dashboard.
  • Le middleware enregistre "Accès accordé" et appelle next().
  • Le gestionnaire d'itinéraire envoie "Bienvenue dans le tableau de bord d'administration !".
• Un utilisateur avec le rôle : "utilisateur" demande /admin/dashboard.
  • Le middleware enregistre « Accès refusé » et envoie « Vous n'avez pas accès à cette ressource ».

Points clés à retenir

• Les middlewares sont comme des gardiens : ils décident de ce qui se passe avant l'exécution de la logique de route principale.
• Utilisez next() pour vous assurer que le flux continue jusqu'au prochain middleware ou itinéraire.
• Définissez toujours les middlewares critiques avant les routes pour vous assurer qu'ils s'appliquent.
• Si vous n'appelez pas next() ou n'envoyez pas de réponse, la demande se bloquera (expiration du délai).

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!