Melhores 4 Maneiras de Fazer Requisições POST em Node.js

Você quer aprender como fazer requisições POST em Node.js? Se sim, então você está no lugar certo. Neste post do blog, eu vou mostrar como usar o módulo http embutido e a popular biblioteca axios para fazer requisições POST em Node.js. Então, use Apidog para testar requisições POST com interface visual e compartilhá-las com sua equipe.

button

O que é uma requisição HTTP POST em NodeJS?

Uma requisição HTTP POST em Node.js é usada para enviar dados a um servidor para criar ou atualizar um recurso. Requisições POST são comumente usadas ao enviar dados de formulários, fazer upload de arquivos ou enviar dados para serem armazenados em um banco de dados.

Em Node.js, você pode fazer uma requisição POST usando o módulo http embutido ou uma biblioteca de terceiros como Axios. Os dados a serem enviados com a requisição são incluídos no corpo da requisição. O servidor pode acessar e processar esses dados para realizar a ação desejada.

Node.js fornece um modelo de I/O não bloqueante e orientado a eventos que o torna eficiente para lidar com aplicações intensivas em dados e em tempo real. Sua capacidade de lidar com requisições POST e processar dados o torna uma escolha popular para construir APIs web, aplicações de chat em tempo real, e outros tipos de aplicações do lado do servidor.

Como enviar requisição POST em Node.js？

Agora, vamos mostrar várias maneiras de enviar e fazer requisições POST em Node.js, incluindo o Módulo HTTP e a biblioteca Axios. Você pode escolher a abordagem que melhor se adapta aos requisitos e preferências do seu projeto.

1. Enviar requisição POST em Node.js usando o módulo http

Node.js é frequentemente usado para criar servidores web, aplicações web e APIs web. Node.js também fornece um módulo http embutido que permite fazer requisições e respostas HTTP.

Para fazer uma requisição POST em Node.js usando o módulo http, você precisa seguir estas etapas:

Importar o módulo http usando a função require.
Criar um objeto options que contém as informações sobre a requisição POST, como o hostname, porta, caminho, método, cabeçalhos e dados.
Usar o método http.request para criar um objeto de requisição, passando o objeto options como o primeiro argumento e uma função de callback como o segundo argumento. A função de callback será executada quando a resposta for recebida, e terá um objeto response como seu parâmetro.
Usar o objeto request para enviar os dados e encerrar a requisição. O objeto request é uma instância da classe http.ClientRequest, que implementa a interface WritableStream. Isso significa que você pode usar o objeto request como um fluxo de dados, e escrever dados nele usando o método request.write. Você também pode usar o método request.end para sinalizar o final dos dados e da requisição. Você pode também ouvir eventos como error e timeout no objeto request e manipulá-los de acordo.
Usar o objeto response para lidar com os dados e cabeçalhos da resposta. O objeto response é uma instância da classe http.IncomingMessage, que implementa a interface ReadableStream. Isso significa que você pode usar o objeto response como um fluxo de dados, e ouvir eventos como data, end, e error. Você também pode usar a propriedade response.statusCode para obter o código de status da resposta, e a propriedade response.headers para obter os cabeçalhos da resposta.
Usar o método response.on para registrar ouvintes de eventos para o objeto response. Por exemplo, você pode usar o método response.on('data', callback) para ouvir o evento data, que será emitido quando um bloco de dados for recebido. A função de callback terá um objeto chunk como seu parâmetro, que é um buffer de dados. Você pode usar o método chunk.toString() para converter o buffer em uma string, e adicioná-la a uma variável para armazenar todos os dados da resposta. Você também pode usar o método response.on('end', callback) para ouvir o evento end, que será emitido quando a resposta estiver completa. A função de callback não terá parâmetros e você pode usá-la para executar quaisquer ações finais, como registrar ou analisar os dados da resposta. Você também pode usar o método response.on('error', callback) para ouvir o evento error, que será emitido quando um erro ocorrer durante a resposta. A função de callback terá um objeto error como seu parâmetro, e você pode usá-lo para lidar com o erro, como registrar ou lançar.

Aqui está um exemplo de como fazer uma requisição POST em Node.js usando o módulo http:

// Importar o módulo http
const http = require('http');

// Criar um objeto de opções
const options = {
  hostname: 'jsonplaceholder.typicode.com',
  port: 80,
  path: '/posts',
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'User-Agent': 'Node.js'
  }
};

