javascript - headers - Solicitud HTTP GET en Node.js Express
node http get headers (12)
Aquí está el código de una muestra mía. Es asincrónico y devuelve un objeto JSON. Podría hacer cualquier solicitud de obtención. Tenga en cuenta que hay formas más óptimas (solo una muestra), por ejemplo, en lugar de concatenar los fragmentos que pone en una matriz y unirlos, etc. Con suerte, lo ayuda a comenzar en la dirección correcta:
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();
};
Se llama creando objetos de opciones como:
var options = {
host: ''somesite.com'',
port: 443,
path: ''/some/path'',
method: ''GET'',
headers: {
''Content-Type'': ''application/json''
}
};
y proporcionando una función de devolución de llamada.
Por ejemplo, en un servicio, requiero el módulo de descanso anterior y luego hago esto.
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);
});
ACTUALIZAR:
Si está buscando async await (sin retorno de llamada lineal), promesas, soporte de tiempo de compilación e intellisense, creamos un cliente ligero de http y descanso que se ajusta a esa factura:
¿Cómo puedo hacer una solicitud HTTP desde node / express? Necesito conectarme a otro servicio. Espero que la llamada sea asincrónica y que la devolución de llamada contenga la respuesta de los servidores remotos.
Echa un vistazo a httpreq : es una biblioteca de nodos que he creado porque estaba frustrado de que no hubiera un simple módulo http GET o POST ;-)
Echa un vistazo a shred . Es un cliente HTTP de nodo creado y mantenido por spire.io que maneja redirecciones, sesiones y respuestas JSON. Es genial para interactuar con API de descanso. Vea esta publicación en el blog para más detalles.
Esta versión se basa en la función propuesta inicialmente por que utiliza promesas, un mejor manejo de errores y se reescribe en 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, no tiene que pasar una función de devolución de llamada, sino que getJSON () devuelve una promesa. En el siguiente ejemplo, la función se usa dentro de un manejador de ruta 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 caso de error, delega el error en el error del servidor que maneja el middleware.
Intenta usar la función simple http.get(options, callback) en 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);
});
También hay una función general de http.request(options, callback) que le permite especificar el método de solicitud y otros detalles de solicitud.
Mire el módulo de solicitud. Referencia aquí sitepoint.com/making-http-requests-in-node-js
Si solo necesita hacer solicitudes de obtención simples y no necesita soporte para ningún otro método HTTP, eche un vistazo a: 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
});
También puede usar Requestify , un cliente HTTP realmente genial y muy simple que escribí para nodeJS + y que admite el almacenamiento en caché.
Solo haga lo siguiente para solicitar el 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();
}
);
Use reqclient : no diseñado para fines de scripting como request u otras muchas bibliotecas. Reqclient permite en el constructor especificar muchas configuraciones útiles cuando necesita reutilizar la misma configuración una y otra vez: base URL, encabezados, opciones de autenticación, opciones de registro, almacenamiento en caché, etc. También tiene funciones útiles como consulta y análisis de URL, codificación de consulta automática y Análisis JSON, etc.
La mejor forma de usar la biblioteca es crear un módulo para exportar el objeto que apunta a la API y las configuraciones necesarias para conectarse:
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
Y en los controladores donde necesita consumir la API, use así:
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 admite muchas características, pero tiene algunas que no son compatibles con otras bibliotecas: integración OAuth2 e integración de registrador con sintaxis cURL , y siempre devuelve objetos Promise nativos.
Unirest es la mejor biblioteca que he encontrado para hacer solicitudes HTTP desde Node. Su objetivo es ser un marco multiplataforma, por lo que aprender cómo funciona en Node le servirá también si necesita usar un cliente HTTP en Ruby, PHP, Java, Python, Objective C, .Net o Windows 8 también. Por lo que puedo decir, las bibliotecas unirest están principalmente respaldadas por clientes HTTP existentes (por ejemplo, en Java, el cliente Apache HTTP, en Node, Request ) - Unirest solo pone una mejor API en la parte superior.
Aquí hay un par de ejemplos de código para 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)
}
})
Puede ir directamente a los documentos del nodo here
Request and Superagent son bibliotecas muy buenas para usar.
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
});
## 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)=>{
})