nodejs meminta konkurensi antara muka pihak ketiga

Sebagai bahasa pengaturcaraan tak segerak JavaScript yang terbuka dan fleksibel, keupayaan pemprosesan tugas serentak Node.js yang berkuasa membawa kemungkinan tanpa had kepada pembangun. Terutama apabila meminta API atau antara muka pihak ketiga, kami sering memerlukan permintaan serentak untuk meningkatkan prestasi dan kelajuan tindak balas. Oleh itu, artikel ini akan menumpukan pada cara meminta pemprosesan serentak antara muka pihak ketiga dalam Node.

1. Node.js meminta antara muka pihak ketiga

Sebagai platform terbuka, Node.js boleh mengakses dan memproses HTTP, HTTPS, TCP, UDP, DNS dan protokol rangkaian lain. Dalam pembangunan sebenar, kami biasanya menggunakan Node.js untuk memulakan permintaan HTTP, menghantar data kepada antara muka pihak ketiga dan menerima hasil pulangan. Alat permintaan HTTP yang paling biasa digunakan dalam Node.js ialah modul http dan https.

1. Gunakan alat permintaan HTTP

Membina permintaan HTTP biasanya memerlukan menyatakan kaedah permintaan, pengepala permintaan, isi permintaan dan maklumat lain. Dalam Node.js, kami boleh membina permintaan HTTP dengan:

const http = require('http');
const options = {
   hostname: 'www.example.com',
   port: 80,
   path: '/api/getdata',
   method: 'GET',
   headers: {
       'Content-Type': 'application/json',
       'Authorization': 'Bearer XXXXXXXXXXXX'
   }
};

const req = http.request(options, (res) => {
   console.log(`状态码：${res.statusCode}`);
   res.setEncoding('utf8');
   res.on('data', (chunk) => {
       console.log(`响应主体：${chunk}`);
   });
   res.on('end', () => {
       console.log('响应中已无数据。');
   });
});

req.on('error', (e) => {
   console.error(`请求遇到问题：${e.message}`);
});

// 写入数据到请求主体
req.write('{"username":"hello","password":"world"}');
req.end();

Dengan kaedah http.request(), kami boleh mencipta permintaan HTTP dan menggunakannya untuk berkomunikasi dengan pelayan. Kaedah ini mengandungi dua parameter: parameter pertama menentukan sasaran permintaan, yang merangkumi kaedah permintaan, pengepala permintaan, badan permintaan dan maklumat lain, parameter kedua ialah fungsi panggil balik yang digunakan untuk memproses objek tindak balas;

2. Gunakan alat permintaan https

Dalam permintaan HTTPS, teks sifir perlu dihantar, jadi kunci awam dan kunci peribadi perlu digunakan. Dalam Node.js, anda boleh menggunakan modul https untuk membuat permintaan HTTPS dengan sangat mudah, seperti yang ditunjukkan dalam contoh berikut:

const https = require('https');
const options = {
   hostname: 'www.example.com',
   port: 443,
   path: '/api/getdata',
   method: 'GET',
   headers: {
       'Content-Type': 'application/json',
       'Authorization': 'Bearer XXXXXXXXXXXX'
   }
};

const req = https.request(options, (res) => {
   console.log(`状态码：${res.statusCode}`);
   res.setEncoding('utf8');
   res.on('data', (chunk) => {
       console.log(`响应主体：${chunk}`);
   });
   res.on('end', () => {
       console.log('响应中已无数据。');
   });
});

req.on('error', (e) => {
   console.error(`请求遇到问题：${e.message}`);
});

// 写入数据到请求主体
req.write('{"username":"hello","password":"world"}');
req.end();

2. Node.js meminta antara muka pihak ketiga pemprosesan serentak

