nodejs sendet mehrere http-Anfragen

Mit der Entwicklung des Internets, dem technologischen Fortschritt und dem kontinuierlichen Aufkommen von Internetanwendungen stellen die Menschen immer höhere Anforderungen an die Netzwerkkommunikation. Unter diesen Netzwerkkommunikationen ist das http-Protokoll die am häufigsten verwendete Methode. In NodeJS können wir problemlos HTTP-Anfragen senden, um eine Netzwerkkommunikation zu erreichen. In diesem Artikel wird erläutert, wie Sie mit NodeJS mehrere HTTP-Anfragen senden.

1. http-Modul

In nodejs ist das http-Modul ein Modul zur Verarbeitung des http-Protokolls. Es bietet einige praktische APIs zum Erstellen von HTTP-Servern und -Clients, zur Verarbeitung eingehender HTTP-Anforderungen und zum Senden von HTTP-Anforderungen.

Zwei Methoden können zum Senden von http-Anfragen mithilfe des http-Moduls verwendet werden:

• http.request(options[, callback]): Wird zum Senden von http-Anfragen und zum Zurückgeben eines http.ClientRequest-Objekts verwendet, das einige Methoden zum Konfigurieren von Anfragen bereitstellt , Anfragen senden und Antworten verarbeiten.
• http.get(options[, callback]): Wird zum Senden von http-GET-Anfragen verwendet. Diese Methode ist ein Wrapper der http.request-Methode. Anfragen können vereinfacht werden und Anfrageparameter werden im URL-Format bereitgestellt.

2. Promise

Wir wissen, dass asynchrone Programmierung eine sehr häufige Programmiermethode in NodeJS ist, daher können wir Promise verwenden, um die asynchrone Programmierung mehrerer http-Anfragen durchzuführen.

Promise ist ein Objekt, das zukünftige Ergebnisse darstellt, und Promise selbst ist ein Konstruktor, der einen Funktionsparameter empfängt. Die Funktion verfügt über zwei Parameter: Auflösung und Ablehnung, die jeweils Erfolgs- und Fehlerrückruffunktionen darstellen.

Der Vorteil der Verwendung von Promise besteht darin, dass es das Callback-Höllenproblem lösen und den Code lesbarer und wartbarer machen kann.

3. async/await

Der in ES6 eingeführte async/await-Syntaxzucker ermöglicht es uns, asynchrone Programmierung ohne Verwendung von Promise zu implementieren, wodurch der Code prägnanter und klarer wird.

async/await vereinfacht und kapselt tatsächlich Promise. Es verwendet das Schlüsselwort async, um eine asynchrone Funktion zu deklarieren, und verwendet dann das Schlüsselwort „await“, um auf das Ergebnis der asynchronen Operation zu warten, damit die Ausführung des Programms ausgeführt werden kann Bestellung und Rückrufe werden vermieden.

Im Folgenden verwenden wir Promise und async/await, um mehrere http-Anfragen zu senden.

4. Beispiel für die Verwendung von Promise zum Senden mehrerer http-Anfragen

Wir gehen davon aus, dass wir http-Anfragen an mehrere Websites stellen und die von diesen Websites zurückgegebenen Ergebnisse zusammenführen möchten.

Wir erstellen zunächst ein Array, um die Ziel-URL und die Anforderungsmethode dieser Anforderungen zu speichern (hier verwenden wir die GET-Methode), wie unten gezeigt:

const targets = [
    {url: 'https://www.baidu.com', method: 'GET'},
    {url: 'https://www.google.com', method: 'GET'},
    {url: 'https://www.bing.com', method: 'GET'},
];

Dann definieren wir eine Funktion, die eine Ziel-URL und eine Anforderungsmethode empfängt, und Gibt ein Promise-Objekt zum Senden von HTTP-Anfragen und zum Verarbeiten von Antworten zurück. Die Implementierung der Funktion ist wie folgt:

const http = require('http');

function sendRequest(target) {
    return new Promise((resolve, reject) => {
        const req = http.request(target, res => {
            let result = '';
            res.setEncoding('utf8');
            res.on('data', chunk => {
                result += chunk;
            });
            res.on('end', () => {
                resolve(result);
            });
        });
        req.on('error', err => {
            reject(err);
        });
        req.end();
    });
}