// Criar um objeto de dados
const data = {
  title: 'Olá, mundo!',
  body: 'Este é um post de teste',
  userId: 1
};

// Transformar o objeto de dados em string
const dataString = JSON.stringify(data);

// Atualizar o objeto de opções com o comprimento dos dados
options.headers['Content-Length'] = dataString.length;

// Criar um objeto de requisição
const request = http.request(options, (response) => {
  // Inicializar uma variável para armazenar os dados da resposta
  let data = '';

  // Ouvir o evento de dados
  response.on('data', (chunk) => {
    // Adicionar o bloco à variável de dados
    data += chunk.toString();
  });

  // Ouvir o evento de fim
  response.on('end', () => {
    // Registrar o código de status e os cabeçalhos
    console.log(`Código de status: ${response.statusCode}`);
    console.log(`Cabeçalhos: ${JSON.stringify(response.headers)}`);

    // Analisar os dados como JSON
    const post = JSON.parse(data);

    // Registrar as informações do post
    console.log(`ID do Post: ${post.id}`);
    console.log(`Título do Post: ${post.title}`);
    console.log(`Corpo do Post: ${post.body}`);
    console.log(`ID do Usuário do Post: ${post.userId}`);
  });

  // Ouvir o evento de erro
  response.on('error', (error) => {
    // Lançar o erro
    throw error;
  });
});

// Escrever os dados no objeto de requisição
request.write(dataString);

// Encerrar o objeto de requisição
request.end();

2. Fazer requisições POST em Node.js usando a biblioteca axios

O módulo http é um módulo de baixo nível que fornece funcionalidade básica para fazer requisições e respostas HTTP. No entanto, se você quiser usar um módulo de nível mais alto e mais amigável, você pode usar a biblioteca axios. Axios é uma biblioteca popular e poderosa que permite fazer requisições HTTP e manipular respostas usando promessas e sintaxe async/await. Axios também suporta recursos como interceptadores, transformadores, timeouts, tokens de cancelamento, e mais.

Para fazer uma requisição POST em Node.js usando a biblioteca axios, você precisa seguir estas etapas:

Instalar a biblioteca axios usando o comando npm: npm install axios.
Importar a biblioteca axios usando a função require.
Usar o método axios.post para fazer a requisição POST, passando a URL do recurso como o primeiro argumento e o objeto de dados como o segundo argumento. Você também pode passar um objeto config opcional como o terceiro argumento, que pode conter informações sobre a requisição POST, como cabeçalhos, parâmetros, timeout, e mais. O método axios.post retornará uma promessa, que será resolvida para um objeto response ou rejeitada para um objeto error.
Alternativamente, você pode usar a sintaxe async/await para fazer a requisição POST e manipular a resposta. Para fazer isso, você precisa usar a palavra-chave async antes da função que contém a requisição POST, e a palavra-chave await antes do método axios.post. Isso permitirá que você escreva código assíncrono de maneira síncrona, e atribua o objeto response a uma variável. Você pode então usar o bloco try/catch para lidar com quaisquer erros que possam ocorrer durante a requisição POST.

Aqui está um exemplo de como fazer uma requisição POST em Node.js usando a biblioteca axios:

// Importar a biblioteca axios
const axios = require('axios');

// Criar um objeto de dados
const data = {
  title: 'Olá, mundo!',
  body: 'Este é um post de teste',
  userId: 1
};

// Fazer a requisição POST usando o método then
axios.post('http://jsonplaceholder.typicode.com/posts', data, {
  headers: {
    'Content-Type': 'application/json',
    'User-Agent': 'Node.js'
  }
}).then((response) => {
  // Registrar o código de status e os cabeçalhos
  console.log(`Código de status: ${response.status}`);
  console.log(`Cabeçalhos: ${JSON.stringify(response.headers)}`);

  // Registrar as informações do post
  console.log(`ID do Post: ${response.data.id}`);
  console.log(`Título do Post: ${response.data.title}`);
  console.log(`Corpo do Post: ${response.data.body}`);
  console.log(`ID do Usuário do Post: ${response.data.userId}`);
}).catch((error) => {
  // Registrar a mensagem e o código de erro
  console.log(`Mensagem de erro: ${error.message}`);
  console.log(`Código de erro: ${error.code}`);

  // Registrar o status e os dados da resposta se disponíveis
  if (error.response) {
    console.log(`Status da resposta: ${error.response.status}`);
    console.log(`Dados da resposta: ${JSON.stringify(error.response.data)}`);
  }

  // Registrar o método e o caminho da requisição se disponíveis
  if (error.request) {
    console.log(`Método da requisição: ${error.request.method}`);
    console.log(`Caminho da requisição: ${error.request.path}`);
  }
});

