Définit si une image defond est fixe ou défile avec le reste de la page
Découvrez le concept des middlewares dans ExpressJS, leur fonctionnement et leur importance dans les applications Node.js. Tutoriel détaillé avec exemples.
Dans le développement d’une application ExpressJS, la gestion des requêtes et des réponses est primordiale. Imaginez que vous puissiez intercepter chaque requête HTTP pour la vérifier, la modifier ou la sécuriser avant qu’elle n’atteigne sa destination finale. C’est exactement ce que permettent les middlewares ! Ils jouent un rôle clé dans la personnalisation et l’optimisation du flux de données entre le client et le serveur.
Un middlewares en ExpressJS est une fonction qui s'exécute entre la réception d'une requête et l'envoi d'une réponse. Il joue un rôle intermédiaire dans le cycle de traitement des requêtes HTTP en permettant d'effectuer diverses opérations, telles que l'authentification, la gestion des erreurs, la journalisation, ou encore la modification des objets req (requête) et res (réponse). Un middlewares peut intercepter, modifier ou compléter les données de la requête avant qu'elles n'atteignent le gestionnaire final. Dans ExpressJS, ces fonctions sont exécutées dans l'ordre où elles sont déclarées, et chaque middlewares doit appeler la fonction next() pour transférer le contrôle au middlewares suivant, sinon la requête restera bloquée.
Voici un exemple simple d'un middlewares qui enregistre l'heure de chaque requête :
var express = require('express');
var app = express();
app.use(function(req, res, next){
console.log("Nouvelle requête reçue à " + Date.now());
next();
});
app.listen(3000);
Lorsque vous accédez à localhost:3000, ce middleware s'exécutera et affichera un message dans la console.
L'ordre dans lequel les middlewares sont définis est crucial, car ils sont exécutés dans la séquence où ils apparaissent.
var express = require('express');
var app = express();
app.use(function(req, res, next){
console.log("Début");
next();
});
app.get('/', function(req, res, next){
res.send("Milieu");
next();
});
app.use('/', function(req, res){
console.log('Fin');
});
app.listen(3000);
Lorsque vous visitez /, la console affichera :
Les middlewares dans ExpressJS sont essentiels pour gérer les requêtes HTTP de manière flexible et efficace. Ils peuvent être classés en plusieurs types selon leur rôle et leur position dans le cycle de vie des requêtes. Voici les principaux types de middlewares que vous rencontrerez dans ExpressJS :
Les middlewares d'application sont utilisés pour traiter toutes les requêtes dans une application ExpressJS. Ils sont souvent utilisés pour configurer des fonctionnalités globales telles que l'enregistrement des logs, la gestion des erreurs, ou l'ajout de headers HTTP. Ils sont définis en utilisant app.use() et affectent toutes les routes.
var express = require('express');
var app = express();
// Middleware global de l'application
app.use(function(req, res, next) {
console.log("Requête reçue à " + Date.now());
next();
});
app.listen(3000);
Dans cet exemple, ce middleware s'exécute pour chaque requête reçue, quelle que soit la route.
Les middlewares de route sont spécifiquement liés à une route particulière. Ils ne s'exécutent que lorsqu'une requête correspond à une route définie. Ce type de middleware est utile pour gérer des fonctionnalités spécifiques à certaines routes, comme l'authentification ou la validation des données.
var express = require('express');
var app = express();
// Middleware spécifique à la route "/login"
app.post('/login', function(req, res, next) {
console.log('Middleware de la route /login');
next();
});
app.listen(3000);
Ce middleware sera exécuté uniquement lorsque l'utilisateur accède à la route /login.
Les middlewares d'erreur sont utilisés pour gérer les erreurs dans l'application ExpressJS. Ils doivent être définis après toutes les autres routes et middlewares, car ils sont appelés lorsqu'une erreur est détectée dans la requête. Ces middlewares sont utilisés pour capturer et répondre de manière appropriée aux erreurs, comme les erreurs 404 ou 500.
var express = require('express');
var app = express();
// Middleware de gestion des erreurs
app.use(function(err, req, res, next) {
console.error(err.stack);
res.status(500).send('Quelque chose a mal tourné!');
});
app.listen(3000);
Dans cet exemple, si une erreur se produit dans l'application, ce middleware sera appelé pour afficher l'erreur dans la console et envoyer une réponse avec un code de statut 500.
Les middlewares tiers sont des modules externes installés via npm qui ajoutent des fonctionnalités supplémentaires à votre application ExpressJS. Ces middlewares sont généralement utilisés pour des tâches courantes comme l'analyse du corps des requêtes, la gestion des sessions, la sécurisation des routes, etc.
Exemple avec morgan : morgan est un middleware tiers qui permet de journaliser toutes les requêtes HTTP.
Installation :
npm install --save morgan
Utilisation :
var morgan = require('morgan');
app.use(morgan('dev'));
Le middleware morgan enregistre toutes les requêtes HTTP avec un format de log pratique (mode "dev").
ExpressJS fournit plusieurs middlewares intégrés pour des tâches courantes telles que l'analyse du corps des requêtes, la gestion des cookies, etc. Voici quelques exemples de middlewares intégrés :
express.json() : Analyse les corps de requêtes JSON.express.static() : Sert des fichiers statiques (par exemple, des images ou des fichiers CSS).Exemple d'utilisation de express.static() :
app.use(express.static('public'));
Ce middleware permet de servir des fichiers statiques depuis un répertoire public.
Dans cet exemple, nous allons créer une application ExpressJS qui utilise plusieurs types de middlewares pour traiter les requêtes de manière complète. Nous utiliserons des middlewares pour gérer les logs des requêtes, l'analyse du corps des requêtes, l'authentification et la gestion des erreurs.
var express = require('express');
var bodyParser = require('body-parser');
var app = express();
// Middleware de log des requêtes
app.use(function(req, res, next) {
console.log("Requête reçue à " + Date.now() + " pour " + req.method + " " + req.url);
next();
});
// Middleware pour analyser les données du corps des requêtes
app.use(bodyParser.json());
// Middleware d'authentification (simple vérification de l'authentification)
app.use('/protected', function(req, res, next) {
if (!req.headers.authorization) {
return res.status(403).send('Accès interdit. Authentification requise.');
}
next();
});
// Route accessible sans authentification
app.get('/', function(req, res) {
res.send('Page d\'accueil - accessible sans authentification');
});
// Route protégée (requiert une authentification)
app.get('/protected', function(req, res) {
res.send('Page protégée - Vous êtes authentifié');
});
// Middleware de gestion des erreurs
app.use(function(err, req, res, next) {
console.error(err.stack);
res.status(500).send('Quelque chose a mal tourné!');
});
app.listen(3000, function() {
console.log('Application Express en écoute sur le port 3000');
});
Dans cet exemple :
body-parser pour analyser les données JSON envoyées dans les requêtes./protected et vérifie si l'en-tête authorization est présent. Si ce n'est pas le cas, un message d'accès interdit est renvoyé.En accédant à localhost:3000, tu verras la page d'accueil accessible sans authentification, tandis que la page /protected nécessitera un en-tête d'authentification.
body-parserCe middleware permet d'analyser les données envoyées dans le corps des requêtes.
Installation :
npm install --save body-parser
Utilisation :
var bodyParser = require('body-parser');
app.use(bodyParser.urlencoded({ extended: false }));
app.use(bodyParser.json());
cookie-parserCe middleware permet de traiter les cookies envoyés par les clients.
Installation :
npm install --save cookie-parser
Utilisation :
var cookieParser = require('cookie-parser');
app.use(cookieParser());
Dans cet exemple, nous allons créer une application ExpressJS qui utilise trois middlewares distincts. Le premier est un middleware de journalisation qui enregistre les détails des requêtes. Le deuxième est un middleware qui vérifie la validité des tokens JWT pour l'authentification. Enfin, nous ajouterons un middleware pour la gestion des erreurs.
var express = require('express');
var jwt = require('jsonwebtoken');
var app = express();
// Clé secrète pour la création et la vérification des JWT
var secretKey = 'maCléSecrète';
// Middleware de journalisation
app.use(function(req, res, next) {
console.log("Requête reçue à " + new Date().toISOString() + " pour " + req.method + " " + req.url);
next();
});
// Middleware de vérification du token JWT
app.use(function(req, res, next) {
// Vérifie si le token JWT est présent dans l'en-tête Authorization
var token = req.headers['authorization'];
if (!token) {
return res.status(401).send('Token JWT manquant');
}
// Vérifie le token JWT
jwt.verify(token, secretKey, function(err, decoded) {
if (err) {
return res.status(403).send('Token invalide');
}
req.user = decoded; // Ajoute l'utilisateur décodé à la requête
next();
});
});
// Route accessible uniquement si le token JWT est valide
app.get('/protected', function(req, res) {
res.send('Accès autorisé à la page protégée ! Bienvenue, ' + req.user.username);
});
// Middleware de gestion des erreurs
app.use(function(err, req, res, next) {
console.error(err.stack);
res.status(500).send('Quelque chose a mal tourné !');
});
app.listen(3000, function() {
console.log('Application Express en écoute sur le port 3000');
});
Dans cet exemple :
Authorization contient un token valide. Si le token est manquant ou invalide, il renvoie un code de statut HTTP approprié (401 Unauthorized ou 403 Forbidden)./protected) est accessible uniquement si le token JWT est valide. Si l'authentification réussit, l'utilisateur est accueilli par un message personnalisé incluant son nom d'utilisateur.Pour tester cette application :
var token = jwt.sign({ username: 'utilisateur1' }, 'maCléSecrète', { expiresIn: '1h' });
Authorization lors de la requête à /protected.Voici une explication détaillée des différents middlewares utilisés dans l'exemple ci-dessus :
Ce middleware enregistre chaque requête en loguant l'heure exacte de la requête, ainsi que la méthode HTTP utilisée et l'URL demandée. Cela peut être utile pour surveiller l'activité de l'application et faciliter le débogage. En utilisant cette information, il est possible de suivre l'enchaînement des requêtes, d'identifier les problèmes de performance ou d'analyser les actions des utilisateurs.
Ce middleware vérifie si le token JWT est présent dans l'en-tête Authorization de la requête. Si le token est manquant, un message d'erreur avec un statut HTTP 401 ("Token JWT manquant") est renvoyé. Si le token est valide, il est décodé à l'aide de la clé secrète définie dans l'application. Les informations de l'utilisateur extraites du token (comme le nom d'utilisateur) sont ajoutées à l'objet req, permettant ainsi un accès facile dans les routes protégées.
La route /protected est protégée par le middleware de vérification du token JWT. Cela signifie que cette route n'est accessible qu'aux utilisateurs ayant un token valide. Si la vérification du token est réussie, un message personnalisé contenant le nom d'utilisateur est renvoyé. Sinon, une erreur 403 ("Token invalide") sera renvoyée.
Le middleware de gestion des erreurs capte toutes les erreurs non gérées qui peuvent survenir dans l'application. Il renvoie une réponse générique avec le statut HTTP 500 ("Quelque chose a mal tourné") et logue l'erreur dans la console pour aider au débogage. Ce middleware est essentiel pour s'assurer que l'application reste stable même en cas d'erreurs internes.
Les middlewares sont un élément clé d'ExpressJS. Ils permettent de gérer efficacement les requêtes avant qu'elles n'atteignent le gestionnaire de routes final. Grâce aux middlewares intégrés et tiers, vous pouvez créer des applications ExpressJS plus puissantes et flexibles.