nodejs fordert die Parallelität der Schnittstelle von Drittanbietern an-Front-End-Fragen und Antworten-php.cn

Node.js ist eine offene und flexible asynchrone JavaScript-Programmiersprache. Ihre leistungsstarken Funktionen zur gleichzeitigen Aufgabenverarbeitung bieten Entwicklern unbegrenzte Möglichkeiten. Insbesondere bei der Anforderung von APIs oder Schnittstellen von Drittanbietern benötigen wir häufig gleichzeitige Anforderungen, um die Leistung und Antwortgeschwindigkeit zu verbessern. Daher konzentriert sich dieser Artikel auf die Anforderung der gleichzeitigen Verarbeitung von Schnittstellen von Drittanbietern in Node.

1. Node.js fordert eine Schnittstelle von Drittanbietern an.

Node.js kann als offene Plattform auf HTTP, HTTPS, TCP, UDP, DNS und andere Netzwerkprotokolle zugreifen und diese verarbeiten. In der tatsächlichen Entwicklung verwenden wir normalerweise Node.js, um HTTP-Anfragen zu initiieren, Daten an Schnittstellen von Drittanbietern zu übergeben und Rückgabeergebnisse zu erhalten. Die am häufigsten verwendeten HTTP-Anfragetools in Node.js sind die Module http und https. http和https模块。

1、使用HTTP请求工具

构建一个HTTP请求通常需要指定请求方法、请求头、请求体等信息。在Node.js中，我们可以通过以下方式构建一个HTTP请求：

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();

Nach dem Login kopieren

通过http.request()方法，我们可以创建一个HTTP请求，并使用该请求与服务器进行通信。此方法包含两个参数：第一个参数指定请求目标，其中包括请求方法、请求头、请求体等信息；第二个参数是一个回调函数，用于处理响应对象。

2、使用https请求工具

在HTTPS请求中，需要传输密文，因此需要使用公钥和私钥。在Node.js中，使用https模块可以非常方便地进行HTTPS请求，如下示例：

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();

Nach dem Login kopieren

二、Node.js请求第三方接口并发处理

在实际开发中，单个请求效率会比较低下，因为在请求第三方接口时，需要花费很多时间来等待响应。而将多个请求同时发送，则可以极大地提高数据处理的效率。在Node.js中，实现并发请求可以使用多种方式，如Promise，async/await，事件监听等。

1、Promise方式

使用Promise.all()进行并发请求，将请求数据打包成数组同时发出，然后等待所有请求得到相应之后再进行处理，这样能够大大提高处理效率。下面以一个简单的例子来说明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}`);
   });

Nach dem Login kopieren

2、async/await方式

async/await方式是一种Promise链的替代方式，它可以让代码看起来更加易读和简洁。在实现并发请求时，我们可以使用async/await同时执行多个请求，并通过Promise.race等待其中某个请求返回数据，如下：

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();

Nach dem Login kopieren

3、事件实现方式

使用事件监听是处理并发请求的另一种方法，在Node.js中，EventEmitter是处理事件的标准API，通过EventEmitter我们可以自定义事件和事件触发。下面展示了一个使用EventEmitter

1. Verwenden Sie das HTTP-Anfragetool

Um eine HTTP-Anfrage zu erstellen, müssen Sie normalerweise die Anfragemethode, den Anfrageheader, den Anfragetext und andere Informationen angeben. In Node.js können wir eine HTTP-Anfrage auf folgende Weise erstellen:

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

Nach dem Login kopieren

Mit der Methode http.request() können wir eine HTTP-Anfrage erstellen und diese Anfrage zur Kommunikation mit dem Server verwenden . Diese Methode enthält zwei Parameter: Der erste Parameter gibt das Anforderungsziel an, das die Anforderungsmethode, den Anforderungsheader, den Anforderungstext und andere Informationen umfasst. Der zweite Parameter ist eine Rückruffunktion, die zum Verarbeiten des Antwortobjekts verwendet wird. 🎜🎜2. Verwenden Sie das https-Anfragetool🎜🎜Bei der HTTPS-Anfrage muss Chiffretext übertragen werden, daher müssen ein öffentlicher Schlüssel und ein privater Schlüssel verwendet werden. In Node.js können Sie das https-Modul verwenden, um ganz bequem HTTPS-Anfragen zu stellen, wie im folgenden Beispiel gezeigt: 🎜rrreee🎜2. Node.js fordert Schnittstellen von Drittanbietern zur gleichzeitigen Verarbeitung an🎜🎜 In der tatsächlichen Entwicklung ist die Effizienz einer einzelnen Anfrage relativ gering, da das Warten auf eine Antwort beim Anfordern einer Schnittstelle eines Drittanbieters viel Zeit in Anspruch nimmt. Das gleichzeitige Senden mehrerer Anfragen kann die Effizienz der Datenverarbeitung erheblich verbessern. In Node.js können mehrere Methoden verwendet werden, um gleichzeitige Anforderungen zu implementieren, z. B. Promise, Async/Await, Event Listening usw. 🎜🎜1. Promise-Methode🎜🎜Verwenden Sie Promise.all(), um gleichzeitige Anfragen zu stellen, die Anfragedaten in ein Array zu packen und gleichzeitig zu versenden, und warten Sie dann, bis alle Anfragen beantwortet sind, bevor Sie sie verarbeiten die Verarbeitungseffizienz erheblich verbessern. Das Folgende ist ein einfaches Beispiel, um die Implementierung der Promise-Methode zu veranschaulichen: 🎜rrreee🎜2. Die async/await-Methode 🎜🎜async/await-Methode ist eine Alternative zur Promise-Kette, die den Code lesbarer und prägnanter machen kann. Bei der Implementierung gleichzeitiger Anforderungen können wir async/await verwenden, um mehrere Anforderungen gleichzeitig auszuführen, und wie folgt darauf warten, dass eine der Anforderungen Daten über Promise.race zurückgibt:🎜rrreee🎜3 Ereignisimplementierungsmethode🎜🎜Verwenden von Ereignis Zuhören dient der Verarbeitung gleichzeitiger Anforderungen. Eine weitere Methode in Node.js ist EventEmitter, eine Standard-API zur Verarbeitung von Ereignissen. Über EventEmitter können wir Ereignisse und Ereignisauslöser anpassen. Das Folgende zeigt ein Beispiel für die Verwendung von EventEmitter zur Überwachung von Erfolgs- und Fehlerereignissen: 🎜rrreee🎜 3. Zusammenfassung 🎜🎜Node.js verfügt als asynchrone Programmiersprache über leistungsstarke Fähigkeiten zur gleichzeitigen Verarbeitung und wird häufig in verwendet Stellen Sie gleichzeitige Anfragen, wenn Sie APIs oder Schnittstellen von Drittanbietern anfordern, um die Leistung und Reaktionsfähigkeit zu verbessern. Dieser Artikel konzentriert sich darauf, wie Sie die gleichzeitige Verarbeitung von Schnittstellen von Drittanbietern in Node.js anfordern und dabei Promise, Async/Await und Ereignisüberwachung verwenden, um gleichzeitige Anforderungen zu implementieren. In tatsächlichen Projekten müssen Sie basierend auf den tatsächlichen Anforderungen die beste Methode zur Bearbeitung gleichzeitiger Anforderungen auswählen, um die besten Ergebnisse zu erzielen. 🎜

Das obige ist der detaillierte Inhalt vonnodejs fordert die Parallelität der Schnittstelle von Drittanbietern an. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!