如何在node.js中发出HTTP POST请求？
如何在node.js中使用数据发出出站HTTP POST请求？
#1楼
如果您使用请求库，这会变得更容易。
var request = require('request');
request.post(
'http://www.yoursite.com/formpage',
{ json: { key: 'value' } },
function (error, response, body) {
if (!error && response.statusCode == 200) {
console.log(body);
}
}
);
除了提供一个很好的语法，它使json请求变得容易，处理oeuth签名（对于twitter等），可以做多部分表单（例如用于上传文件）和流。
要安装请求，请使用命令npm install request
#2楼
我喜欢superagent的简单性（ https://github.com/visionmedia/superagent ）。 节点和浏览器上的API相同。
;(async function() {
var response = await superagent.post('http://127.0.0.1:8125/', {age: 2})
console.log(response)
})
还有node-fetch（ https://www.npmjs.com/package/node-fetch ），它有一个匹配浏览器fetch的API - 但是这需要手动查询字符串编码，不会自动处理内容类型，或任何其他工作superagent。
#3楼
我将Restler和Needle用于生产目的。 它们比原生的httprequest更强大。 可以通过基本认证，特殊标题输入或甚至上传/下载文件进行请求。
至于post / get操作，它们比使用httprequest的原始ajax调用更简单。
needle.post('https://my.app.com/endpoint', {foo:'bar'},
function(err, resp, body){
console.log(body);
});
#4楼
您还可以使用Requestify ，这是我为nodeJS +编写的非常酷且简单的HTTP客户端，它支持缓存。
只需执行以下操作：
var requestify = require('requestify');
requestify.post('http://example.com', {
hello: 'world'
})
.then(function(response) {
// Get the response body (JSON parsed or jQuery object for XMLs)
response.getBody();
});
#5楼
您可以使用请求库。 https://www.npmjs.com/package/request
var request = require('request');
要发布JSON数据：
var myJSONObject = { ... };
request({
url: "http://josiahchoi.com/myjson",
method: "POST",
json: true, // <--Very important!!!
body: myJSONObject
}, function (error, response, body){
console.log(response);
});
要发布xml数据：
var myXMLText = '........... '
request({
url: "http://josiahchoi.com/myjson",
method: "POST",
headers: {
"content-type": "application/xml", // <--Very important!!!
},
body: myXMLText
}, function (error, response, body){
console.log(response);
});
#6楼
发布休息/ JSON请求
我们可以简单地使用请求包并保存我们必须在Json变量中发送的值。
首先通过npm install request --save在控制台中安装require包
var request = require('request');
var options={
'key':'28',
'key1':'value',
'key2':'value'
}
request({
url:"http://dev.api.ean.com/ean-services/rs/hotel/v3/ping?
minorRev="+options.key+
"&cid="+options.key1+
"&apiKey="+options.key2,
method:"POST",
json:true},function(error,response,body){
console.log(body)
}
);
#7楼
对于那些晚年来到这里的人。 现在有各种不同的库可以用最少的编码来实现这一点。 除非你绝对需要控制低级HTTP的东西，否则我更喜欢优雅的轻量级库来处理HTTP请求。
一个这样的图书馆是Unirest
要安装它，请使用npm 。 $ npm install unirest
到了Hello, World! 每个人都习惯的例子。
var unirest = require('unirest');
unirest.post('http://example.com/helloworld')
.header('Accept', 'application/json')
.send({ "Hello": "World!" })
.end(function (response) {
console.log(response.body);
});
额外：
很多人也建议使用请求 [2]
值得注意的是， Unirest幕后使用request库。
Unirest提供直接访问请求对象的方法。
例：
var Request = unirest.get('http://mockbin.com/request');
#8楼
我发现了一个视频，解释了如何实现这一目标： https ： //www.youtube.com/watch？v = nuuw48-u3Yrg
它使用默认的“http”模块以及“querystring”和“stringbuilder”模块。 应用程序从网页中获取两个数字（使用两个文本框），并在提交时返回这两个数字的总和（以及保留文本框中的值）。 这是我在其他地方找到的最好的例子。
var http = require("http");
var qs = require("querystring");
var StringBuilder = require("stringbuilder");
var port = 9000;
function getCalcHtml(req, resp, data) {
var sb = new StringBuilder({ newline: "\r\n" });
sb.appendLine("");
sb.appendLine(" ");
sb.appendLine(" ")
sb.appendLine(" ");
sb.appendLine("");
sb.build(function (err, result) {
resp.write(result);
resp.end();
});
}
function getCalcForm(req, resp, data) {
resp.writeHead(200, { "Content-Type": "text/html" });
getCalcHtml(req, resp, data);
}
function getHome(req, resp) {
resp.writeHead(200, { "Content-Type": "text/html" });
resp.write("Home Want to some calculation? Click here");
resp.end();
}
function get404(req, resp) {
resp.writeHead(404, "Resource Not Found", { "Content-Type": "text/html" });
resp.write("404 404: Resource not found. Go to Home");
resp.end();
}
function get405(req, resp) {
resp.writeHead(405, "Method not supported", { "Content-Type": "text/html" });
resp.write("405 405: Method not supported");
resp.end();
}
http.createServer(function (req, resp) {
switch (req.method) {
case "GET":
if (req.url === "/") {
getHome(req, resp);
}
else if (req.url === "/calc") {
getCalcForm(req, resp);
}
else {
get404(req, resp);
}
break;
case "POST":
if (req.url === "/calc") {
var reqBody = '';
req.on('data', function (data) {
reqBody += data;
if (reqBody.length > 1e7) { //10MB
resp.writeHead(413, 'Request Entity Too Large', { 'Content-Type': 'text/html' });
resp.end('413 413: Request Entity Too Large');
}
});
req.on('end', function () {
var formData = qs.parse(reqBody);
getCalcForm(req, resp, formData);
});
}
else {
get404(req, resp);
}
break;
default:
get405(req, resp);
break;
}
}).listen(port);
#9楼
这是我用来发出请求的最简单方法：使用'request'模块。
安装'request'模块的命令：
$ npm install request
示例代码：
var request = require('request')
var options = {
method: 'post',
body: postData, // Javascript object
json: true, // Use,If you are sending JSON data
url: url,
headers: {
// Specify headers, If any
}
}
request(options, function (err, res, body) {
if (err) {
console.log('Error :', err)
return
}
console.log(' Body :', body)
});
您还可以使用Node.js的内置“http”模块发出请求。
#10楼
这是我的POST和GET解决方案。
关于Post方法：
如果正文是JSON对象，那么使用JSON.stringify进行反序列化很重要，并可能相应地设置Content-Lenght标头：
var bodyString=JSON.stringify(body)
var _headers = {
'Content-Length': Buffer.byteLength(bodyString)
};
在将其写入请求之前：
request.write( bodyString );
关于Get和Post方法：
timeout可以作为socket断开发生，因此您必须注册其处理程序，如：
request.on('socket', function (socket) {
socket.setTimeout( self.timeout );
socket.on('timeout', function() {
request.abort();
if(timeout) return timeout( new Error('request timed out') );
});
});
而request处理程序是
request.on('timeout', function () {
// Timeout happend. Server received request, but not handled it
// (i.e. doesn't send any response or it took to long).
// You don't know what happend.
// It will emit 'error' message as well (with ECONNRESET code).
req.abort();
if(timeout) return timeout( new Error('request timed out') );
});
我强烈建议注册两个处理程序。
响应主体是分块的，因此您必须在data处理程序中连接块：
var body = '';
response.on('data', function(d) {
body += d;
});
end ， body将包含整个响应主体：
response.on('end', function() {
try {
var jsonResponse=JSON.parse(body);
if(success) return success( jsonResponse );
} catch(ex) { // bad json
if(error) return error(ex.toString());
}
});
它是安全与包装try ...赶上the JSON.parse`因为你不能确保它实际上是一个格式良好的JSON，也没有办法，以确保它在你请求的时间。
模块： SimpleAPI
/**
* Simple POST and GET
* @author Loreto Parisi (loretoparisi at gmail dot com)
*/
(function() {
var SimpleAPI;
SimpleAPI = (function() {
var qs = require('querystring');
/**
* API Object model
* @author Loreto Parisi (loretoparisi at gmail dot com)
*/
function SimpleAPI(host,port,timeout,ssl,debug,json) {
this.host=host;
this.port=port;
this.timeout=timeout;
/** true to use ssl - defaults to true */
this.ssl=ssl || true;
/** true to console log */
this.debug=debug;
/** true to parse response as json - defaults to true */
this.json= (typeof(json)!='undefined')?json:true;
this.requestUrl='';
if(ssl) { // use ssl
this.http = require('https');
} else { // go unsafe, debug only please
this.http = require('http');
}
}
/**
* HTTP GET
* @author Loreto Parisi (loretoparisi at gmail dot com)
*/
SimpleAPI.prototype.Get = function(path, headers, params, success, error, timeout) {
var self=this;
if(params) {
var queryString=qs.stringify(params);
if( queryString ) {
path+="?"+queryString;
}
}
var options = {
headers : headers,
hostname: this.host,
path: path,
method: 'GET'
};
if(this.port && this.port!='80') { // port only if ! 80
options['port']=this.port;
}
if(self.debug) {
console.log( "SimpleAPI.Get", headers, params, options );
}
var request=this.http.get(options, function(response) {
if(self.debug) { // debug
console.log( JSON.stringify(response.headers) );
}
// Continuously update stream with data
var body = '';
response.on('data', function(d) {
body += d;
});
response.on('end', function() {
try {
if(self.json) {
var jsonResponse=JSON.parse(body);
if(success) return success( jsonResponse );
}
else {
if(success) return success( body );
}
} catch(ex) { // bad json
if(error) return error( ex.toString() );
}
});
});
request.on('socket', function (socket) {
socket.setTimeout( self.timeout );
socket.on('timeout', function() {
request.abort();
if(timeout) return timeout( new Error('request timed out') );
});
});
request.on('error', function (e) {
// General error, i.e.
// - ECONNRESET - server closed the socket unexpectedly
// - ECONNREFUSED - server did not listen
// - HPE_INVALID_VERSION
// - HPE_INVALID_STATUS
// - ... (other HPE_* codes) - server returned garbage
console.log(e);
if(error) return error(e);
});
request.on('timeout', function () {
// Timeout happend. Server received request, but not handled it
// (i.e. doesn't send any response or it took to long).
// You don't know what happend.
// It will emit 'error' message as well (with ECONNRESET code).
req.abort();
if(timeout) return timeout( new Error('request timed out') );
});
self.requestUrl = (this.ssl?'https':'http') + '://' + request._headers['host'] + request.path;
if(self.debug) {
console.log("SimpleAPI.Post",self.requestUrl);
}
request.end();
} //RequestGet
/**
* HTTP POST
* @author Loreto Parisi (loretoparisi at gmail dot com)
*/
SimpleAPI.prototype.Post = function(path, headers, params, body, success, error, timeout) {
var self=this;
if(params) {
var queryString=qs.stringify(params);
if( queryString ) {
path+="?"+queryString;
}
}
var bodyString=JSON.stringify(body)
var _headers = {
'Content-Length': Buffer.byteLength(bodyString)
};
for (var attrname in headers) { _headers[attrname] = headers[attrname]; }
var options = {
headers : _headers,
hostname: this.host,
path: path,
method: 'POST',
qs : qs.stringify(params)
};
if(this.port && this.port!='80') { // port only if ! 80
options['port']=this.port;
}
if(self.debug) {
console.log( "SimpleAPI.Post\n%s\n%s", JSON.stringify(_headers,null,2), JSON.stringify(options,null,2) );
}
if(self.debug) {
console.log("SimpleAPI.Post body\n%s", JSON.stringify(body,null,2) );
}
var request=this.http.request(options, function(response) {
if(self.debug) { // debug
console.log( JSON.stringify(response.headers) );
}
// Continuously update stream with data
var body = '';
response.on('data', function(d) {
body += d;
});
response.on('end', function() {
try {
console.log("END", body);
var jsonResponse=JSON.parse(body);
if(success) return success( jsonResponse );
} catch(ex) { // bad json
if(error) return error(ex.toString());
}
});
});
request.on('socket', function (socket) {
socket.setTimeout( self.timeout );
socket.on('timeout', function() {
request.abort();
if(timeout) return timeout( new Error('request timed out') );
});
});
request.on('error', function (e) {
// General error, i.e.
// - ECONNRESET - server closed the socket unexpectedly
// - ECONNREFUSED - server did not listen
// - HPE_INVALID_VERSION
// - HPE_INVALID_STATUS
// - ... (other HPE_* codes) - server returned garbage
console.log(e);
if(error) return error(e);
});
request.on('timeout', function () {
// Timeout happend. Server received request, but not handled it
// (i.e. doesn't send any response or it took to long).
// You don't know what happend.
// It will emit 'error' message as well (with ECONNRESET code).
req.abort();
if(timeout) return timeout( new Error('request timed out') );
});
self.requestUrl = (this.ssl?'https':'http') + '://' + request._headers['host'] + request.path;
if(self.debug) {
console.log("SimpleAPI.Post",self.requestUrl);
}
request.write( bodyString );
request.end();
} //RequestPost
return SimpleAPI;
})();
module.exports = SimpleAPI
}).call(this);
用法：
// Parameters
// domain: example.com
// ssl:true, port:80
// timeout: 30 secs
// debug: true
// json response:true
var api = new SimpleAPI('posttestserver.com', 80, 1000 * 10, true, true, true);
var headers = {
'Content-Type' : 'application/json',
'Accept' : 'application/json'
};
var params = {
"dir" : "post-test"
};
var method = 'post.php';
api.Post(method, headers, params, body
, function(response) { // success
console.log( response );
}
, function(error) { // error
console.log( error.toString() );
}
, function(error) { // timeout
console.log( new Error('timeout error') );
});
#11楼
var https = require('https');
/**
* HOW TO Make an HTTP Call - POST
*/
// do a POST request
// create the JSON object
jsonObject = JSON.stringify({
"message" : "The web of things is approaching, let do some tests to be ready!",
"name" : "Test message posted with node.js",
"caption" : "Some tests with node.js",
"link" : "http://www.youscada.com",
"description" : "this is a description",
"picture" : "http://youscada.com/wp-content/uploads/2012/05/logo2.png",
"actions" : [ {
"name" : "youSCADA",
"link" : "http://www.youscada.com"
} ]
});
// prepare the header
var postheaders = {
'Content-Type' : 'application/json',
'Content-Length' : Buffer.byteLength(jsonObject, 'utf8')
};
// the post options
var optionspost = {
host : 'graph.facebook.com',
port : 443,
path : '/youscada/feed?access_token=your_api_key',
method : 'POST',
headers : postheaders
};
console.info('Options prepared:');
console.info(optionspost);
console.info('Do the POST call');
// do the POST call
var reqPost = https.request(optionspost, function(res) {
console.log("statusCode: ", res.statusCode);
// uncomment it for header details
// console.log("headers: ", res.headers);
res.on('data', function(d) {
console.info('POST result:\n');
process.stdout.write(d);
console.info('\n\nPOST completed');
});
});
// write the json data
reqPost.write(jsonObject);
reqPost.end();
reqPost.on('error', function(e) {
console.error(e);
});
#12楼
在创建一个低级实用程序来处理帖子并获得我的项目请求之后经过很多努力之后，我决定在这里发布我的努力。 就接受的答案而言，这里有一个用于发送http和https POST请求以发送JSON数据的片段。
const http = require("http")
const https = require("https")
// Request handler function
let postJSON = (options, postData, callback) => {
// Serializing JSON
post_data = JSON.stringify(postData)
let port = options.port == 443 ? https : http
// Callback function for the request
let req = port.request(options, (res) => {
let output = ''
res.setEncoding('utf8')
// Listener to receive data
res.on('data', (chunk) => {
output += chunk
});
// Listener for intializing callback after receiving complete response
res.on('end', () => {
let obj = JSON.parse(output)
callback(res.statusCode, obj)
});
});
// Handle any errors occurred while making request
req.on('error', (err) => {
//res.send('error: ' + err.message)
});
// Request is made here, with data as string or buffer
req.write(post_data)
// Ending the request
req.end()
};
let callPost = () => {
let data = {
'name': 'Jon',
'message': 'hello, world'
}
let options = {
host: 'domain.name', // Your domain name
port: 443, // 443 for https and 80 for http
path: '/path/to/resource', // Path for the request
method: 'POST',
headers: {
'Content-Type': 'application/json',
'Content-Length': Buffer.byteLength(data)
}
}
postJSON(options, data, (statusCode, result) => {
// Handle response
// Process the received data
});
}
#13楼
如果您正在寻找基于承诺的HTTP请求， 那么axios可以很好地完成它的工作。
const axios = require('axios');
axios.post('/user', {firstName: 'Fred',lastName: 'Flintstone'})
.then((response) => console.log(response))
.catch((error) => console.log(error));
要么
await axios.post('/user', {firstName: 'Fred',lastName: 'Flintstone'})
#14楼
发布使用其他配置选项和自定义标头的axios.post请求的另一个axios示例。
var postData = { email: "[email protected]", password: "password" }; let axiosConfig = { headers: { 'Content-Type': 'application/json;charset=UTF-8', "Access-Control-Allow-Origin": "*", } }; axios.post('http://:/', postData, axiosConfig) .then((res) => { console.log("RESPONSE RECEIVED: ", res); }) .catch((err) => { console.log("AXIOS ERROR: ", err); })
#15楼
通过使用请求依赖。
简单方案：
import request from 'request'
var data = {
"host":"127.1.1.1",
"port":9008
}
request.post( baseUrl + '/peers/connect',
{
json: data, // your payload data placed here
headers: {
'X-Api-Key': 'dajzmj6gfuzmbfnhamsbuxivc', // if authentication needed
'Content-Type': 'application/json'
}
}, function (error, response, body) {
if (error) {
callback(error, null)
} else {
callback(error, response.body)
}
});
#16楼
简单且无依赖性。 使用Promise以便等待结果。 它返回响应主体，不检查响应状态代码。
const https = require('https');
function httpsPost({body, ...options}) {
return new Promise((resolve,reject) => {
const req = https.request({
method: 'POST',
...options,
}, res => {
const chunks = [];
res.on('data', data => chunks.push(data))
res.on('end', () => {
let body = Buffer.concat(chunks);
switch(res.headers['content-type']) {
case 'application/json':
body = JSON.parse(body);
break;
}
resolve(body)
})
})
req.on('error',reject);
if(body) {
req.write(body);
}
req.end();
})
}
用法：
const res = await httpsPost({
hostname: 'sentry.io',
path: `/api/0/organizations/org/releases/${changesetId}/deploys/`,
headers: {
'Authorization': `Bearer ${process.env.SENTRY_AUTH_TOKEN}`,
'Content-Type': 'application/json',
},
body: JSON.stringify({
environment: isLive ? 'production' : 'demo',
})
})
#17楼
let request = require('request');
let jsonObj = {};
request({
url: "https://myapii.com/sendJsonData",
method: "POST",
json: true,
body: jsonObj
}, function (error, resp, body){
console.log(resp);
});
或者你可以使用这个库：
let axios = require("axios");
let jsonObj = {};
const myJsonAPI = axios.create({
baseURL: 'https://myapii.com',
timeout: 120*1000
});
let response = await myJsonAPI.post("sendJsonData",jsonobj).catch(e=>{
res.json(e);
});
console.log(response);
#18楼
Request-Promise提供基于承诺的响应。 除2xx之外的http响应代码将导致承诺被拒绝。 这可以通过设置options.simple = false来覆盖
var options = {
method: 'POST',
uri: 'http://api.posttestserver.com/post',
body: {
some: 'payload'
},
json: true // Automatically stringifies the body to JSON
};
rp(options)
.then(function (parsedBody) {
// POST succeeded...
})
.catch(function (err) {
// POST failed...
});
#19楼
以下是使用node.js向Google Compiler API发出POST请求的示例：
// We need this to build our post string
var querystring = require('querystring');
var http = require('http');
var fs = require('fs');
function PostCode(codestring) {
// Build the post string from an object
var post_data = querystring.stringify({
'compilation_level' : 'ADVANCED_OPTIMIZATIONS',
'output_format': 'json',
'output_info': 'compiled_code',
'warning_level' : 'QUIET',
'js_code' : codestring
});
// An object of options to indicate where to post to
var post_options = {
host: 'closure-compiler.appspot.com',
port: '80',
path: '/compile',
method: 'POST',
headers: {
'Content-Type': 'application/x-www-form-urlencoded',
'Content-Length': Buffer.byteLength(post_data)
}
};
// Set up the request
var post_req = http.request(post_options, function(res) {
res.setEncoding('utf8');
res.on('data', function (chunk) {
console.log('Response: ' + chunk);
});
});
// post the data
post_req.write(post_data);
post_req.end();
}
// This is an async file read
fs.readFile('LinkedList.js', 'utf-8', function (err, data) {
if (err) {
// If this were just a small part of the application, you would
// want to handle this differently, maybe throwing an exception
// for the caller to handle. Since the file is absolutely essential
// to the program's functionality, we're going to exit with a fatal
// error instead.
console.log("FATAL An error occurred trying to read in the file: " + err);
process.exit(-2);
}
// Make sure there's data before we post it
if(data) {
PostCode(data);
}
else {
console.log("No data to post");
process.exit(-1);
}
});
我已更新代码以显示如何从文件发布数据，而不是硬编码字符串。 它使用async fs.readFile命令来实现这一点，在成功读取后发布实际代码。 如果出现错误，则抛出错误，如果没有数据，则进程以负值退出以指示失败。