Que signifient les middlewares et app.use dans Expressjs?
Presque toutes les applications Express que je vois ont une instruction app.use pour le middleware, mais je n'ai pas trouvé d'explication claire et concise de ce qu'est réellement le middleware et de ce que fait l'instruction app.use. Même les documents express eux-mêmes sont un peu vagues à ce sujet. Pouvez-vous expliquer ces concepts pour moi s'il vous plaît?
Je suis à mi-chemin de la séparation du concept de middleware dans un nouveau projet.
Le middleware vous permet de définir une pile d'actions que vous devez parcourir. Les serveurs express eux-mêmes sont une pile de middlewares.
// express
var app = express();
// middleware
var stack = middleware();
Ensuite, vous pouvez ajouter des couches à la pile de middleware en appelant .use
// express
app.use(express.static(..));
// middleware
stack.use(function(data, next) {
next();
});
Une couche de la pile de middleware est une fonction qui prend n paramètres (2 pour express, req & res) et une fonction next.
Le middleware s'attend à ce que la couche fasse des calculs, augmente les paramètres, puis appelle next.
Une pile ne fait rien à moins que vous ne la manipuliez. Express gérera la pile chaque fois qu'une demande HTTP entrante est interceptée sur le serveur. Avec le middleware, vous gérez la pile manuellement.
// express, you need to do nothing
// middleware
stack.handle(someData);
Un exemple plus complet:
var middleware = require("../src/middleware.js");
var stack = middleware(function(data, next) {
data.foo = data.data*2;
next();
}, function(data, next) {
setTimeout(function() {
data.async = true;
next();
}, 100)
}, function(data) {
console.log(data);
});
stack.handle({
"data": 42
})
En termes explicites, vous définissez simplement une pile d'opérations que vous souhaitez que Express gère pour chaque demande HTTP entrante.
En termes d’express (plutôt que de connexion), vous avez un middleware global et un middleware spécifique au routage. Cela signifie que vous pouvez attacher une pile de middleware à chaque demande HTTP entrante ou seulement l'attacher à des demandes HTTP qui interagissent avec un certain itinéraire.
Exemples avancés d'express & middleware:
// middleware
var stack = middleware(function(req, res, next) {
users.getAll(function(err, users) {
if (err) next(err);
req.users = users;
next();
});
}, function(req, res, next) {
posts.getAll(function(err, posts) {
if (err) next(err);
req.posts = posts;
next();
})
}, function(req, res, next) {
req.posts.forEach(function(post) {
post.user = req.users[post.userId];
});
res.render("blog/posts", {
"posts": req.posts
});
});
var app = express.createServer();
app.get("/posts", function(req, res) {
stack.handle(req, res);
});
// express
var app = express.createServer();
app.get("/posts", [
function(req, res, next) {
users.getAll(function(err, users) {
if (err) next(err);
req.users = users;
next();
});
}, function(req, res, next) {
posts.getAll(function(err, posts) {
if (err) next(err);
req.posts = posts;
next();
})
}, function(req, res, next) {
req.posts.forEach(function(post) {
post.user = req.users[post.userId];
});
res.render("blog/posts", {
"posts": req.posts
});
}
], function(req, res) {
stack.handle(req, res);
});
Après avoir simplifié les choses, un serveur Web peut être considéré comme une fonction qui reçoit une demande et génère une réponse. Ainsi, si vous affichez un serveur Web en tant que fonction, vous pouvez l'organiser en plusieurs parties et les séparer en fonctions plus petites afin que leur composition soit la fonction d'origine.
Les middlewares sont les plus petites fonctions que vous pouvez composer avec d'autres et l'avantage évident est que vous pouvez les réutiliser.
J'ajoute une réponse tardive pour ajouter quelque chose qui n'est pas mentionné dans les réponses précédentes.
À présent, il devrait être clair que le middleware est/sont une/des fonction (s) exécutée (s) entre la demande client et la réponse server. Les fonctionnalités de middleware les plus courantes sont la gestion des erreurs, l’interaction avec la base de données, l’obtention d’informations à partir de fichiers statiques ou d’autres ressources. Pour déplacer la pile de middleware, le prochain rappel doit être appelé. Vous pouvez le voir à la fin de la fonction de middleware pour passer à l'étape suivante du flux.
Vous pouvez utiliser l'approche app.use et créer un flux comme celui-ci :
var express = require('express'),
app = express.createServer(),
port = 1337;
function middleHandler(req, res, next) {
console.log("execute middle ware");
next();
}
app.use(function (req, res, next) {
console.log("first middle ware");
next();
});
app.use(function (req, res, next) {
console.log("second middle ware");
next();
});
app.get('/', middleHandler, function (req, res) {
console.log("end middleware function");
res.send("page render finished");
});
app.listen(port);
console.log('start server');
mais vous pouvez également utiliser une autre approche et passer chaque middleware en tant qu'argument de fonction. Voici un exemple du site Web de MooTools Nodejs où midleware obtient le flux Twitter, Github et Blog avant que la variable response ne soit renvoyée au client. Notez comment les fonctions sont passées comme arguments dans app.get('/', githubEvents, Twitter, getLatestBlog, function(req, res){. L'utilisation de app.get ne sera appelée que pour les demandes GET, app.use sera appelée pour toutes les demandes.
// github, Twitter & blog feeds
var githubEvents = require('./middleware/githubEvents')({
org: 'mootools'
});
var Twitter = require('./middleware/Twitter')();
var blogData = require('./blog/data');
function getLatestBlog(req, res, next){
blogData.get(function(err, blog) {
if (err) next(err);
res.locals.lastBlogPost = blog.posts[0];
next();
});
}
// home
app.get('/', githubEvents, Twitter, getLatestBlog, function(req, res){
res.render('index', {
title: 'MooTools',
site: 'mootools',
lastBlogPost: res.locals.lastBlogPost,
tweetFeed: res.locals.Twitter
});
});
===== Explication très très simple =====
Les middlewares sont souvent utilisés dans le cadre du framework Express.js et constituent un concept fondamental pour node.js. En un mot, il s’agit essentiellement d’une fonction qui a accès aux objets requête et réponse de votre application. La façon dont je voudrais y penser est une série de "vérifications/pré-écrans" que la demande passe avant que l'application ne la traite. Par exemple, les middlewares seraient un bon moyen de déterminer si la demande est authentifiée avant de passer à l’application et de retourner la page de connexion si la demande n’est pas authentifiée ou pour la journalisation de chaque demande. De nombreux middlewares tiers sont disponibles pour permettre diverses fonctionnalités.
Exemple de middleware simple:
var app = express();
app.use(function(req,res,next)){
console.log("Request URL - "req.url);
next();
}
Le code ci-dessus serait exécuté pour chaque demande entrant et consignera l'URL de la demande. La méthode next () permet essentiellement au programme de continuer. Si la fonction next () n'est pas appelée, le programme ne poursuivra pas et s'arrêtera lors de l'exécution du middleware.
Quelques pièges à middleware:
- L'ordre des middlewares dans votre application est important, car la requête traiterait chacun d'eux dans un ordre séquentiel.
- Oublier d'appeler la méthode next () dans votre fonction middleware peut interrompre le traitement de votre requête.
- Toute modification des objets req et res dans la fonction middleware rendrait la modification disponible pour les autres parties de l'application qui utilisent req et res
Les middlewares sont des fonctions exécutées au milieu après que l'entrée/la source génère ensuite une sortie qui pourrait être la sortie finale ou qui pourrait être utilisée par le middleware suivant jusqu'à la fin du cycle.
C'est comme un produit qui passe par une chaîne d'assemblage où il est modifié au fur et à mesure jusqu'à ce qu'il soit terminé, évalué ou rejeté.
Un middleware s'attend à travailler sur une valeur (c'est-à-dire des valeurs de paramètre) et, sur la base d'une logique, le middleware appellera ou non le middleware suivant ou renverra une réponse au client.
Si vous ne pouvez toujours pas comprendre le concept d'intergiciel, il est similaire aux modèles de décorateur ou de chaîne de commande.
Le middleware est un sous-ensemble de fonctions en chaîne appelées par la couche de routage Express js avant que le gestionnaire défini par l'utilisateur ne soit appelé. Les fonctions middleware ont un accès complet aux objets de requête et de réponse et peuvent modifier l'un ou l'autre.
La chaîne de middleware est toujours appelée dans l'ordre exact dans lequel elle a été définie. Il est donc essentiel que vous sachiez exactement ce que fait un middleware spécifique.
Une fois qu'un middleware a fini, il appelle la fonction suivante dans la chaîne en invoquant son argument suivant en tant que fonction.
Une fois la chaîne complète exécutée, le gestionnaire de demandes de l'utilisateur est appelé.
Gardez les choses simples, mec!
Note: la réponse est liée aux cas de logiciels intermédiaires intégrés à ExpressJS, mais il existe différentes définitions et cas d'utilisation de middlewares.
De mon point de vue, le middleware agit comme un utilitaire ou des fonctions d'assistance, mais son activation et son utilisation sont totalement facultatives en utilisant la app.use('path', /* define or use builtin middleware */) qui ne veut pas que nous écrivions du code pour effectuer des tâches très courantes qui sont nécessaires. pour chaque requête HTTP de notre client, comme les cookies de traitement, les jetons CSRF et ..., qui sont très courants dans la plupart des applications le middleware peut donc nous aider à faire tout cela pour chaque requête HTTP de notre client dans une pile, une séquence ou un ordre) d’opérations fournit alors le résultat du processus sous la forme d’une seule unité de demande client}.
Exemple:
Accepter les demandes des clients et leur répondre en fonction de leurs demandes est la nature même de la technologie des serveurs Web.
Imaginez si nous fournissons une réponse avec juste "Hello, world!" Le texte d'une requête HTTP GET adressée à l'URI racine de notre serveur Web est un scénario très simple et ne nécessite rien d'autre, mais si nous vérifions l'utilisateur actuellement connecté puis répondons par "Hello, Username!" besoin de quelque chose de plus que d'habitude dans ce cas, nous avons besoin d'un middleware pour traiter toutes les métadonnées de la demande du client et nous fournir les informations d'identification saisies à partir de la demande du client, puis, en fonction de cette information, nous pouvons identifier de manière unique notre utilisateur actuel et pouvoir y répondre/elle avec des données liées.
J'espère que ça aidera quelqu'un!
En termes très basiques, si je veux l'expliquer ainsi, je l'apprends grâce au cours intensif de traversymedia youtube channel express.
ok donc le middleware est une fonction qui s'exécute après que vous ayez appelé votre route comme ceci.
var logger = function(req, res, next){
console.log('logging...');
next();
}
app.use(logger);
Cette fonction de journalisation s'exécute à chaque fois que vous actualisez votre page, ce qui signifie que vous pouvez y écrire tout ce que vous devez faire après que votre page soit rendue dans un appel d'opération d'opération, pour tout réinitialiser. et mettez ce middleware avant que votre fonction de routage ne soit vraiment importante