Comprendre et implémenter un middleware dans Express.js

Express.js est l'un des frameworks les plus populaires pour créer des applications Web avec Node.js. Il facilite la création d'API RESTful et permet de structurer les applications de manière modulaire. L'un des concepts principaux d'Express.js est l'utilisation de middlewares. Dans cet article, nous comprendrons ce qu'est un middleware, comment il fonctionne et comment vous pouvez créer le vôtre.

Que sont les middlewares ?

Les middlewares sont des fonctions qui ont accès à l'objet requête (req), à l'objet réponse (res) et à la fonction next(). Ils peuvent modifier l’objet de requête et/ou de réponse et contrôler le cycle requête-réponse. Un middleware peut faire plusieurs choses, telles que :

• Exécutez n'importe quel code.
• Modifiez la demande et la réponse.
• Fermez le cycle demande-réponse.
• Appelez le prochain middleware de la chaîne.

La signature de base d'un middleware dans Express.js est :

function middleware(req, res, next) {
    // Lógica do middleware
    next(); // Chama o próximo middleware
}

Types de middleware

Dans Express, on peut trouver plusieurs types de middleware :

1. Application Middleware : Ce sont des middlewares qui affectent l'ensemble de l'application ou un ensemble de routes.
2. Route Middleware : Spécifique à une ou plusieurs routes.
3. Middleware intégré : tels que express.json() et express.static(), fournis directement par Express.
4. Middleware tiers : tels que Morgan ou Cors, que vous pouvez installer pour étendre les fonctionnalités d'Express.

Comment fonctionne le middleware ?

Lorsqu'une requête est reçue, elle passe par une "chaîne middleware". Chaque middleware peut traiter la requête et, à la fin de son exécution, décider d'appeler le middleware suivant (à l'aide de la fonction next()) ou de finaliser la réponse.

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

// Middleware global
app.use((req, res, next) => {
    console.log('Request Type:', req.method);
    next();
});

// Middleware específico para a rota /user
app.use('/user', (req, res, next) => {
    console.log('Middleware para /user');
    next();
});

app.get('/user', (req, res) => {
    res.send('Página do Usuário');
});

app.listen(3000, () => {
    console.log('Servidor rodando na porta 3000');
});

Création d'un middleware personnalisé

En plus du middleware fourni par Express ou par des tiers, vous pouvez créer votre propre middleware pour gérer des fonctionnalités spécifiques, telles que l'authentification, la journalisation ou la manipulation de données.

Exemple de middleware d'authentification simple :

function autenticar(req, res, next) {
    const token = req.header('Authorization');
    if (!token) {
        return res.status(401).send('Acesso negado. Token não fornecido.');
    }
    try {
        // Lógica para validar o token
        next(); // Continua para o próximo middleware
    } catch (err) {
        res.status(400).send('Token inválido.');
    }
}

app.use(autenticar); // Aplica o middleware para todas as rotas

Middleware tiers

Express permet également l'utilisation de middleware tiers, qui peuvent être installés via npm. Certains des plus populaires sont :

• Morgan : Pour les journaux HTTP.
• casque : pour des raisons de sécurité, définition d'en-têtes HTTP de protection.
• cors : pour activer CORS (partage de ressources inter-origines).

Installation et utilisation de Morgan :

npm install morgan

const morgan = require('morgan');

// Middleware de log
app.use(morgan('tiny'));

app.get('/', (req, res) => {
    res.send('Hello World');
});

Ordre des middlewares

L'ordre dans lequel vous définissez les middlewares est important, car ils sont exécutés dans l'ordre dans lequel ils sont enregistrés. Par exemple, si vous définissez un middleware d'authentification après une route qui nécessite une authentification, il ne s'exécutera pas pour cette route.

app.use(express.json()); // Middleware para parsear JSON

app.post('/secure-data', autenticar, (req, res) => {
    res.send('Acesso a dados seguros');
});

Finalisation du middleware

Si un middleware n'appelle pas la fonction next(), il interrompra le cycle requête-réponse. Cela peut être utile dans les cas où vous souhaitez finaliser la requête au sein même du middleware, comme lors d'un contrôle d'authentification :

function autenticar(req, res, next) {
    if (!req.header('Authorization')) {
        return res.status(403).send('Não autorizado');
    }
    next();
}

Conclusion

Les middlewares sont un élément essentiel de la création d'applications avec Express.js, permettant une grande flexibilité et modularité. En maîtrisant l'utilisation du middleware, vous serez en mesure de structurer efficacement vos API, en réutilisant le code et en ajoutant des fonctionnalités telles que l'authentification, la sécurité et la manipulation des données de manière simple et évolutive.

Si vous n'utilisez pas déjà un middleware personnalisé dans vos projets, commencez par quelque chose de simple, comme un middleware de journalisation ou d'authentification, et découvrez la modularité et la flexibilité qu'offre Express.js !

---

Vous avez aimé l'article ? N'oubliez pas de partager avec vos collègues développeurs !

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!