Solicitação HTTP GET no Node.js Express

191

Como posso fazer uma solicitação HTTP no Node.js ou no Express.js? Preciso me conectar a outro serviço. Espero que a chamada seja assíncrona e que o retorno de chamada contenha a resposta do servidor remoto.

Travis Parks
fonte

Respostas:

219

Aqui está um trecho de algum código de uma amostra minha. É assíncrono e retorna um objeto JSON. Pode fazer qualquer forma de solicitação GET.

Observe que existem maneiras mais ótimas (apenas uma amostra) - por exemplo, em vez de concatenar os pedaços que você coloca em uma matriz e junta-se a ela etc ... Esperemos que você comece na direção certa:

const http = require('http');
const https = require('https');

/**
 * getJSON:  RESTful GET request returning JSON object(s)
 * @param options: http options object
 * @param callback: callback to pass the results JSON object(s) back
 */

module.exports.getJSON = (options, onResult) => {
  console.log('rest::getJSON');
  const port = options.port == 443 ? https : http;

  let output = '';

  const req = port.request(options, (res) => {
    console.log(`${options.host} : ${res.statusCode}`);
    res.setEncoding('utf8');

    res.on('data', (chunk) => {
      output += chunk;
    });

    res.on('end', () => {
      let obj = JSON.parse(output);

      onResult(res.statusCode, obj);
    });
  });

  req.on('error', (err) => {
    // res.send('error: ' + err.message);
  });

  req.end();
};

É chamado criando um objeto de opções como:

const options = {
  host: 'somesite.com',
  port: 443,
  path: '/some/path',
  method: 'GET',
  headers: {
    'Content-Type': 'application/json'
  }
};

E fornecendo uma função de retorno de chamada.

Por exemplo, em um serviço, eu preciso do módulo REST acima e faça o seguinte:

rest.getJSON(options, (statusCode, result) => {
  // I could work with the resulting HTML/JSON here. I could also just return it
  console.log(`onResult: (${statusCode})\n\n${JSON.stringify(result)}`);

  res.statusCode = statusCode;

  res.send(result);
});

ATUALIZAR

Se você está procurando async/ await(linear, sem retorno de chamada), promessas, suporte a tempo de compilação e intellisense, criamos um cliente HTTP e REST leve que se encaixa nessa conta:

Microsoft digitou-resto-cliente

bryanmac
fonte
@bryanmac, você pode enviar / adicionar a amostra completa?
StErMi
@bryanmac com sua permissão Eu gostaria de usar este plugin de código que estou construindo atualmente. Não tenho certeza de quando, mas será aberto quando for concluído.
JeffH
3
tente módulo pedido .. É muito mais simples sitepoint.com/making-http-requests-in-node-js
saurshaz
6
yes - o módulo request é simples, mas este é um nível inferior, mostrando o que as bibliotecas, como o módulo request, estão fazendo. Se você precisar de controle de nível inferior ou solicitações http (mostrando o progresso em downloads grandes, etc ...), isso mostra como é feito.
Bryanmac 24/08
1
@KrIsHnA - o nó tem um objeto de querystring: nodejs.org/api/querystring.html e o objeto de URL nodejs.org/docs/latest/api/url.html
bryanmac
100

Tente usar a http.get(options, callback)função simples no node.js:

var http = require('http');
var options = {
  host: 'www.google.com',
  path: '/index.html'
};

var req = http.get(options, function(res) {
  console.log('STATUS: ' + res.statusCode);
  console.log('HEADERS: ' + JSON.stringify(res.headers));

  // Buffer the body entirely for processing as a whole.
  var bodyChunks = [];
  res.on('data', function(chunk) {
    // You can process streamed parts here...
    bodyChunks.push(chunk);
  }).on('end', function() {
    var body = Buffer.concat(bodyChunks);
    console.log('BODY: ' + body);
    // ...and/or process the entire body here.
  })
});

req.on('error', function(e) {
  console.log('ERROR: ' + e.message);
});

Há também uma http.request(options, callback)função geral que permite especificar o método de solicitação e outros detalhes da solicitação.

maerics
fonte
Onde está o conteúdo da resposta do servidor solicitada pelo OP?
Dan Dascalescu
Obrigado pela atualização. Parece que é necessário um manipulador 'final' para concatenar os pedaços. O que equivale basicamente à resposta de @ bryanmac?
Dan Dascalescu
@ DanDascalescu: sim, se você deseja processar o corpo como um todo (o que é provável), provavelmente deseja armazená-lo em buffer e processá-lo 'final'. Também atualizarei minha resposta para garantir a integridade.
maerics
desculpe, não consigo descobrir com que parâmetros o retorno de chamada é chamado ... como posso obter body e onde está a referência para parâmetros e propriedades desses parâmetros.
Muhammad Umer
@maerics Como posso usar esta GETsolicitação se tiver este URL? graph.facebook.com/debug_token? input_token={token-to-inspect} &access_token={app-token-or-admin-token}?
24419 frank17
70

