nodejs demande la concurrence d'interface tierce

Node.js est un langage de programmation asynchrone JavaScript ouvert et flexible. Ses puissantes capacités de traitement de tâches simultanées offrent des possibilités illimitées aux développeurs. En particulier lorsque nous demandons des API ou des interfaces tierces, nous avons souvent besoin de requêtes simultanées pour améliorer les performances et la vitesse de réponse. Par conséquent, cet article se concentrera sur la façon de demander le traitement simultané d’interfaces tierces dans Node.

1. Node.js demande une interface tierce

Node.js en tant que plate-forme ouverte peut accéder et traiter HTTP, HTTPS, TCP, UDP, DNS et d'autres protocoles réseau. Dans le développement réel, nous utilisons généralement Node.js pour lancer des requêtes HTTP, transmettre des données à des interfaces tierces et recevoir les résultats de retour. Les outils de requête HTTP les plus couramment utilisés dans Node.js sont les modules http et 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();

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

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

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

3、事件实现方式

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

1. Utilisez l'outil de requête HTTP

Pour construire une requête HTTP, vous devez généralement spécifier la méthode de requête, l'en-tête de la requête, le corps de la requête et d'autres informations. Dans Node.js, nous pouvons construire une requête HTTP de la manière suivante :

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

Avec la méthode http.request(), nous pouvons créer une requête HTTP et utiliser cette requête pour communiquer avec le serveur . Cette méthode contient deux paramètres : le premier paramètre spécifie la cible de la demande, qui comprend la méthode de la demande, l'en-tête de la demande, le corps de la demande et d'autres informations ; le deuxième paramètre est une fonction de rappel utilisée pour traiter l'objet de réponse ; 🎜🎜2. Utilisez l'outil de requête https🎜🎜Dans la requête HTTPS, le texte chiffré doit être transmis, donc la clé publique et la clé privée doivent être utilisées. Dans Node.js, vous pouvez utiliser le module https pour effectuer des requêtes HTTPS très facilement, comme le montre l'exemple suivant : 🎜rrreee🎜2 Node.js demande des interfaces tierces pour un traitement simultané🎜🎜. Dans le développement réel, une seule requête L'efficacité sera relativement faible, car lors de la demande d'une interface tierce, il faut beaucoup de temps pour attendre une réponse. L'envoi de plusieurs requêtes en même temps peut grandement améliorer l'efficacité du traitement des données. Dans Node.js, plusieurs méthodes peuvent être utilisées pour implémenter des requêtes simultanées, telles que Promise, async/await, écoute d'événements, etc. 🎜🎜1. Méthode Promise🎜🎜Utilisez Promise.all() pour effectuer des requêtes simultanées, regroupez les données de la requête dans un tableau et envoyez-les en même temps, puis attendez que toutes les requêtes reçoivent une réponse avant de les traiter, ce qui peut améliorer considérablement l'efficacité du traitement. Voici un exemple simple pour illustrer l'implémentation de la méthode Promise : 🎜rrreee🎜2. Méthode async/await 🎜🎜La méthode async/await est une alternative à la chaîne Promise, qui peut rendre le code plus lisible et concis. Lors de la mise en œuvre de requêtes simultanées, nous pouvons utiliser async/await pour exécuter plusieurs requêtes en même temps et attendre que l'une des requêtes renvoie des données via Promise.race, comme suit :🎜rrreee🎜Méthode d'implémentation d'événement🎜🎜Utilisation de l'événement. l'écoute consiste à gérer les requêtes simultanées. Une autre méthode, dans Node.js, EventEmitter est une API standard pour gérer les événements. Grâce à EventEmitter, nous pouvons personnaliser les événements et les déclencheurs d'événements. Ce qui suit montre un exemple d'utilisation de EventEmitter pour surveiller les événements de réussite et d'erreur : 🎜rrreee🎜 3. Résumé 🎜🎜Node.js, en tant que langage de programmation asynchrone, possède de puissantes capacités de traitement simultané et est souvent utilisé dans Effectuez des requêtes simultanées lorsque vous demandez des API ou des interfaces tierces pour améliorer les performances et la réactivité. Cet article se concentre sur la façon de demander un traitement simultané d'interfaces tierces dans Node.js, en utilisant Promise, async/await et la surveillance des événements pour implémenter des requêtes simultanées. Dans les projets réels, vous devez choisir la meilleure façon de gérer les demandes simultanées en fonction des besoins réels pour obtenir les meilleurs résultats. 🎜

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!