In der obigen Funktion verwenden wir die Methode http.request, um eine http-Anfrage zu senden und die Antwortdaten über das Ereignis res.on('data', ...) zu empfangen Verarbeitungsfunktion und über res. Die Ereignisbehandlungsfunktion on('end', ...) verarbeitet die Logik nach dem Ende der Antwort und gibt schließlich die empfangenen Antwortdaten als Ergebnis von Promise zurück.

Mit dem folgenden Code können wir testen, ob diese Funktion ordnungsgemäß funktioniert.

sendRequest({url: 'https://www.baidu.com', method: 'GET'})
    .then(result => {
         console.log(result);
     })
     .catch(err => {
          console.error('An error occurred:', err);
     });

Wir können jetzt eine Funktion definieren, die mehrere Ziel-URLs und Anforderungsmethoden akzeptiert und ein Promise-Objekt zum Senden mehrerer http-Anfragen und zum Zusammenführen ihrer Ergebnisse zurückgibt. Die Implementierung der Funktion ist wie folgt:

function sendMultiRequests(targets) {
    return Promise.all(targets.map(target => {
        return sendRequest(target);
    }));
}

In der obigen Funktion verwenden wir die Promise.all-Methode, um mehrere Promise-Objekte in ein neues Promise-Objekt zu kapseln. Wenn alle aktuellen Promise-Objekte erfolgreich sind, sind die zurückgegebenen Promise-Objekte erfolgreich Wenn jedes Versprechen fehlschlägt, schlägt auch das zurückgegebene Versprechen fehl.

Mit dieser Funktion können wir jetzt mehrere http-Anfragen senden und deren Ergebnisse zusammenführen.

sendMultiRequests(targets)
    .then(results => {
        console.log('All requests completed.');
        console.log('Results:');
        console.log(results);
    })
    .catch(err => {
        console.error('An error occurred:', err);
    });

Wenn alle http-Anfragen abgeschlossen sind, führen wir ihre Ergebnisse zusammen und drucken sie aus.

5. Beispiel für die Verwendung von async/await zum Senden mehrerer http-Anfragen

In ES6 können wir die async/await-Syntax verwenden, um asynchrone Programmierung zu implementieren. Wir können den obigen Code mit async/await implementieren. Der Kern dieser Implementierung besteht darin, Promise als asynchrone Funktion zu kapseln und das Schlüsselwort „await“ zu verwenden, um auf den Abschluss asynchroner Vorgänge zu warten.

Das Folgende ist ein Beispiel für die Verwendung von async/await zum Senden mehrerer http-Anfragen.

async function sendRequests(targets) {
    const results = await Promise.all(targets.map(async target => {
        const result = await sendRequest(target);
        return result;
    }));
    return results;
}

Im obigen Code definieren wir eine asynchrone Funktion sendRequests, um mehrere http-Anfragen zu senden und auf deren Ergebnisse zu warten. Die Promise.all-Methode gibt ein Promise-Objekt zurück, wenn alle Promises erfolgreich sind. Wenn ein Promise fehlschlägt, schlägt das zurückgegebene Promise fehl. Wir verwenden das Schlüsselwort „await“, um auf die Fertigstellung des Promise-Objekts zu warten und das Ergebnis direkt dem Ergebnisarray zuzuweisen.

Mit dem folgenden Code können wir testen, ob diese asynchrone Funktion ordnungsgemäß funktioniert.

sendRequests(targets)
    .then(results => {
        console.log('All requests completed.');
        console.log('Results:');
        console.log(results);
    })
    .catch(err => {
        console.error('An error occurred:', err);
    });

Wenn alle http-Anfragen abgeschlossen sind, führen wir ihre Ergebnisse zusammen und drucken sie aus.

6. Zusammenfassung

In diesem Artikel werden zwei Möglichkeiten zum Senden mehrerer HTTP-Anfragen mithilfe von NodeJS vorgestellt. Die erste Möglichkeit besteht darin, mit Promise mehrere http-Anfragen zu senden und deren Ergebnisse zusammenzuführen. Die zweite Möglichkeit besteht darin, mithilfe der Async/Await-Syntaxzucker mehrere HTTP-Anfragen zu senden und auf deren Ergebnisse zu warten. Unabhängig davon, ob Sie Promise oder Async/Await verwenden, können Sie problemlos die asynchrone Programmierung mehrerer http-Anfragen implementieren und so den Code besser lesbar und wartbar machen.

Das obige ist der detaillierte Inhalt vonnodejs sendet mehrere http-Anfragen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!