Middlewares

O que são Middlewares em Express.js?

Middlewares no Express.js são funções que atuam no ciclo de pedido e resposta das aplicações web. Essas funções recebem três parâmetros principais: o objeto do pedido (req), o objeto de resposta (res) e a função next(). O middleware pode executar qualquer código, modificar os objetos req e res, encerrar a resposta ou passar o controle para o próximo middleware chamando next().

Na prática, middlewares funcionam como etapas intermediárias que processam o pedido HTTP desde o momento em que ele chega até o momento em que a resposta é enviada para o cliente. Eles são essenciais para adicionar funcionalidades modulares, como autenticação, logging, manipulação de erros e muito mais, permitindo manter o código organizado e reutilizável.

Tipos de Middlewares

  • Middleware de Aplicação: Aplicado a todas ou várias rotas da aplicação. Exemplo: app.use().
  • Middleware de Rota: Específico para uma rota ou grupo de rotas.
  • Middleware Integrado: Fornecido pelo próprio Express (ex: express.json(), express.static()).
  • Middleware de Terceiros: Bibliotecas externas instaladas via npm, como morgan (logging) ou cors (controle de acesso).

Como Funciona o Fluxo de Middlewares?

Quando um pedido chega, o Express passa esse pedido por uma cadeia sequencial de middlewares. Cada middleware pode realizar alguma ação e, para que o processamento continue, deve chamar next(). Se um middleware não chamar next() e não encerrar a resposta, o pedido fica “preso” e não chega na rota final.

Criar Middlewares Customizados no Express.js

Exemplo 1: Middleware Simples de Logging

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

// Middleware que registra o método HTTP e a URL do pedido
function logger(req, res, next) {
    console.log(`[${new Date().toISOString()}] ${req.method} ${req.url}`);
    next(); // Chama o próximo middleware ou rota
}

app.use(logger); // Middleware global para todas as rotas

app.get('/', (req, res) => {
    res.send('Olá, mundo!');
});

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

Esse middleware simplesmente registra no console o tipo de requisição e o caminho acessado, e depois chama next() para continuar o fluxo.

Exemplo 2: Middleware de Autenticação Simples

function autenticar(req, res, next) {
    const token = req.header('Authorization');
    if (!token) {
        return res.status(401).send('Acesso negado. Token não fornecido.');
    }
    // Aqui você poderia validar o token (ex: JWT)
    try {
        // Suponha que a validação do token foi feita aqui
        next(); // Continua para a próxima etapa
    } catch (erro) {
        res.status(400).send('Token inválido.');
    }
}

app.use('/protegido', autenticar);

app.get('/protegido', (req, res) => {
    res.send('Conteúdo protegido acessado com sucesso.');
});

Esse middleware verifica se o cabeçalho Authorization está presente e, caso negativo, encerra a requisição com erro 401. Caso esteja presente, o fluxo continua.

Exemplo 3: Middleware para Adicionar Informação ao Pedido

function addRequestTime(req, res, next) {
    req.requestTime = Date.now();
    next();
}

app.use(addRequestTime);

app.get('/time', (req, res) => {
    res.send(`Hora da requisição: ${new Date(req.requestTime).toLocaleString()}`);
});

Esse middleware adiciona uma propriedade requestTime ao objeto req para ser usada nas rotas seguintes.

Como Usar Middlewares em Rotas Específicas?

Você pode aplicar middlewares apenas em rotas específicas passando-os como primeiro parâmetro:

app.get('/rota', middlewareExemplo, (req, res) => {
    res.send('Rota com middleware específico');
});

Resumo e Dicas

  • Middlewares são blocos de código que processam requisições e respostas em Express.js.
  • Podem executar ações como logging, autenticação, manipulação de dados.
  • Sempre chame next() ao final do middleware para que o processamento continue, a menos que queira finalizar a resposta.
  • São configuráveis globalmente (app.use()) ou para rotas específicas.
  • Use middlewares para separar responsabilidades e deixar o código mais organizado e modular.

Essa estrutura básica já permite criar middlewares poderosos para qualquer aplicação Express.js, facilitando a manutenção e a adição de funcionalidades rapidamente.