Solicitação e Superagente são boas bibliotecas para usar.

nota: a solicitação foi descontinuada , use por sua conta e risco!

Usando request:

var request=require('request');

request.get('https://someplace',options,function(err,res,body){
  if(err) //TODO: handle err
  if(res.statusCode === 200 ) //etc
  //TODO Do something with response
});
staackuser2
fonte
7
Deveria ser res.statusCode === 200 em segundo se? )
Gleb Dolzikov
1
qual é a variável de opções? basta passar um indefinido? Eu duvido
lxknvlk
32

Você também pode usar o Requestify , um cliente HTTP muito legal e muito simples que escrevi para o nodeJS +, que suporta cache.

Basta fazer o seguinte para a solicitação do método GET:

var requestify = require('requestify');

requestify.get('http://example.com/api/resource')
  .then(function(response) {
      // Get the response body (JSON parsed or jQuery object for XMLs)
      response.getBody();
  }
);
ranm8
fonte
1
"Experimente esta outra ferramenta" não é uma resposta aceitável se o conjunto de ferramentas existente for suficiente.
Grunion Shaftoe
9

Esta versão é baseada na função inicialmente proposta pela bryanmac , que usa promessas, melhor tratamento de erros e é reescrita no ES6.

let http = require("http"),
    https = require("https");

/**
 * getJSON:  REST get request returning JSON object(s)
 * @param options: http options object
 */
exports.getJSON = function(options)
{
    console.log('rest::getJSON');
    let reqHandler = +options.port === 443 ? https : http;

    return new Promise((resolve, reject) => {
        let req = reqHandler.request(options, (res) =>
        {
            let output = '';
            console.log('rest::', options.host + ':' + res.statusCode);
            res.setEncoding('utf8');

            res.on('data', function (chunk) {
                output += chunk;
            });

            res.on('end', () => {
                try {
                    let obj = JSON.parse(output);
                    // console.log('rest::', obj);
                    resolve({
                        statusCode: res.statusCode,
                        data: obj
                    });
                }
                catch(err) {
                    console.error('rest::end', err);
                    reject(err);
                }
            });
        });

        req.on('error', (err) => {
            console.error('rest::request', err);
            reject(err);
        });

        req.end();
    });
};

Como resultado, você não precisa passar em uma função de retorno de chamada, mas getJSON () retorna uma promessa. No exemplo a seguir, a função é usada dentro de um manipulador de rota ExpressJS

router.get('/:id', (req, res, next) => {
    rest.getJSON({
        host: host,
        path: `/posts/${req.params.id}`,
        method: 'GET'
    }).then(({status, data}) => {
        res.json(data);
    }, (error) => {
        next(error);
    });
});

Em caso de erro, ele delega o erro para o erro do servidor que trata do middleware.

maqduni
fonte
1
Sim, este exemplo está mostrando como fazê-lo dentro de uma getdefinição de rota Express , que falta muitas postagens aqui.
Micros
7

O Unirest é a melhor biblioteca que encontrei para fazer solicitações HTTP do Node. Seu objetivo é ser uma estrutura multiplataforma, portanto, aprender como funciona no Node será útil se você precisar usar um cliente HTTP em Ruby, PHP, Java, Python, Objetivo C, .Net ou Windows 8 também. Tanto quanto posso dizer, as bibliotecas unirest são apoiadas principalmente por clientes HTTP existentes (por exemplo, em Java, o cliente HTTP Apache, no Node, a biblioteca Request do Mikeal ) - o Unirest apenas coloca uma API mais agradável no topo.

Aqui estão alguns exemplos de código para o Node.js:

var unirest = require('unirest')

// GET a resource
unirest.get('http://httpbin.org/get')
  .query({'foo': 'bar'})
  .query({'stack': 'overflow'})
  .end(function(res) {
    if (res.error) {
      console.log('GET error', res.error)
    } else {
      console.log('GET response', res.body)
    }
  })

// POST a form with an attached file
unirest.post('http://httpbin.org/post')
  .field('foo', 'bar')
  .field('stack', 'overflow')
  .attach('myfile', 'examples.js')
  .end(function(res) {
    if (res.error) {
      console.log('POST error', res.error)
    } else {
      console.log('POST response', res.body)
    }
  })

Você pode pular diretamente para os documentos do Node aqui

Brian Beckett
fonte
3

Confira o fragmento . É um cliente HTTP de nó criado e mantido pelo spire.io que lida com redirecionamentos, sessões e respostas JSON. É ótimo para interagir com as APIs restantes. Veja esta postagem no blog para mais detalhes.

Jonathan McIntire
fonte
3

Confira o enablepreq : é uma biblioteca de nós que criei porque estava frustrada porque não havia um módulo http GET ou POST simples ;-)

Sam
fonte
0

Se você só precisa fazer solicitações get simples e não precisa de suporte para outros métodos HTTP, consulte: simple-get :

