Après avoir simplifié les choses, un serveur web peut être considéré comme une fonction qui prend une requête et génère une réponse. Donc, si vous affichez un serveur web en tant que fonction, vous pouvez organiser en plusieurs morceaux et de les séparer en petites fonctions, de sorte que la composition d'entre eux sera 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 la ou les fonctions exécutées entre la requête du client et la réponse du serveur . Les fonctionnalités de middleware les plus courantes nécessaires sont la gestion des erreurs, l'interaction de la base de données, l'obtention d'informations à partir de fichiers statiques ou d'autres ressources. Pour se déplacer sur la pile middleware, le rappel suivant doit être appelé, vous pouvez le voir à la fin de la fonction middleware pour se déplacer la prochaine étape dans le flux.

Vous pouvez utiliser le app.use approche et un flux de comme ceci:

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'arguments de fonction. Voici un exemple du site Web de Mootools Nodejs où midleware obtient le flux Twitter, Github et Blog avant que le response ne soit renvoyé au client. Notez comment les fonctions sont passées en tant qu'arguments dans app.get('/', githubEvents, twitter, getLatestBlog, function(req, res){. L'utilisation de app.get ne sera appelée que pour les requêtes GET, app.use sera appelé 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
    });
});

Expressjs guide a une réponse assez soignée à votre question, je vous recommande fortement de lire cela, je poste un court extrait du guide, le guide est assez bon.

Écriture middleware pour une utilisation dans les applications Express

Vue d'ensemble

Middleware les fonctions sont des fonctions qui ont accès à l' objet de demande (req), le objet de réponse (res), et la fonction suivante dans l'application cycle demande-réponse. La fonction suivante est une fonction dans le routeur Express qui, lorsqu'elle est invoquée, exécute le middleware succédant au middleware actuel.

Les fonctions Middleware peuvent effectuer les tâches suivantes:

• exécute n'importe quel code.
• modifiez les objets request et response.
• terminer le cycle demande-réponse.
• appelez le middleware suivant dans la pile.

Si la fonction middleware actuelle ne met pas demande-réponse, il doit appeler next () pour passer le contrôle à la fonction middleware suivante. Sinon, la demande sera laissée en suspens.

Exemple

Voici un exemple d'une simple Application Express "Hello World". Le reste de cet article définira et ajoutera deux fonctions middleware à l'application: une appelée myLogger {[14] } qui imprime un message de journal simple et une autre appelée Temps de demande¹ qui affiche l'horodatage de la requête HTTP.

var express = require('express')
var app = express()

app.get('/', function (req, res) {
  res.send('Hello World!')
})

app.listen(3000)   

Fonction Middleware myLogger

Voici un exemple simple d'une fonction middleware appelée "myLogger". Cette fonction imprime simplement "connecté" lorsqu'une demande à l'application passe à travers elle. La fonction middleware est affectée à une variable nommée myLogger.

var myLogger = function (req, res, next) {
  console.log('LOGGED')
  next()
}

Notez l'appel ci-dessus à next(). L'appel de cette fonction appelle le middleware suivant fonction dans l'application. La fonction next () ne fait pas partie du nœud.JS ou Express API, mais est le troisième argument qui est passé à la fonction middleware. La fonction next () peut être nommée n'importe quoi, mais par convention elle est toujours nommée "next". Pour éviter toute confusion, utilisez toujours cette convention.

Pour charger la fonction middleware, appelez app.utilisez () , en spécifiant la fonction middleware. Par exemple, le code suivant charge le myLogger fonction middleware avant la route vers le chemin racine ( / ).

var express = require('express')
var app = express()

var myLogger = function (req, res, next) {
  console.log('LOGGED')
  next()
}

app.use(myLogger)

app.get('/', function (req, res) {
  res.send('Hello World!')
})

app.listen(3000)

Chaque fois que l'application reçoit une demande, elle imprime le message "LOGGED" sur le terminal.

L'ordre de chargement du middleware est important: les fonctions du middleware qui sont chargées en premier sont également exécutées en premier.

