Requête HTTP GET dans le nœud.js Express

Essayez d'utiliser la simple http.get(options, callback) la fonction dans le nœud.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);
});

Il y a aussi un général http.request(options, callback) Fonction qui vous permet de spécifier la méthode de requête et d'autres détails de requête.

Demande de et Superagent sont assez bonnes bibliothèques à utiliser.

En utilisant 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
});

Vous pouvez également utiliser Requestify , un client HTTP vraiment cool et très simple que j'ai écrit pour nodeJS + il supporte la mise en cache.

Faites simplement ce qui suit pour la demande de méthode 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();
  }
);

Unirest est la meilleure bibliothèque que j'ai rencontrée pour faire des requêtes HTTP à partir du nœud. Il vise à être un framework multiplateforme, donc apprendre comment cela fonctionne sur Node vous servira bien si vous avez besoin d'utiliser un client HTTP sur Ruby, PHP, Java, Python, Objective C,. Net ou Windows 8 aussi bien. Pour autant que je sache, les bibliothèques unirest sont principalement soutenues par des clients HTTP existants (par exemple sur Java, le client HTTP Apache, sur Node, la bibliothèque de requête de Mikeal ) - Unirest met juste un API plus agréable sur le dessus.

Voici quelques exemples de code pour 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)
    }
  })

Vous pouvez accéder directement aux documents de nœud ici

Découvrez déchiqueter. C'est un client HTTP node créé et maintenu par spire.io {[2] } qui gère les redirections, les sessions et les réponses JSON. C'est génial pour interagir avec les API rest. Voir Cet article de blog pour plus de détails.

Check out httpreq : c'est une bibliothèque de nœuds que j'ai créée parce que j'étais frustré qu'il n'y ait pas de simple module HTTP GET ou POST là-bas; -)

Cette version est basée sur la fonction initialement proposée par bryanmac qui utilise des promesses, une meilleure gestion des erreurs, et est réécrite dans 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();
    });
};

Par conséquent, vous n'avez pas besoin de passer une fonction de rappel, à la place getJSON() renvoie une promesse. Dans l'exemple suivant, la fonction est utilisée dans un gestionnaire de route 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);
    });
});

En cas d'erreur, il délègue l'erreur au middleware de gestion des erreurs du serveur.

Si vous avez juste besoin de faire des requêtes get simples et n'avez pas besoin de support pour d'autres méthodes HTTP, jetez un oeil à: 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
});

Regardez le module de requête. Référence ici http://www.sitepoint.com/making-http-requests-in-node-js/

Use reqclient : non conçu à des fins de script comme request ou beaucoup d'autres bibliothèques. Reqclient permet dans le constructeur spécifiez de nombreuses configurations utiles lorsque vous avez besoin de réutiliser la même configuration encore et encore: URL de base, en-têtes, options d'authentification, options de journalisation, mise en cache, etc. A également des fonctionnalités utiles comme analyse des requêtes et des URL, encodage automatique des requêtes et analyse JSON, etc.

La meilleure façon d'utiliser la bibliothèque est de créer un module pour exporter l'objet pointant vers L'API et les configurations nécessaires pour se connecter avec:

Module 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

Et dans les contrôleurs où vous devez consommer L'API, utilisez comme ceci:

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

reqclient prend en charge de nombreuses fonctionnalités, mais certaines ne sont pas prises en charge par d'autres bibliothèques: intégration OAuth2 et intégration de l'enregistreur avec syntaxe cURL , et renvoie toujours des objets de promesse natifs.

## 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)=>{
})