var get = require('simple-get');

get('http://example.com', function (err, res) {
  if (err) throw err;
  console.log(res.statusCode); // 200
  res.pipe(process.stdout); // `res` is a stream
});
benjiman
fonte
0

Use reqclient : não projetado para fins de script como requestou muitas outras bibliotecas. O Reqclient permite que o construtor especifique muitas configurações úteis quando você precisar reutilizar a mesma configuração repetidamente: URL base, cabeçalhos, opções de autenticação, opções de log, armazenamento em cache, etc. Também possui recursos úteis como consulta e análise de URL, codificação automática de consulta e Análise JSON etc.

A melhor maneira de usar a biblioteca é criar um módulo para exportar o objeto apontando para a API e as configurações necessárias para se conectar com:

Módulo client.js:

let RequestClient = require("reqclient").RequestClient

let client = new RequestClient({
  baseUrl: "https://myapp.com/api/v1",
  cache: true,
  auth: {user: "admin", pass: "secret"}
})

module.exports = client

E nos controladores em que você precisa consumir a API, use assim:

let client = require('client')
//let router = ...

router.get('/dashboard', (req, res) => {
  // Simple GET with Promise handling to https://myapp.com/api/v1/reports/clients
  client.get("reports/clients")
    .then(response => {
       console.log("Report for client", response.userId)  // REST responses are parsed as JSON objects
       res.render('clients/dashboard', {title: 'Customer Report', report: response})
    })
    .catch(err => {
      console.error("Ups!", err)
      res.status(400).render('error', {error: err})
    })
})

router.get('/orders', (req, res, next) => {
  // GET with query (https://myapp.com/api/v1/orders?state=open&limit=10)
  client.get({"uri": "orders", "query": {"state": "open", "limit": 10}})
    .then(orders => {
      res.render('clients/orders', {title: 'Customer Orders', orders: orders})
    })
    .catch(err => someErrorHandler(req, res, next))
})

router.delete('/orders', (req, res, next) => {
  // DELETE with params (https://myapp.com/api/v1/orders/1234/A987)
  client.delete({
    "uri": "orders/{client}/{id}",
    "params": {"client": "A987", "id": 1234}
  })
  .then(resp => res.status(204))
  .catch(err => someErrorHandler(req, res, next))
})

reqclientsuporta muitos recursos, mas há alguns que não são suportados por outras bibliotecas: integração do OAuth2 e integração do criador de logs com a sintaxe cURL e sempre retorna objetos nativos do Promise.

Mariano Ruiz
fonte
0

Se você precisar enviar uma GETsolicitação a uma IPe também a Domain(Outras respostas não mencionaram que você pode especificar uma portvariável), você poderá fazer uso desta função:

function getCode(host, port, path, queryString) {
    console.log("(" + host + ":" + port + path + ")" + "Running httpHelper.getCode()")

    // Construct url and query string
    const requestUrl = url.parse(url.format({
        protocol: 'http',
        hostname: host,
        pathname: path,
        port: port,
        query: queryString
    }));

    console.log("(" + host + path + ")" + "Sending GET request")
    // Send request
    console.log(url.format(requestUrl))
    http.get(url.format(requestUrl), (resp) => {
        let data = '';

        // A chunk of data has been received.
        resp.on('data', (chunk) => {
            console.log("GET chunk: " + chunk);
            data += chunk;
        });

        // The whole response has been received. Print out the result.
        resp.on('end', () => {
            console.log("GET end of response: " + data);
        });

    }).on("error", (err) => {
        console.log("GET Error: " + err);
    });
}

Não perca a exigência de módulos na parte superior do seu arquivo:

http = require("http");
url = require('url')

Lembre-se também de que você pode usar o httpsmódulo para se comunicar pela rede segura. então essas duas linhas mudariam:

https = require("https");
...
https.get(url.format(requestUrl), (resp) => { ......
AmiNadimi
fonte
-1
## you can use request module and promise in express to make any request ##
const promise                       = require('promise');
const requestModule                 = require('request');

const curlRequest =(requestOption) =>{
    return new Promise((resolve, reject)=> {
        requestModule(requestOption, (error, response, body) => {
            try {
                if (error) {
                    throw error;
                }
                if (body) {

                    try {
                        body = (body) ? JSON.parse(body) : body;
                        resolve(body);
                    }catch(error){
                        resolve(body);
                    }

                } else {

                    throw new Error('something wrong');
                }
            } catch (error) {

                reject(error);
            }
        })
    })
};

const option = {
    url : uri,
    method : "GET",
    headers : {

    }
};


curlRequest(option).then((data)=>{
}).catch((err)=>{
})
izhar ahmad
fonte
(Como acontece, não vai resolver o problema Este código. Ouvir um pedido , mas a questão é perguntando como enviar um pedido )
Quentin
1
é fixo, você pode experimentá-lo. @Quentin
izhar ahmad 30/01