Requête HTTP GET dans Node.js Express
Comment puis-je faire une demande HTTP à partir de node/express? Je dois me connecter à un autre service. J'espère que l'appel est asynchrone et que le rappel contient la réponse du serveur distant.
Voici le code d'un échantillon de la mienne. C'est asynchrone et retourne un objet JSON. Il pourrait faire n'importe quelle demande. Notez qu'il existe d'autres moyens optimaux (juste un exemple) - par exemple, au lieu de concaténer les morceaux que vous avez placés dans un tableau et que vous le joignez, etc.
var http = require("http");
var https = require("https");
/**
* getJSON: REST get request returning JSON object(s)
* @param options: http options object
* @param callback: callback to pass the results JSON object(s) back
*/
exports.getJSON = function(options, onResult)
{
console.log("rest::getJSON");
var port = options.port == 443 ? https : http;
var req = port.request(options, function(res)
{
var output = '';
console.log(options.Host + ':' + res.statusCode);
res.setEncoding('utf8');
res.on('data', function (chunk) {
output += chunk;
});
res.on('end', function() {
var obj = JSON.parse(output);
onResult(res.statusCode, obj);
});
});
req.on('error', function(err) {
//res.send('error: ' + err.message);
});
req.end();
};
Cela s’appelle en créant un objet d’options comme:
var options = {
Host: 'somesite.com',
port: 443,
path: '/some/path',
method: 'GET',
headers: {
'Content-Type': 'application/json'
}
};
et fournissant une fonction de rappel.
Par exemple, dans un service, j'ai besoin du module de repos ci-dessus, puis je le fais.
rest.getJSON(options, function(statusCode, result) {
// I could work with the result html/json here. I could also just return it
console.log("onResult: (" + statusCode + ")" + JSON.stringify(result));
res.statusCode = statusCode;
res.send(result);
});
METTRE À JOUR:
Si vous recherchez une attente asynchrone (pas de rappel linéaire), des promesses, une assistance pour la compilation de la compilation et intellisense, nous créons un client http et rest léger qui correspond à cette facture:
Essayez d’utiliser la simple fonction - http.get(options, callback) 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);
});
Il existe également une fonction générale http.request(options, callback) qui vous permet de spécifier la méthode de requête et d’autres détails de la requête.
Request et Superagent sont de très bonnes bibliothèques à utiliser.
Utiliser 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 très simple et très cool que j'ai écrit pour nodeJS +.
Procédez comme 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 je connaisse pour faire des requêtes HTTP à partir de Node. Son objectif est de devenir un framework multiplateforme. Apprendre comment ça marche sur Node vous sera utile si vous devez utiliser un client HTTP sous Ruby, PHP, Java, Python, Objective C, .Net ou Windows 8. Autant que je sache, les bibliothèques unirest sont principalement gérées par des clients HTTP existants (par exemple, sur Java, le client HTTP Apache, sur Node, Mikeal's Request libary ) - Unirest met simplement une API plus agréable au-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 passer directement au Node docs ici
Cette version est basée sur la fonction initialement proposée par bryanmac qui utilise les promesses, améliore la 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 transmettre de fonction de rappel, mais getJSON () renvoie une promesse. Dans l'exemple suivant, la fonction est utilisée à l'intérieur d'un gestionnaire de routage 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, cette erreur est déléguée au middleware de traitement des erreurs du serveur.
Découvrez httpreq : c'est une bibliothèque de noeuds que j'ai créée parce que j'étais frustrée par l'absence d'un simple module http GET ou POST ;-)
Départ Shred . C'est un client HTTP de noeud créé et maintenu par spire.io qui gère les redirections, les sessions et les réponses JSON. C'est parfait pour interagir avec les API de repos. Voir cet article de blog pour plus de détails.
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, consultez: 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
});
Utilisez reqclient : non conçu à des fins de script like request ou de nombreuses autres bibliothèques. Reqclient permet dans le constructeur De spécifier de nombreuses configurations utiles lorsque vous devez 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. requête et analyse d'URL, encodage automatique de requête 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 utiliser 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 il en existe d'autres qui ne sont pas prises en charge par les autres bibliothèques .__: OAuth2 integration et l'intégration de l'enregistreur avec la syntaxe cURL , et renvoie toujours les objets Promise natifs.
Regardez le module de requête. Référence ici http://www.sitepoint.com/making-http-requests-in-node-js/