Si myLogger est chargé après la route vers le chemin racine, la requête ne l'atteint jamais et l'application n'affiche pas "connecté", car le gestionnaire de route du chemin racine termine le cycle demande-réponse.

La fonction middleware myLogger imprime simplement un message, puis transmet la requête à la fonction middleware suivante de la pile en appelant la fonctionnext () .

Les Middlewares sont des fonctions exécutées au milieu après que l'entrée/la source produit une sortie qui pourrait être la sortie finale ou 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 qu'il se déplace jusqu'à ce qu'il soit terminé, évalué ou rejeté.

Un middleware s'attend à ce qu'une valeur fonctionne (c'est-à-dire des valeurs de paramètre) et basé sur une logique, le middleware appellera ou pas appeler le middleware suivant ou envoyer une réponse au client.

Si vous ne pouvez pas encore saisir le concept de middleware, il est d'une manière similaire aux modèles de décorateur ou de chaîne de commandement.

=====Très très simple explication=====

Les Middlewares sont souvent utilisés dans le contexte D'Express.cadre js et sont un concept fondamental pour le nœud.js . En un mot, c'est essentiellement une fonction qui a accès aux objets request et response de votre application. La façon dont je voudrais y penser, est une série de "contrôles / pré-écrans" que la demande Traverse avant qu'elle ne soit traitée par l'application. Par exemple, les Middlewares seraient un bon moyen de déterminer si la demande est authentifié avant de passer à l'application et de retourner la page de connexion si la demande n'est pas authentifiée ou pour journaliser chaque demande. Beaucoup de middlewares tiers sont disponibles qui permet une variété de 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 requête qui entre et enregistrerait l'url de la requête, la méthode next() permet essentiellement au programme de continuer. Si la fonction next() n'est pas appelée, le programme ne poursuivrait pas plus loin et s'arrêterait à l'exécution du middleware.

Quelques Gotchas Middleware:

1. l'ordre des middlewares dans votre application est important, car la demande passerait par chacun dans un ordre séquentiel.
2. oublier d'appeler la méthode next () dans votre fonction middleware peut arrêter le traitement de votre requête.
3. toute modification des objets req et res dans la fonction middleware rendrait la modification disponible pour d'autres parties de l'application qui utilise req. et res

Middleware est un sous-ensemble de fonctions chaînées 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 request et response et peuvent les modifier.

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 qu'un middleware spécifique fait.
Une fois une fonction middleware terminée, elle appelle la fonction suivante chaîne en invoquant son argument suivant en tant que fonction.
Une fois la chaîne complète exécutée, le gestionnaire de requêtes utilisateur est appelé.

garde les choses simples, mec!

Note: la réponse est liée aux cas de middlware intégré ExpressJS, mais il existe différentes définitions et cas d'utilisation des middlewares.

De mon point de vue, middleware agit comme des fonctions d'utilité ou d'assistance, mais son activation et son utilisation sont entièrement facultatives en utilisant le app.use('path', /* define or use builtin middleware */) qui ne veut pas de nous écrire du code pour faire des tâches très courantes qui sont nécessaires pour chaque requête HTTP de notre client comme traitement des cookies, jetons CSRF et ..., qui sont très communs dans la plupart des applications donc middleware peut 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, puis fournir le résultat du processus comme une seule unité de requête client .

Exemple:

Accepter les demandes des clients et leur fournir des réponses en fonction de leurs demandes est la nature de la technologie des serveurs web.

Imaginez si nous fournissons un réponse avec un simple "Bonjour, monde!"le texte d'une requête HTTP GET à L'URI racine de notre serveur web est un scénario très simple et n'a besoin de rien d'autre, mais si nous vérifions l'utilisateur actuellement connecté et répondons avec" Bonjour, nom D'utilisateur!"a 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 selon cette information, nous pouvons identifier de manière unique notre courant utilisateur et il est possible de répondre à lui / elle avec des données connexes.

J'espère que cela aidera quelqu'un!