dalam pembangunan sebenar , kecekapan satu permintaan akan menjadi agak rendah, kerana apabila meminta antara muka pihak ketiga, ia memerlukan banyak masa untuk menunggu respons. Menghantar berbilang permintaan pada masa yang sama boleh meningkatkan kecekapan pemprosesan data. Dalam Node.js, berbilang kaedah boleh digunakan untuk melaksanakan permintaan serentak, seperti Janji, async/menunggu, mendengar acara, dsb.

1. Kaedah Promise

Gunakan Promise.all() untuk membuat permintaan serentak, bungkus data permintaan ke dalam tatasusunan dan hantarkannya pada masa yang sama, dan kemudian tunggu semua permintaan untuk dibalas sebelum diproses, yang boleh meningkatkan kecekapan pemprosesan. Berikut ialah contoh mudah untuk menggambarkan pelaksanaan kaedah Promise:

const request = require('request-promise');

//多个请求
const requests = [
   request('https://api.example.com/1'),
   request('https://api.example.com/2'),
   request('https://api.example.com/3')
];

//并发处理多个请求
Promise.all(requests)
   .then((results) => {
       console.log('所有请求完成.');
       // 处理请求结果
   })
   .catch((error) => {
       console.error(`请求错误：${error}`);
   });

2 kaedah async/wait

kaedah async/wait ialah alternatif kepada rantai Promise, yang membenarkan kod untuk melihat. Ia kelihatan lebih mudah dibaca dan ringkas. Apabila melaksanakan permintaan serentak, kami boleh menggunakan async/waiit untuk melaksanakan berbilang permintaan pada masa yang sama dan menunggu salah satu permintaan untuk mengembalikan data melalui Promise.race, seperti berikut:

const request = require('request-promise');

//多个请求
const requests = [
   request('https://api.example.com/1'),
   request('https://api.example.com/2'),
   request('https://api.example.com/3')
];

//异步处理多个请求
async function getMultipleData() {
   try {
       const result = await Promise.race(requests);
       console.log(`获取数据成功：${result}`);
   } catch (error) {
       console.error(`获取数据失败：${error}`);
   }
}

getMultipleData();

3

Menggunakan mendengar acara ialah cara lain untuk mengendalikan permintaan serentak Dalam Node.js, EventEmitter ialah API standard untuk mengendalikan acara Melalui EventEmitter kami boleh menyesuaikan acara dan pencetus peristiwa. Berikut menunjukkan contoh penggunaan EventEmitter untuk memantau peristiwa kejayaan dan ralat:

const request = require('request');

const emitter = new EventEmitter();

// 多个请求
const urls = ['https://api.example.com/1', 'https://api.example.com/2', 'https://api.example.com/3'];
let counter = 0;

// 逐个请求，每个请求完成时触发success和error事件
for (let i = 0; i < urls.length; i++) {
   request(urls[i], (error, response, body) => {
       if (!error && response.statusCode === 200) {
           counter++;
           emitter.emit('success', body);
       } else {
           emitter.emit('error', error);
       }
   });
}

// 监听success和error事件
emitter.on('success', (data) => {
   console.log(data);
   // 按照计数器判断是否所有请求完成
   if (counter === urls.length) {
       console.log('所有请求完成.');
   }
});
emitter.on('error', (error) => {
   console.error(`请求遇到问题：${error}`);
});

3. Ringkasan

Sebagai bahasa pengaturcaraan tak segerak, Node.js mempunyai keupayaan pemprosesan serentak yang kuat Digunakan untuk membuat permintaan serentak apabila meminta API atau antara muka pihak ketiga untuk meningkatkan prestasi dan kelajuan tindak balas. Artikel ini memfokuskan pada cara meminta pemprosesan serentak antara muka pihak ketiga dalam Node.js, menggunakan Janji, async/menunggu dan pemantauan acara untuk melaksanakan permintaan serentak. Dalam projek sebenar, anda perlu memilih cara terbaik untuk mengendalikan permintaan serentak berdasarkan keperluan sebenar untuk mencapai hasil yang terbaik.

Atas ialah kandungan terperinci nodejs meminta konkurensi antara muka pihak ketiga. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!