HTTP-GET-Anfrage in Node.js Express

Wie kann ich innerhalb von Node.js oder Express.js eine HTTP-Anfrage stellen? Ich muss mich mit einem anderen Dienst verbinden. Ich hoffe, dass der Aufruf asynchron ist und dass der Rückruf die Antwort des Remote-Servers enthält.

Hier ist ein Codeausschnitt aus einem Beispiel von mir. Es ist asynchron und gibt ein JSON-Objekt zurück. Es kann jede Form von GET-Anfrage ausführen.

Beachten Sie, dass es optimalere Möglichkeiten gibt (nur ein Beispiel) – zum Beispiel, anstatt die Chunks, die Sie in ein Array einfügen, zu verketten und zu verbinden usw. … Hoffentlich bringt es Sie in die richtige Richtung:

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();
};

Es wird aufgerufen, indem ein Optionsobjekt wie folgt erstellt wird:

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

Und Bereitstellung einer Rückruffunktion.

In einem Dienst benötige ich beispielsweise das obige REST-Modul und mache dann Folgendes:

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

  res.statusCode = statusCode;

  res.send(result);
});

AKTUALISIEREN

Wenn Sie suchen async/await (linear, kein Rückruf), Versprechungen, Kompilierzeitunterstützung und Intellisense haben wir einen leichtgewichtigen HTTP- und REST-Client entwickelt, der dieser Rechnung entspricht:

Microsoft hat „rest-client“ eingegeben

Versuchen Sie es mit dem Einfachen http.get(options, callback) Funktion in 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);
});

Es gibt auch einen General http.request(options, callback) Funktion Damit können Sie die Anforderungsmethode und andere Anforderungsdetails angeben.

Anfrage und Superagent sind ziemlich gute Bibliotheken zu verwenden.

Hinweis: Anfrage ist veraltetBenutzung auf eigene Gefahr!

Verwenden 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
});

Sie können auch verwenden Anfordernein wirklich cooler und sehr einfacher HTTP-Client, den ich für nodeJS geschrieben habe + er unterstützt Caching.

Führen Sie einfach Folgendes für die GET-Methodenanforderung aus:

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();
  }
);

Diese Version basiert auf der ursprünglich von Bryanmac vorgeschlagenen Funktion, die Versprechungen verwendet, eine bessere Fehlerbehandlung bietet und in ES6 neu geschrieben wurde.

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();
    });
};

Als Ergebnis müssen Sie keine Callback-Funktion übergeben, stattdessen gibt getJSON() ein Promise zurück. Im folgenden Beispiel wird die Funktion innerhalb eines ExpressJS-Routenhandlers verwendet

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

Im Fehlerfall delegiert es den Fehler an die Fehlerbehandlungs-Middleware des Servers.

Unirest ist die beste Bibliothek, auf die ich gestoßen bin, um HTTP-Anforderungen von Node. Es zielt darauf ab, ein Multiplattform-Framework zu sein, also wird es Ihnen gut tun, zu lernen, wie es auf Node funktioniert, wenn Sie einen HTTP-Client auch auf Ruby, PHP, Java, Python, Objective C, .Net oder Windows 8 verwenden müssen. Soweit ich das beurteilen kann, werden die unirest-Bibliotheken hauptsächlich von vorhandenen HTTP-Clients unterstützt (z. B. auf Java, dem Apache HTTP-Client, auf Node, Mikeals Request-Bibliothek) – Unirest legt einfach eine schönere API oben drauf.

Hier sind ein paar Codebeispiele für 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)
    }
  })

Sie können direkt zu den Node-Dokumenten springen Hier

Kasse Fetzen. Es ist ein Knoten-HTTP-Client, der von erstellt und verwaltet wird spire.io das Umleitungen, Sitzungen und JSON-Antworten verarbeitet. Es eignet sich hervorragend für die Interaktion mit Rest-APIs. Sehen diesen Blogbeitrag für mehr Details.