// Fazer a requisição POST usando a sintaxe async/await
async function createPost() {
  try {
    // Aguardar a requisição POST e atribuir o objeto de resposta a uma variável
    const response = await axios.post('http://jsonplaceholder.typicode.com/posts', data, {
      headers: {
        'Content-Type': 'application/json',
        'User-Agent': 'Node.js'
      }
    });

    // Registrar o código de status e os cabeçalhos
    console.log(`Código de status: ${response.status}`);
    console.log(`Cabeçalhos: ${JSON.stringify(response.headers)}`);

    // Registrar as informações do post
    console.log(`ID do Post: ${response.data.id}`);
    console.log(`Título do Post: ${response.data.title}`);
    console.log(`Corpo do Post: ${response.data.body}`);
    console.log(`ID do Usuário do Post: ${response.data.userId}`);
  } catch (error) {
    // Registrar a mensagem e o código de erro
    console.log(`Mensagem de erro: ${error.message}`);
    console.log(`Código de erro: ${error.code}`);

    // Registrar o status e os dados da resposta se disponíveis
    if (error.response) {
      console.log(`Status da resposta: ${error.response.status}`);
      console.log(`Dados da resposta: ${JSON.stringify(error.response.data)}`);
    }

    // Registrar o método e o caminho da requisição se disponíveis
    if (error.request) {
      console.log(`Método da requisição: ${error.request.method}`);
      console.log(`Caminho da requisição: ${error.request.path}`);
    }
  }
}

// Chamar a função createPost
createPost();

3. Enviar e Receber Dados em Node.js

Enviar e receber dados em Node.js envolve algumas etapas chave. Quando você envia uma requisição POST em Node.js, normalmente você quer enviar alguns dados para o servidor web e receber uma resposta. Por exemplo, você pode querer enviar informações do usuário para criar uma nova conta e receber uma mensagem ou token de confirmação. Ou então, você pode enviar dados de um arquivo para fazer upload de um arquivo e receber de volta uma URL do arquivo ou uma mensagem de status.

Para lidar com diferentes tipos de dados, você precisará de diferentes métodos e módulos:

Dados JSON: Se seus dados são um objeto ou array simples, você pode convertê-los para uma string JSON usando JSON.stringify(). Este método cria uma string com pares chave-valor e arrays, facilitando o envio e recebimento de dados. Para trabalhar com respostas JSON, você pode usar JSON.parse() para converter a resposta de volta em um objeto ou array JavaScript.
Dados de Arquivo: Ao lidar com arquivos, você pode usar a biblioteca form-data para criar um objeto de dados de formulário e anexar o arquivo a ele. Esta biblioteca imita o comportamento de um formulário HTML, permitindo que você envie dados de texto e de arquivo. Você precisará instalar a biblioteca form-data com npm e então usá-la para criar e enviar o objeto de dados de formulário.
Streams: Para dados em streaming, você pode usar o módulo stream embutido. Streams permitem que você lide com dados grandes ou contínuos sem carregá-los todos na memória.

Você pode criar streams legíveis, graváveis ou transformadores dependendo das suas necessidades. Streams são úteis para lidar com áudio, vídeo ou dados de rede, e você pode direcionar dados de um stream para outro para processamento ou envio ao servidor.

4. Usando Apidog para Testar Sua Requisição POST em NodeJs

Apidog é uma ferramenta poderosa para testar APIs. Ela permite que você crie e salve requisições de API, organize-as em coleções, e compartilhe-as com sua equipe.

button

Aqui está como você pode usar o Apidog para testar sua requisição POST:

Abra o Apidog e crie uma nova requisição.

2. Defina o método da requisição como POST.

3. Digite a URL do recurso que você deseja atualizar. Adicione quaisquer cabeçalhos ou parâmetros adicionais que você deseja incluir e clique no botão “Enviar” para enviar a requisição.

4. Verifique se a resposta é o que você esperava.

Conclusão

Neste post do blog, eu mostrei como fazer requisições POST em Node.js usando o módulo http e a biblioteca axios. Eu também mostrei como enviar e receber dados em diferentes formatos e cenários. Espero que você tenha aprendido algo útil e tenha gostado de ler este post.

button