Entendendo e escrevendo middlewares no NodeJs com Express!
Tags: node, javascript, express
Published: 2019-07-30 18:40:29

Assim que começamos a estudar NodeJs com Express, um dos primeiros termos que ouvimos falar são os `Middlewares`, como o próprio site do express já diz: 

`O Express é uma estrutura web de roteamento e middlewares que tem uma funcionalidade mínima por si só: Um aplicativo do Express é essencialmente uma série de chamadas de funções de middleware.`

Mas afinal, o que são os middlewares?

![](https://thepracticaldev.s3.amazonaws.com/i/ioc6haypf5xutxtip02e.jpg)

Os middlewares são funções que tem acesso a requisição, a resposta e ao próximo middleware. Como podemos ver acima, os middlewares são de certa forma ligados um com os outros e assim que um deles é executado, o próximo é chamado e assim consecutivamente até a chegada do ultimo middleware onde é encerrado o ciclo de solicitação-resposta.

Para exemplificar melhor, vamos criar uma aplicação bem simples de Hello World. Primeiro, entre em algum terminal e digite os seguintes codigos:

```
// Cria um diretório chamado hello-world
mkdir hello-world

// Entra no diretório recém criado
cd hello-world

// Cria o arquivo package.json
npm init -y

// Instala o Express
npm install express
```

Crie um arquivo chamado `index.js` e insira o seguinte código nele:

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

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

app.listen(3000, function() {
    console.log('Servidor online na porta 3000.');
})
```

Rodando o comando `node index.js` no terminal e entrando em http://localhost:3000/ em qualquer navegador já vamos ver a aplicação rodando.

Se voltarmos ao código vamos perceber uma função que recebe como parâmetros um `req`(request ou requisição) e um `res`(response ou resposta), essa função é encarregada de verificar que o usuário entrou na rota passada (nesse caso, a rota raiz '/') e retornar uma resposta contendo o "Hello World!" para ele.

Essa função é um middleware, mais especificamente, é o middleware em que se encerra o ciclo de solicitação-resposta. Ou seja, em uma cadeia de middlewares como a imagem demostra essa função seria a ultima delas, para ficar mais fácil de entender, vamos chama-lo de `middleware final`.

### Corpo de um middleware:

```javascript
app.use(function(req, res, next) {
    // Logic

    next();
})
```

assim como no middleware final esse também recebe os mesmos parâmetros req e res, porém, esse também recebe um parâmetro chamado next que é responsável por chamar o próximo middleware, e como no middleware final não existia um próximo, podemos ocuta-lo dessa função. Em todos os middlewares os parametros req e res são os mesmos, dessa forma, podemos editar esse conteúdo para as próximas funções da cadeia, por exemplo:

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

app.use(function(req, res, next) {
    console.log('Tudo certo no primeiro middleware, chamando o proximo...');

    next();
})

app.use(function(req, res, next) {
    console.log('Adicionando informaçoes a requisição e chamando proximo middleware...');

    req['name'] = "Daniel";

    next();
})

app.get('/', function(req, res) {
    return res.send('Hello world, ' + req.name);
})

app.listen(3000, function() {
    console.log('Servidor online na porta 3000.');
})
```

Rodando esse script e entrando em http://localhost:3000/, o resultado será `Hello world, Daniel` e no console, vamos poder ver as mensagens, em sequencia, descritas em cada middlewares, isso por que:

1. O usuário acessou a rota '/' e cai na cadeia de middlewares;
2. O primeiro middleware é chamado, mostra uma mensagem no console e chama o próximo;
3. O segundo middleware é chamado, ele adiciona a propriedade `name` ao objeto `req`, e chama o próximo middleware;
4. Retorna uma mensagem escrita `Hello world, ` + o nome adicionado a propriedade `name` no middleware anterior, e encerra o ciclo de solicitação-resposta.

### Exemplo de uso

Um dos exemplos mais comuns para o uso de middlewares são os de autenticação, em que você cria um middleware para interceptar a solicitação, ver se o usuário esta logado ou não e tomar uma decisão com isso.

Pacotes como [bodyParser](https://www.npmjs.com/package/body-parser) e [multer](https://github.com/expressjs/multer) também são middlewares.