Como configurar um servidor de API Express em Node.js
No tutorial anterior, aprendemos o que é a arquitetura REST, as seis restrições orientadoras do REST, como entender os métodos de solicitação HTTP e seus códigos de resposta e a anatomia de um endpoint de API RESTful.
Neste tutorial, vamos configurar um servidor para nossa API funcionar. Você pode criar uma API com qualquer linguagem de programação e software de servidor, mas usaremos o Node.js, que é a implementação de back-end do JavaScript, e o Express, uma estrutura mínima popular para Node.
Instalação
Nosso primeiro pré-requisito é garantir que o Node.js e o npm estejam instalados globalmente no computador. Podemos testar ambos usando o -v flag, que exibirá a versão. Abra seu prompt de comando e digite o seguinte.
node -v && npm -v
v10.8.0 6.2.0
Suas versões podem ser um pouco diferentes das minhas, mas desde que ambas estejam lá, podemos começar.
Vamos criar um diretório de projeto chamado express-api e mova-se para ele.
mkdir express-api && cd express-api
Agora que estamos em nosso novo diretório, podemos inicializar nosso projeto com o comando init.
npm init
Este comando solicitará que você responda a algumas perguntas sobre o projeto, que você pode optar por preencher ou não. Quando a configuração estiver concluída, você terá um pacote.json arquivo que se parece com isso:
{
"name": "express-api",
"version": "1.0.0",
"description": "Node.js and Express REST API",
"main": "index.js",
"scripts": {
"test": "echo "Error: no test specified" && exit 1"
},
"author": "Tania Rascia",
"license": "MIT"
}
Agora que temos nosso pacote.json, podemos instalar as dependências necessárias para nosso projeto. Felizmente, não exigimos muitas dependências, apenas essas quatro listadas abaixo.
-
body-parser: middleware de análise de corpo.
-
express: Um framework web minimalista que usaremos para nosso servidor.
-
mysql: Um driver MySQL.
-
request (opcional): Uma maneira simples de fazer chamadas HTTP.
Nós vamos usar o install comando seguido por cada dependência para terminar de configurar nosso projeto.
npm install body-parser express mysql request
Isso criará um pacote-lock.json arquivo e um node_modules diretório e nosso pacote.json será atualizado para ficar assim:
{
"name": "express-api",
"version": "1.0.0",
"description": "Node.js and Express REST API",
"main": "index.js",
"scripts": {
"test": "echo "Error: no test specified" && exit 1"
},
"author": "Tania Rascia",
"license": "MIT",
"dependencies": {
"dependencies": {
"body-parser": "^1.18.3",
"express": "^4.16.3",
"mysql": "^2.16.0",
"request": "^2.88.0"
}
}
Configurando um servidor HTTP
Antes de começarmos a configurar um servidor Express, configuraremos rapidamente um servidor HTTP com o recurso interno do Node http módulo, para ter uma ideia de como funciona um servidor simples.
Crie um arquivo chamado hello-server.js. Carregue no http módulo, defina um número de porta (eu escolhi 3001), e crie o servidor com o createServer() método.
// Build a server with Node's HTTP module
const http = require('http');
const port = 3001;
const server = http.createServer();
No artigo introdutório do REST, discutimos o que são solicitações e respostas em relação a um servidor HTTP. Vamos configurar nosso servidor para lidar com uma solicitação e exibir a URL solicitada no lado do servidor e exibir um Olá, servidor! mensagem para o cliente no lado da resposta.
server.on('request', (request, response) => {
console.log(`URL: ${request.url}`);
response.end('Hello, server!')
})
Por fim, informaremos ao servidor em qual porta escutar e exibiremos um erro, se houver.
// Start the server
server.listen(port, (error) => {
if (error) return console.log(`Error: ${error}`);
console.log(`Server is listening on port ${port}`)
})
Agora, podemos iniciar nosso servidor com node seguido pelo nome do arquivo.
node hello-server.js
Você verá esta resposta no terminal:
Server is listening on port 3001
Para verificar se o servidor está realmente em execução, vá para https://localhost:3001/ na barra de endereços do seu navegador. Se tudo estiver funcionando corretamente, você deverá ver Olá, servidor! na página. No seu terminal, você também verá os URLs que foram solicitados.
URL: / URL: /favicon.ico
Se você navegar para http://localhost:3001/hellovocê veria URL: /hello.
Também podemos usar cURL em nosso servidor local, que nos mostrará os cabeçalhos e o corpo exatos que estão sendo retornados.
curl -i http://localhost:3001
HTTP/1.1 200 OK Date: Wed, 15 Aug 2018 22:14:23 GMT Connection: keep-alive Content-Length: 14 Hello, server!
Se você fechar a janela do terminal a qualquer momento, o servidor desaparecerá.
Agora que temos uma ideia de como o servidor, solicitação e resposta funcionam juntos, podemos reescrever isso no Express, que possui uma interface ainda mais simples e recursos estendidos.
Configurando um servidor expresso
Vamos criar um novo arquivo, app.js, que será o ponto de entrada para o nosso projeto atual. Assim como no servidor http original, precisaremos de um módulo e definiremos uma porta para iniciar.
Criar um app.js arquivo e coloque o seguinte código nele.
// Require packages and set the port
const express = require('express');
const port = 3002;
const app = express();
Agora, em vez de procurar todas as solicitações, declararemos explicitamente que estamos procurando uma GET pedido na raiz do servidor (/). Quando / receber uma solicitação, exibiremos a URL solicitada e a mensagem “Hello, Server!” mensagem.
app.get('/', (request, response) => {
console.log(`URL: ${request.url}`);
response.send('Hello, Server!');
});
Finalmente, iniciaremos o servidor na porta 3002 com o listen() método.
// Start the server
const server = app.listen(port, (error) => {
if (error) return console.log(`Error: ${error}`);
console.log(`Server listening on port ${server.address().port}`);
});
Podemos iniciar o servidor com node app.js como fizemos antes, mas também podemos modificar o scripts propriedade em nosso pacote.json arquivo para executar automaticamente este comando específico.
"scripts": {
"start": "node app.js"
},
Agora podemos usar npm start para iniciar o servidor, e veremos nossa mensagem de servidor no terminal.
Server listening on port 3002
Se executarmos um curl -i no URL, veremos que ele é desenvolvido pelo Express agora e existem alguns cabeçalhos adicionais, como Content-Type.
curl -i http://localhost:3002
HTTP/1.1 200 OK X-Powered-By: Express Content-Type: text/html; charset=utf-8 Content-Length: 14 ETag: W/"e-gaHDsc0MZK+LfDiTM4ruVL4pUqI" Date: Wed, 15 Aug 2018 22:38:45 GMT Connection: keep-alive Hello, Server!
Adicionar middleware de análise de corpo
Para lidar facilmente com POST e PUT solicitações à nossa API, adicionaremos middleware de análise de corpo. É aqui que nosso body-parser módulo entra. body-parser extrairá todo o corpo de uma solicitação recebida e a analisará em um objeto JSON com o qual podemos trabalhar.
Vamos simplesmente exigir o módulo no topo do nosso arquivo. Adicione o seguinte require declaração no topo do seu app.js Arquivo.
const bodyParser = require('body-parser');
...
Em seguida, diremos ao nosso aplicativo Expresso para usar body-parsere procure por JSON.
// Use Node.js body parsing middleware
app.use(bodyParser.json());
app.use(bodyParser.urlencoded({
extended: true,
}));
Além disso, vamos alterar nossa mensagem para enviar um objeto JSON como resposta em vez de texto simples.
response.send({message: 'Node.js and Express REST API'});
Segue nosso completo app.json arquivo como está agora.
// Require packages and set the port
const express = require('express');
const port = 3002;
const bodyParser = require('body-parser');
const app = express();
// Use Node.js body parsing middleware
app.use(bodyParser.json());
app.use(bodyParser.urlencoded({
extended: true,
}));
app.get('/', (request, response) => {
response.send({
message: 'Node.js and Express REST API'}
);
});
// Start the server
const server = app.listen(port, (error) => {
if (error) return console.log(`Error: ${error}`);
console.log(`Server listening on port ${server.address().port}`);
});
Se você enviar um curl -i para o servidor, você verá que o cabeçalho agora retorna Content-Type: application/json; charset=utf-8.
Configurar rotas
Até agora, temos apenas um GET rota para a raiz (/), mas nossa API deve ser capaz de lidar com todos os quatro principais métodos de solicitação HTTP em vários URLs. Vamos configurar um roteador e fazer alguns dados falsos para exibir.
Vamos criar um novo diretório chamado rotase um arquivo dentro chamado route.js. Faremos um link para ele no topo de app.js.
const routes = require('./routes/routes');
Observe que o .js extensão não é necessária no require. Agora vamos mover o nosso aplicativo GET ouvinte de route.js. Digite o seguinte código em route.js.
const router = app => {
app.get('/', (request, response) => {
response.send({
message: 'Node.js and Express REST API'
});
});
}
Por fim, exporte o router para que possamos usá-lo em nosso app.js Arquivo.
// Export the router module.exports = router;
Dentro app.jssubstitua o app.get() código que você tinha antes com uma chamada para routes():
routes(app);
Agora você deve ser capaz de ir para http://localhost:3002 e ver a mesma coisa que antes. (Não se esqueça de reiniciar o servidor!)
Quando tudo estiver configurado e funcionando corretamente, forneceremos alguns dados JSON com outra rota. Usaremos apenas dados falsos por enquanto, pois nosso banco de dados ainda não está configurado.
Vamos criar um users variável em route.jscom alguns dados de usuário falsos no formato JSON.
const users = [{
id: 1,
name: "Richard Hendricks",
email: "[email protected]",
},
{
id: 2,
name: "Bertram Gilfoyle",
email: "[email protected]",
},
];
vamos adicionar outro GET rota para o nosso roteador, /userse enviar os dados do usuário.
app.get('/users', (request, response) => {
response.send(users);
});
Depois de reiniciar o servidor, agora você pode navegar para http://localhost:3002/users e veja todos os nossos dados exibidos.
Observação: se você não tiver uma extensão do visualizador JSON em seu navegador, é altamente recomendável fazer o download de uma, como JSONView for Chrome. Isso tornará os dados muito mais fáceis de ler!
Visite nosso GitHub Repo para ver o código completo para este post e compará-lo com o seu.
Conclusão
Neste tutorial, aprendemos como configurar um servidor HTTP integrado e um servidor Express em node, rotear solicitações e URLs e consumir dados JSON com solicitações get.
Na parte final da série RESTful API, conectaremos nosso servidor Express ao MySQL para criar, visualizar, atualizar e excluir usuários em um banco de dados, finalizando a funcionalidade de nossa API.
[ad_2]
