Home-theater-designers
Node.js é um runtime JavaScript de código aberto construído no mecanismo v8 do Chrome que permite executar código JavaScript fora de um navegador.
Seu modelo de evento, ecossistema e velocidade tornaram o Node.js um dos tempos de execução mais procurados e usados para aplicativos do lado do servidor.
A maioria dos servidores de API Node.js usa Express ou outra estrutura. No entanto, você também pode criar uma API Node.js simples sem uma estrutura em apenas algumas etapas.
MAKEUSEO VÍDEO DO DIA
Etapa 1: Configurando seu ambiente de desenvolvimento
Crie um diretório de projeto e cd nele executando:
mkdir nodejs-api
cd nodejs-api
A seguir, inicialize npm em seu projeto executando:
npm init -y
Esta API CRUD contará com o uso do MongoDB, um banco de dados NoSQL, e seu popular ODM, o mongoose.
Execute o seguinte comando para instalar mangusto :
npm install mongoose
A seguir, crie um server.js arquivo no diretório raiz do seu projeto e adicione o bloco de código abaixo para criar um servidor:
const http = require("http");
const server = http.createServer((req, res) => {});
server.listen(3000, () => {
console.log(`Server is running`);
});
Este bloco de código importa o módulo http, um módulo Node.js principal. O módulo http permite que o Node.js transfira dados por HTTP. Este módulo contém os métodos necessários para criar um servidor.
Em seguida, ele chama o módulo http criarServidor método que cria e retorna uma instância de um servidor. o criarServidor O método recebe uma função de retorno de chamada com um objeto de solicitação e resposta como parâmetros.
Em seguida, o código chama o ouço método na instância do servidor retornada. Isso permite que o servidor comece a ouvir o tráfego na porta especificada. o ouço O método dispara um retorno de chamada — o segundo argumento — quando é bem-sucedido.
Finalmente, crie dois diretórios chamados rotas e modelos no diretório raiz do seu projeto. o rotas pasta conterá a lógica de roteamento para sua API, enquanto modelo conterá tudo relacionado ao banco de dados.
Etapa 2: conectando seu aplicativo a um banco de dados
Dentro server.js , importar mangusto :
const mongoose = require("mongoose");
Ligar para conectar método em mangusto e passe seu URI do MongoDB como um argumento:
mongoose.connect("MongoDB_URI")
Etapa 3: criar um modelo de API
Crie uma API CRUD para um aplicativo de blog simples. Na tua modelos pasta, crie um blogModel.js arquivo e adicione o seguinte código ao seu arquivo:
const mongoose = require("mongoose");
const blogSchema = mongoose.Schema({
title: {
type: String,
required: [true, "Blog must have a title"],
},
body: {
type: String,
required: [true, "Blog must have a body"],
},
});
module.exports = mongoose.model("Blog", blogSchema);
O bloco de código acima cria um modelo mongoose com duas propriedades e as mapeia para um banco de dados MongoDB.
Ambas as propriedades neste modelo têm um Corda digite com requeridos definido como verdadeiro . As mensagens de erro que acompanham serão exibidas se um corpo de solicitação não contiver nenhuma das propriedades.
A linha final cria e exporta um modelo de mangusto chamando o método modelo método em mangusto. Passe o nome do modelo ( Blogue ) como o primeiro argumento e um esquema ( blogAgenda ) como o segundo argumento.
Etapa 4: implementando o roteamento em seu aplicativo
Sem a ajuda de frameworks como Express , você terá que criar manualmente a lógica para lidar com cada solicitação feita à sua API.
Primeiro, crie um blogRoutes.js arquivo em seu rotas pasta e importe o modelo de blog:
const Blog = require("../models/blogModel");
Em seguida, crie um arquivo assíncrono roteador função, passe req e res como parâmetros e exporte a função:
const router = async function (req, res) {};
module.exports = router;
Esta função conterá toda a sua lógica de roteamento.
Em seguida, você implementará a lógica de roteamento rota por rota.
GET Rotas
Adicione o bloco de código abaixo ao seu roteador função para implementar o PEGUE manipulador de rotas para solicitações feitas a /api/blogs :
// GET: /api/blogs
if (req.url === "/api/blogs" && req.method === "GET") {
// get all blogs
const blogs = await Blog.find();
// set the status code and content-type
res.writeHead(200, { "Content-Type": "application/json" });
// send data
res.end(JSON.stringify(blogs));
}
O bloco de código acima verifica o URL e método propriedades do objeto de solicitação. Em seguida, ele busca todos os blogs do banco de dados por meio do achar método no modelo mangusto ( Blogue ).
A seguir, chama o escrever Cabeçalho método em res , o objeto de resposta. Esse método envia um cabeçalho de resposta com três argumentos: um código de status, uma mensagem de status opcional e cabeçalhos. o 200 código de status representa uma resposta bem-sucedida e o tipo de conteúdo para esta chamada de API é definido como aplicativo/json .
Por fim, feche a solicitação para garantir que o servidor não seja interrompido chamando o fim método em res . A chamada para JSON.stringify converte o blogs objeto para uma string JSON e passando isso para o fim O método retorna como o corpo da resposta.
Adicione o bloco de código abaixo ao seu roteador função para implementar o PEGUE manipulador de rota para um único recurso:
meu computador não reconhece meu telefone
// GET: /api/blogs/:id
if (req.url.match(/\/api\/blogs\/([0-9]+)/) && req.method === "GET") {
try {
// extract id from url
const id = req.url.split("/")[3];
// get blog from DB
const blog = await Blog.findById(id);
if (blog) {
res.writeHead(200, { "Content-Type": "application/json" });
res.end(JSON.stringify(blog));
} else {
throw new Error("Blog does not exist");
}
} catch (error) {
res.writeHead(404, { "Content-Type": "application/json" });
res.end(JSON.stringify({ message: error }));
}
}
Este código usa o Combine método, que recebe uma expressão regex como argumento, para verificar se a url corresponde ao formato: /api/blogs/
A seguir, extraia o Eu iria propriedade do URL string chamando seu dividir método. Este método recebe um padrão como argumento ( / ), divide a string com base no padrão e retorna uma matriz. O terceiro elemento dessa matriz é o Eu iria .
Por fim, recupere o documento com a correspondência Eu iria do seu banco de dados. Se existir, envie um código de resposta de 200 , feche a solicitação e envie o blog recuperado. Se não existir, lance um erro e envie-o como resposta no bloco catch.
Rota POST
Adicione o bloco de código abaixo à função do seu roteador para implementar o PUBLICAR manipulador de rotas:
// POST: /api/blogs/
if (req.url === "/api/blogs" && req.method === "POST") {
try {
let body = "";
// Listen for data event
req.on("data", (chunk) => {
body += chunk.toString();
});
// Listen for end event
req.on("end", async () => {
// Create Blog
let blog = new Blog(JSON.parse(body));
// Save to DB
await blog.save();
res.writeHead(200, { "Content-Type": "application/json" });
res.end(JSON.stringify(blog));
});
} catch (error) {
console.log(error);
}
}
O objeto de solicitação implementa o Node.js ReadableStream interface. Este fluxo emite um dados e um fim evento que lhe dá acesso aos dados do corpo da solicitação.
Esse código escuta o evento de dados e o trata convertendo-o em uma string e concatenando-o ao corpo variável. No fim manipulador de eventos, ele cria um Blogue instância com a string do corpo analisada. Em seguida, ele salva o novo blog, envia o código de status e o cabeçalho de conteúdo e fecha a solicitação.
PUT Rota
Adicione o bloco de código abaixo à função do seu roteador para implementar o COLOCAR manipulador de rotas:
// PUT: /api/blogs/:id
if (req.url.match(/\/api\/blogs\/([0-9]+)/) && req.method === "PUT") {
try {
// extract id from url
const id = req.url.split("/")[3];
let body = "";
req.on("data", (chunk) => {
body += chunk.toString();
});
req.on("end", async () => {
// Find and update document
let updatedBlog = await Blog.findByIdAndUpdate(id, JSON.parse(body), {
new: true,
});
res.writeHead(200, { "Content-Type": "application/json" });
res.end(JSON.stringify(updatedBlog));
});
} catch (error) {
console.log(error);
}
}
O manipulador de solicitação PUT é quase idêntico ao PUBLICAR manipulador de solicitação, exceto que ele extrai o Eu iria propriedade do URL para atualizar o blog relevante.
APAGAR Rota
Adicione o bloco de código abaixo à função do seu roteador para implementar seu EXCLUIR manipulador de rotas:
// DELETE: /api/blogs/:id
if (req.url.match(/\/api\/blogs\/([0-9]+)/) && req.method === "DELETE") {
try {
const id = req.url.split("/")[3];
// Delete blog from DB
await Blog.findByIdAndDelete(id);
res.writeHead(200, { "Content-Type": "application/json" });
res.end(JSON.stringify({ message: "Blog deleted successfully" }));
} catch (error) {
res.writeHead(404, { "Content-Type": "application/json" });
res.end(JSON.stringify({ message: error }));
}
}
Este bloco de código extrai o Eu iria de URL , exclui o documento com a correspondência Eu iria , envia o código de status e os cabeçalhos e fecha a solicitação.
Por fim, importe roteador na tua server.js arquivo e ligue para o seu roteador função, passando req e res como argumentos:
const router = require("./routes/blogRoutes");
const server = http.createServer((req, res) => {
router(req, res);
});
Isso permite que seu servidor intercepte e lide com as solicitações de forma adequada.
Você pode encontrar o projeto concluído neste Repositório do GitHub .
Usando uma estrutura Node.js
Embora seja possível criar uma API da Web manualmente, pode ser uma tarefa difícil. Você precisará ter certeza de que cobriu muitos casos extremos e é melhor que seu código esteja livre de bugs.
Ao longo dos anos, os desenvolvedores construíram estruturas como ExpressJS, NestJS, Fastify, etc., para facilitar muito.