As APIs (Interfaces de Programação de Aplicações) são amplamente utilizadas para facilitar a comunicação entre diferentes aplicações de software. Elas desempenham um papel fundamental na escalabilidade e reutilização de código. É comum encontrar aplicativos e serviços web que disponibilizam APIs públicas, permitindo que outros desenvolvedores integrem recursos como login através de redes sociais, pagamentos com cartão de crédito e rastreamento de desempenho.
Neste artigo, iremos explorar a criação de uma API RESTful utilizando o Node.js. O Node.js é um ambiente de tempo de execução de código aberto baseado no mecanismo JavaScript V8 do Google Chrome. Ele oferece um ambiente de execução assíncrona de entrada e saída não bloqueante, o que o torna ideal para o desenvolvimento de aplicações web escaláveis.
- Como criar um site responsivo com CSS Grid: Guia Completo
- Como Criar um Jogo 2D: Tutorial Completo usando Unity! Crie seu primeiro jogo.
- Como criar sua primeira interface web com Bootstrap para iniciantes
Pré-requisitos
Antes de prosseguir com a criação da API RESTful, é importante ter conhecimentos básicos de JavaScript e ter o Node.js instalado no sistema. Certifique-se de ter a versão mais recente do Node.js instalada. Você também precisará ter o MongoDB instalado para que nossa API possa se conectar ao banco de dados.
O que é uma API RESTful?
Uma API RESTful, ou Representational State Transfer API, é baseada no estilo arquitetural REST e é amplamente utilizada no desenvolvimento de serviços web. A tecnologia REST é preferida em relação a outras tecnologias similares devido ao seu baixo consumo de largura de banda, tornando-a mais adequada para o uso eficiente da Internet. As APIs RESTful podem ser criadas utilizando diversas linguagens de programação, como JavaScript ou Python.
O REST é comumente utilizado sobre o protocolo HTTP para a criação de Web APIs. Isso significa que os desenvolvedores não precisam instalar nenhuma biblioteca ou software adicional para utilizar uma API REST. O REST possui a capacidade de lidar com diferentes tipos de chamadas, retornar dados em diferentes formatos e até mesmo alterar sua estrutura por meio da implementação adequada de hiperlinks, pois os dados não estão vinculados a métodos e recursos específicos. Através da flexibilidade proporcionada pelo design da API REST, é possível criar uma API que atenda às suas necessidades e às necessidades de uma ampla gama de clientes.
O que é o Node.js?
O Node.js é um ambiente de tempo de execução de código aberto baseado no mecanismo JavaScript V8 do Google Chrome. Ele oferece um ambiente de execução assíncrona de entrada e saída não bloqueante, permitindo que os desenvolvedores criem aplicações JavaScript de alto desempenho para o lado do servidor. O Node.js pode ser utilizado para criar uma variedade de aplicações, incluindo aplicações de linha de comando, aplicações web, aplicações de chat em tempo real, servidores de API REST, entre outras.
Uma das principais vantagens de utilizar o Node.js para o desenvolvimento de aplicações back-end é a sua capacidade de lidar com um grande número de solicitações simultâneas de forma eficiente. Isso ocorre porque o Node.js utiliza uma arquitetura orientada a eventos e não bloqueante, o que significa que ele é capaz de lidar com várias solicitações de forma assíncrona, sem bloquear a execução de outras partes do código. Além disso, o Node.js utiliza a linguagem JavaScript, que é amplamente conhecida e utilizada por desenvolvedores profissionais.
Criando uma API RESTful com Node.js
Agora que entendemos os conceitos básicos de uma API RESTful e a importância do Node.js no desenvolvimento de aplicações back-end, vamos começar a criar nossa própria API RESTful utilizando o Node.js. Para isso, seguiremos os seguintes passos:
-
Criar os diretórios necessários
-
Criar a API Express básica
-
Criar o módulo de usuário
-
Criar o módulo de autenticação
Passo 1: Criar os diretórios necessários
O primeiro passo para criar nossa API RESTful é criar os diretórios que conterão o código da API. Abra o terminal e navegue até o local onde você costuma criar seus projetos. Em seguida, crie um novo diretório para a nossa API Node.js utilizando o seguinte comando:
mkdir minha-api-node
Agora, entre no diretório que acabamos de criar e execute o seguinte comando para iniciar um novo projeto Node.js:
npm init -y
Isso criará um arquivo chamado package.json, que é utilizado para gerenciar as dependências do nosso projeto.
Em seguida, crie um novo diretório chamado src dentro do diretório raiz do projeto, onde iremos colocar todo o código-fonte da nossa API. Para criar esse diretório, execute o seguinte comando:
mkdir src
O objetivo desse diretório é armazenar todo o código-fonte que será utilizado para criar a nossa API Node.js. Após criar o diretório src, crie um novo arquivo chamado index.js dentro dele, utilizando o seguinte comando:
touch src/index.js
Em seguida, abra o arquivo index.js em um editor de texto de sua preferência e adicione o seguinte código:
// src/index.js
console.log('Olá, mundo!');
Salve o arquivo e execute o seguinte comando para testar o código:
node src/index.js
Ao executar esse comando, você deverá ver a mensagem ‘Olá, mundo!’ impressa no terminal.
Passo 2: Criar a API Express básica
Agora que já criamos a estrutura básica do nosso projeto, vamos começar a criar a API Express básica. A API Express será responsável por lidar com as requisições HTTP recebidas pela nossa aplicação e fornecer as respostas adequadas.
Para começar, vamos instalar as dependências necessárias. Execute o seguinte comando no terminal para instalar as dependências do Express:
npm install express
Em seguida, abra o arquivo src/index.js novamente e substitua o código existente pelo seguinte:
// src/index.js
const express = require('express');
const app = express();
app.get('/', (req, res) => {
res.send('Olá, mundo!');
});
app.listen(3000, () => {
console.log('Servidor rodando na porta 3000');
});
Salve o arquivo e execute o seguinte comando para iniciar o servidor:
node src/index.js
Agora, ao acessar http://localhost:3000 no seu navegador, você deverá ver a mensagem ‘Olá, mundo!’ sendo exibida.
Passo 3: Criar o módulo de usuário
Agora que nossa API Express básica está funcionando, vamos criar o módulo de usuário. O módulo de usuário será responsável por lidar com as operações CRUD (criar, ler, atualizar e deletar) relacionadas aos usuários da nossa aplicação.
Para começar, vamos instalar as dependências necessárias. Execute o seguinte comando no terminal para instalar as dependências do Mongoose:
npm install mongoose
Em seguida, crie um novo diretório chamado users dentro do diretório src, onde iremos colocar todo o código relacionado ao módulo de usuário. Para criar esse diretório, execute o seguinte comando:
mkdir src/users
Dentro do diretório users, crie um novo diretório chamado models, onde iremos armazenar os modelos de dados relacionados aos usuários. Execute o seguinte comando para criar esse diretório:
mkdir src/users/models
Em seguida, crie um novo arquivo chamado user.model.js dentro do diretório models, utilizando o seguinte comando:
touch src/users/models/user.model.js
Abra o arquivo user.model.js em um editor de texto e adicione o seguinte código:
// src/users/models/user.model.js
const mongoose = require('mongoose');
const userSchema = new mongoose.Schema({
firstName: { type: String, required: true },
lastName: { type: String, required: true },
email: { type: String, required: true },
password: { type: String, required: true },
permissionLevel: { type: Number, required: true },
});
const UserModel = mongoose.model('User', userSchema);
module.exports = UserModel;
Esse código define o esquema de dados para o modelo de usuário utilizando o Mongoose. O modelo de usuário é exportado para que possamos utilizá-lo em outros arquivos do nosso projeto.
Em seguida, volte para o diretório users e crie um novo diretório chamado controllers, onde iremos armazenar os controladores relacionados ao módulo de usuário. Execute o seguinte comando para criar esse diretório:
mkdir src/users/controllers
Dentro do diretório controllers, crie um novo arquivo chamado user.controller.js, utilizando o seguinte comando:
touch src/users/controllers/user.controller.js
Abra o arquivo user.controller.js em um editor de texto e adicione o seguinte código:
// src/users/controllers/user.controller.js
const UserModel = require('../models/user.model');
exports.insert = (req, res) => {
const user = new UserModel(req.body);
user.save((err, result) => {
if (err) {
res.status(400).send(err);
} else {
res.status(201).send(result);
}
});
};
exports.get = (req, res) => {
UserModel.find({}, (err, result) => {
if (err) {
res.status(400).send(err);
} else {
res.status(200).send(result);
}
});
};
exports.getById = (req, res) => {
UserModel.findById(req.params.userId, (err, result) => {
if (err) {
res.status(400).send(err);
} else {
res.status(200).send(result);
}
});
};
exports.update = (req, res) => {
UserModel.findByIdAndUpdate(
req.params.userId,
req.body,
{ new: true },
(err, result) => {
if (err) {
res.status(400).send(err);
} else {
res.status(200).send(result);
}
}
);
};
exports.delete = (req, res) => {
UserModel.findByIdAndDelete(req.params.userId, (err, result) => {
if (err) {
res.status(400).send(err);
} else {
res.status(204).send(result);
}
});
};
Esse código define os controladores para as operações CRUD relacionadas ao módulo de usuário. Cada controlador é responsável por lidar com uma operação específica, como inserir um novo usuário, obter todos os usuários, obter um usuário pelo ID, atualizar um usuário e deletar um usuário.
Por fim, volte para o diretório raiz do projeto e abra o arquivo src/index.js. Substitua o código existente pelo seguinte:
// src/index.js
const express = require('express');
const mongoose = require('mongoose');
const userRoutes = require('./users/routes');
const app = express();
app.use(express.json());
app.use('/users', userRoutes);
mongoose.connect('mongodb://localhost:27017/myapp', {
useNewUrlParser: true,
useUnifiedTopology: true,
});
app.listen(3000, () => {
console.log('Servidor rodando na porta 3000');
});
Esse código configura a conexão com o banco de dados MongoDB e define as rotas relacionadas ao módulo de usuário. O app.use(express.json()) permite que nosso aplicativo utilize o formato JSON para enviar e receber dados. As rotas do módulo de usuário são definidas pelo userRoutes, que é um arquivo separado contendo as definições das rotas.
Agora, vamos criar o arquivo src/users/routes.js. Execute o seguinte comando para criar esse arquivo:
touch src/users/routes.js
Abra o arquivo routes.js em um editor de texto e adicione o seguinte código:
// src/users/routes.js
const express = require('express');
const UserController = require('./controllers/user.controller');
const router = express.Router();
router.post('/', UserController.insert);
router.get('/', UserController.get);
router.get('/:userId', UserController.getById);
router.put('/:userId', UserController.update);
router.delete('/:userId', UserController.delete);
module.exports = router;
Esse código define as rotas para o módulo de usuário utilizando o Express Router. Cada rota é associada a uma função do controlador correspondente.
Agora, salve todos os arquivos e execute o seguinte comando para iniciar o servidor:
node src/index.js
Parabéns! Você criou com sucesso uma API RESTful básica utilizando o Node.js. Agora você pode testar as diferentes rotas utilizando ferramentas como o Postman.
Conclusão
Neste artigo, exploramos a criação de uma API RESTful utilizando o Node.js. Vimos como o Node.js pode ser utilizado para criar aplicações back-end escaláveis e como o Express.js simplifica o processo de criação de APIs. Criamos um módulo de usuário com operações CRUD básicas e utilizamos o MongoDB como banco de dados.
Seguindo os passos descritos neste artigo, você pode criar sua própria API RESTful utilizando o Node.js e adaptá-la de acordo com as necessidades do seu projeto. Lembre-se de que este artigo fornece apenas uma introdução básica ao desenvolvimento de APIs RESTful com o Node.js, e há muitos outros recursos e conceitos avançados para explorar. Espero que este artigo tenha sido útil e que você possa aproveitar ao máximo o potencial do Node.js no desenvolvimento de aplicações back-end.